第一个go程序和基本语法
2024-08-31 03:40:02
第一个go程序和基本语法
一. 第一个go程序
//package 声明开头表示代码所属包
package main
//导入格式化包,引了必须用
import "fmt"
//左括号{不能单起一行
func main(){
fmt.Println("Go Lang, 开始浪吧~")
}
// "//"表示单行注释
// "*/ */"表示多行注释
二. 基础语法
1. 命名
go语言中的函数名、变量名、常量名、类型名、语句标号和包名等所有的命名,都遵循一个简单的命名规则
一个名字必须以一个字母或下划线开头,后面可以跟任意数量的字母、数字或下划线
go区分大小写,hello和Hello不一样
go语言中有25个关键字,不能用于自定义名字
break default func interface select
case defer go map struct
chan else goto package switch
const fallthrough if range type
continue for import return var
还有30多个预定义的名字,用于内建的常量、类型和函数
内建常量:
true false iota nil 内建类型:
int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr
float32 float64 complex128 complex64
bool byte rune string error 内建函数:
make len cap new append copy close delete
complex real imag
panic recover
2. 变量
2.1 声明变量:
//package 声明开头表示代码所属包
package main
import "fmt"
func main() {
//第一种:
var v1 int
var v2 int
//第二种:
var v3, v4 int
//第三种
var(
v5 int
v6 int
)
//零值
fmt.Println(v1, v2, v3, v4, v5, v6)
}
2.2 变量初始化
//package 声明开头表示代码所属包
package main
import (
"fmt"
"reflect"
)
func main() {
//方式一:
var v1 int = 10
//方式二:go编译器自动推到出变量类型
var v2 = 20
//方式三:声明加赋值, 必须在函数里面用
v3 := 30
fmt.Println(v1, v2, v3)
//利用反射查看变量类型
fmt.Println("v3的类型是", reflect.TypeOf(v3))
}
//10 20 30
//v3的类型是 int
2.3 变量赋值
//package 声明开头表示代码所属包
package main
import "fmt"
func main() {
//1. 直接赋值
var v1 int
v1 = 123
//2. 声明并赋值
i := 10
j :=20
//3. 多重赋值
var v2, v3, v4 int
v2, v3, v4 = 1, 2, 3
fmt.Println(v1, v2, v3, v4, i, j)
}
匿名变量:
//package 声明开头表示代码所属包
package main
import "fmt"
//(int, sting): 返回值类型
func test()(int, string){
return 666,"浪不浪"
}
func main() {
// "_"是特殊变量, 占位
_, s1 := test()
fmt.Println(s1)
a1, s1 := test()
fmt.Println(a1,s1)
}
//浪不浪
//666 浪不浪
.
//package 声明开头表示代码所属包
package main
import "fmt"
var abc = 456
func main() {
//定义
var a int
var s string
fmt.Println(a,s)
fmt.Printf("%d %q\n", a,s)
//定义多个
var c,b int = 3,4
fmt.Println(c,b)
//不指定类型定义, 可以写一行
j,k,q :=3,true,"xx"
fmt.Println(j,k,q)
}
//0
//0 ""
//3 4
//3 true xx
3 常量与枚举
//package 声明开头表示代码所属包
package main
import "fmt"
//常量 const
const filename = "luhan.txt"
////常量必须是可确定的数字, 字符串, 布尔值
//var a = "haha"
//const file2 = a
//定义函数, 函数内写常量
func consts() {
//多个常量
const (
XX = "haha1"
OO = "haha2"
filename = "haha3"
)
fmt.Println(XX, OO, filename)
}
//1. 定义枚举类型
func enums() {
const (
python = 0
java = 1
golang = 2
)
fmt.Println(python, java, golang)
}
//2. 自增的枚举类型
func enums1() {
const (
//iota关键字是自增
pyhton = iota
java
golang
)
fmt.Println(pyhton, java, golang)
}
//3. iota还可以参与计算
func enums2() {
const (
//位运算, n*2(10*1), 2^0 = 1
b = 1 << (10 * iota)
kb
mb
gb
tb
pb
)
fmt.Println(b, kb, mb, gb, tb, pb )
}
func main() {
consts()
enums1()
enums2()
}
//haha1 haha2 haha3
//0 1 2
//1 1024 1048576 1073741824 1099511627776 1125899906842624
4. 数据类型
u开头是无符号类型
8,16,32这些,最大最用是增加可移植性和维护性
short int long
类型名称 有无符号 bit数
int8 Yes 8
int16 Yes 16
int32 Yes 32
int64 Yes 64
uint8 No 8
uint16 No 16
uint32 No 32
uint64 No 64
int Yes 等于cpu位数
uint No 等于cpu位数
rune Yes 与 int32 等价
byte No 与 uint8 等价
uintptr No -
.
//package 声明开头表示代码所属包
package main
import (
"fmt"
"reflect"
)
func main() {
//1.整型
var v1 int32
v1 = 123
v2 := 64
fmt.Println(v1,v2)
//默认是int
fmt.Println(reflect.TypeOf(v2))
//2.浮点型
var f1 float32
f1 = 12
fmt.Println(f1)
f2 := 12.0
fmt.Println(reflect.TypeOf(f2))
//3.布尔型
var b1 bool
b1 = true
fmt.Println(b1)
b2 := (1==2)
//打印类型
fmt.Println(reflect.TypeOf(b2))
//4.字符型
var ch byte
ch = 'a'
fmt.Println(ch)
fmt.Printf("ch = %c",ch)
//5.字符串
var str string
str = "luhan"
s := str[0]
fmt.Println(s)
//反括号圈起来的字符串,原样输出
str2 := `hello
luhan \n \r xx
`
fmt.Println("str2=",str2)
}
//123 64
//int
//12
//float64
//true
//bool
//97
//ch = a108
//str2= hello
//luhan \n \r xx
5. fmt包的使用
输出:
//package 声明开头表示代码所属包
package main
import "fmt"
func main() {
//整型
a := 15
//%b:二进制
fmt.Printf("a = %b\n",a)
//只输出一个%
fmt.Printf("%%\n")
//字符
ch := 'a'
fmt.Printf("ch = %c,%d\n",ch,97)
//浮点
f := 3.14
//%g紧凑方式输出
fmt.Printf("f = %f,%g\n",f,f)
//布尔型
fmt.Printf("%t,%t\n",true,false)
//字符串
str := "hello.go"
fmt.Printf("str = %s\n",str)
}
//a = 1111
//%
//ch = a,97
//f = 3.140000,3.14
//true,false
//str = hello.go
输入:
//package 声明开头表示代码所属包
package main
import "fmt"
func main() {
//用户输入内容, 程序接收
var v int
//Print是不回车
fmt.Print("请输入一个整型:")
//直接输入
//如果不是int,输出零值
fmt.Scan(&v)
fmt.Println(v)
}
//请输入一个整型:5
//5
6. 类型别名
//package 声明开头表示代码所属包
package main
import (
"fmt"
"reflect"
)
func main() {
//type关键字定义别名
type myint int
var i myint = 100
fmt.Println(i)
fmt.Println(reflect.TypeOf(i))
}
//100
//main.myint
7. 类型转换
go类型转换不允许隐式转换
//package 声明开头表示代码所属包
package main
import "fmt"
func main() {
var ch byte = 'a'
var i int = int(ch)
fmt.Println(ch)
fmt.Println(i)
}
//97
//97
8. 运算符
算术运算符
+ 相加 A + B 输出结果 30
- 相减 A - B 输出结果 -10
* 相乘 A * B 输出结果 200
/ 相除 B / A 输出结果 2
% 求余 B % A 输出结果 0
++ 自增 A++ 输出结果 11
-- 自减 A-- 输出结果 9
关系运算符
== 检查两个值是否相等,如果相等返回 True 否则返回 False。 (A == B) 为 False
!= 检查两个值是否不相等,如果不相等返回 True 否则返回 False。 (A != B) 为 True
> 检查左边值是否大于右边值,如果是返回 True 否则返回 False。 (A > B) 为 False
< 检查左边值是否小于右边值,如果是返回 True 否则返回 False。 (A < B) 为 True
>= 检查左边值是否大于等于右边值,如果是返回 True 否则返回 False。 (A >= B) 为 False
<= 检查左边值是否小于等于右边值,如果是返回 True 否则返回 False。 (A <= B) 为 True
逻辑运算符
&& 逻辑 AND 运算符。 如果两边的操作数都是 True,则条件 True,否则为 False。 (A && B) 为 False
|| 逻辑 OR 运算符。 如果两边的操作数有一个 True,则条件 True,否则为 False。 (A || B) 为 True
! 逻辑 NOT 运算符。 如果条件为 True,则逻辑 NOT 条件 False,否则为 True。 !(A && B) 为 True
位运算符
& 按位与运算符"&"是双目运算符。 其功能是参与运算的两数各对应的二进位相与。 (A & B) 结果为 12, 二进制为 0000 1100
| 按位或运算符"|"是双目运算符。 其功能是参与运算的两数各对应的二进位相或 (A | B) 结果为 61, 二进制为 0011 1101
^ 按位异或运算符"^"是双目运算符。 其功能是参与运算的两数各对应的二进位相异或,当两对应的二进位相异时,结果为1。 (A ^ B) 结果为 49, 二进制为 0011 0001
<< 左移运算符"<<"是双目运算符。左移n位就是乘以2的n次方。 其功能把"<<"左边的运算数的各二进位全部左移若干位,由"<<"右边的数指定移动的位数,高位丢弃,低位补0。 A << 2 结果为 240 ,二进制为 1111 0000
>> 右移运算符">>"是双目运算符。右移n位就是除以2的n次方。 其功能是把">>"左边的运算数的各二进位全部右移若干位,">>"右边的数指定移动的位数。 A >> 2 结果为
赋值运算符
= 简单的赋值运算符,将一个表达式的值赋给一个左值 C = A + B 将 A + B 表达式结果赋值给 C
+= 相加后再赋值 C += A 等于 C = C + A
-= 相减后再赋值 C -= A 等于 C = C - A
*= 相乘后再赋值 C *= A 等于 C = C * A
/= 相除后再赋值 C /= A 等于 C = C / A
%= 求余后再赋值 C %= A 等于 C = C % A
<<= 左移后赋值 C <<= 2 等于 C = C << 2
>>= 右移后赋值 C >>= 2 等于 C = C >> 2
&= 按位与后赋值 C &= 2 等于 C = C & 2
^= 按位异或后赋值 C ^= 2 等于 C = C ^ 2
|= 按位或后赋值 C |= 2 等于 C = C | 2
其他
& 返回变量存储地址 &a; 将给出变量的实际地址。
* 指针变量。 *a; 是一个指针变量
最新文章
- 如何快速在当前目录打开cmd命令提示符
- top命令详解(转,详细)
- mapreduce.framework.name
- wordpress对显示某分类目录的文章列表页时对单个文章显示字数限制和省略
- Linux常用指令---find | locate(查找)
- 下拉列表联动显示(Car表) 三级联动
- HTTP协议分析及攻防方法
- 简单总结一下NotificationCenter、KVC、KVO、Delegate
- C/C++中字符串存储位置
- MS Server中varchar与nvarchar的区别
- 条款38 通过复合塑膜出has-a或&;quot;依据某物实现&;quot;
- PHP面向对象摘要
- [线段树]P1047 校门外的树
- 从.git文件夹探析git实现原理
- RequireJS中的require返回模块
- Python自动化中的元素定位xpath(二)
- ECS配置lamp环境
- Github提交本地代码
- c++输入输出流加速器
- Centos7 DNS神奇的配置