这里写目录标题
- 一.昨日回顾
- 二.今日内容
- 1.变量命名规范
- 2.变量
- 代码演示
- 3.类型
- 代码演示
- 4.常量
- 5.函数基础
- 6.函数高级
一.昨日回顾
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
201 redis高级:高可用,集群,过期策略,缓存穿透,击穿,雪崩 2 go语言介绍 3 环境搭建:go的sdk(开发工具包,开发阶段用),IDE:集成开发环境(goland,vscode,txt) 4 go命令 -go build go源码编译成可执行文件(在什么平台就编译成什么平台) -go env go的环境变量 -GO111MODULE ：go 1.11以后，包管理使用go module -GOPATH：在不使用go module之前，所有，项目，源代码必须放在该路径下的src下 -GOROOT: go sdk的安装路径：C:Program FilesGo -go fmt 格式化代码 -go get 等同于pip3 install 获取第三方模块 -go没有一个集中的版本管理仓库（大家约定俗成把它放到github上） -go run 编译并执行（开发阶段） 5 go语言交叉编译 6 go hello world -一个go项目要运行，必须有个包main包，main包下的main函数，是整个项目的入口 -导入的包，必须使用，如果不使用，编译不通过 -func 声明函数 main函数 -fmt.Println("ssss") 等同于python中的print()内置函数
二.今日内容
1.变量命名规范
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
231 变量命名，推荐用驼峰 AgeOfXX== （变量，函数，大写字母开头表示导出，外部包可以使用） 2 go文件命名，推荐用下滑线 3 名字必须以一个字母（Unicode字母）或下划线开头，后面可以跟任意数量的字母、数字或下划线 4 不要用关键字和保留关键字作为变量名 5 大写字母和小写字母是不同的：Name和name是两个不同的变量 6 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 7 有37个保留字，主要对应内建的常量、类型和函数 内建常量: 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.变量
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18# 记住三种 -var a int =10 -var a =10 -a:=10 # 掌握定义多个 -var a,b int=10,11 -var a,b =10,11 -a,b:=10,11 # 了解其它方式 var ( name="lqz" age int ) # 注意点： 1 变量要先定义再使用 2 完整定义可以先定义再赋初值，后面两种方式，定义阶段必须赋初值 3 变量的类型一旦确定，后期不能修改(跟py最大的差距)
代码演示
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66package main //变量定义 func main() { // 第一种定义方式：完整定义 //var关键字 变量名 变量类型=变量值 //var a int =10 //第二种定义方式：类型推导 //var a =10 // 第三种：简略声明 := 是一起的不能隔开 //a := 10 //name := "lqz" //var name string="lqz" //var name ="lqz" //其它变形 //同时定义多个变量 //定义阶段初始化 //var name,age string="lqz","18" //先定义在初始化 //var name,age string //name="lqz" //age="18" //类型推导定义多个 //var name,age ="lqz",18 //这种方式不能先定义再初始化(变量再定义阶段就需要确定类型) //var name,age //name="lqz" //age=18 //简略声明 //name,age:="lqz",18 //了解 //var ( // name1 = "lqz" // name2 = "egon" // age int //) //fmt.Println(name1) //fmt.Println(name2) //fmt.Println(age) // 0 /* 变量定义注意点： 1 变量要先定义再使用 2 完整定义可以先定义再赋初值，后面两种方式，定义阶段必须赋初值 3 变量的类型一旦确定，后期不能修改(跟py最大的差距) */ //a:=10 a=10.01 //a="lqz" //fmt.Println(a) }
3.类型
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29# 数字类型 1 int类型（长度不一样） - int8（正负，2的7次方-1），int16（正负，2的15次方-1），int32（正负，2的31次方-1），int64 -int：在32位机器上是int32，在64位机器上是int64 2 uint类型（无符号） -uint8（2的8次方，256），uint16，uint32，uint64 -uint：在32位机器上是uint32，在64位机器上是uint64 3 float类型(表示精度不一样) -float32，float64 4 complex 复数类型（不知道）：实部和虚部，并返回一个复数类型 -complex64, complex128 5 byte -是 uint8 的别名 6 rune（go语言中的编码方式使用unicode编码） -是 int32的别名 # 字符串类型 1 string # 布尔类型 1 bool # 注意： 强类型语言：不同类型之间不允许直接运算 显示类型转换：手动转换
代码演示
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54package main import "fmt" func main() { //var a int8=128 //报错 //var a int16=128 //int64 //var a int = 9223372036854775807 //var a int64 = 9223372036854775807 //fmt.Println(a) //var a uint8=128 //fmt.Println(a) //var a float32=9.99 //var a float64=9.999999999 //c1 := complex(5, 7) //c2 := 8 + 27i //fmt.Println(c1+c2) //fmt.Printf("a的类型是：%T,a的值是%v",c1,c1) //打印变量类型 //fmt.Printf("a的类型是：%T,a的值是%v",a,a) //字符串(双引号，和反引号) //a:="lqz" // a:=`换行 // 换行阿斯顿发射点 //阿斯顿发顺丰` //单引号引起来的是一个字符 //a:='中' //int32类型 //a:='中' //fmt.Printf("a的类型是：%T,a的值是%v",a,a) // //var b bool=true //fmt.Println(b) //b=false //fmt.Printf("a的类型是：%T,a的值是%v",b,b) var a = 10.01 var b =10 //var c int8=9 //fmt.Println(a+float64(b)) fmt.Println(int(a)+b) //fmt.Println(b+int(c)) }
4.常量
复制代码
1
2
3# 恒定不变的量，定义并赋值后，再也不能改了 const name string="lqz"
5.函数基础
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69package main //函数 /* func关键字 函数名(参数1 参数类型，参数2 参数类型)(返回值类型1,返回值类型2){ } */ func main(){ //var a int=add(7,8) //a:=add(7,8) //有多个返回值，必须用多个值来接收 //a,b:=add(7,8) //有多个返回值，只要第一个 //a,_:=add(7,8) //var a,b=add(7,8) //var a int //var b string //a,b=add(7,8) //fmt.Println(a) //fmt.Println(b) } //1 最简单的函数 //func add(a int,b int) { // fmt.Println(a+b) //} //2 有1个返回值 //func add(a int,b int) int { //func add(a int,b int) (int) { // return a+b //} //2 有多个返回值 //func add(a int,b int) (int,string) { // return a+b,"成功" //} //3 多个参数，类型一致,可以省略前面的类型 //func add(a int ,b int){ //func add(a ,b int)int{ func add(a int,b string){ // return a+b //} //4 命名返回值（了解） //func add(a,b int) (int) { // c:=a+b // return c //} //func add(a,b int) (c int) { // //c:=a+b //重复定义 // c=a+b //内部不需要定义 // //return c //返回的时候，c可以省略 // return //返回的时候，c可以省略 //} //5 空白符 _ 忽略掉某个返回值
6.函数高级
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92package main import "fmt" //函数高级(都是按位置传，没有关键字一说) func main() { //test(1,2,5,6,7,8,8) //res:=find(10,1,2,43,54,6,7,8,9,10) //fmt.Println(res) //3 匿名函数 ，定义在函数内部 //定义一个匿名函数,加括号使用匿名函数 //func (){ // fmt.Println("我是匿名函数") //}() //把函数赋值给一个变量,并且执行 //var a func() //函数类型 //a = func() { // fmt.Println("aaaaa") //} //a() a是什么类型？定义出a来 //var a func()=test(10) //a() //fmt.Println(a) var f func(c int)int f=test(10,20) res:=f(30) fmt.Println(res) } //1 可变长参数(可以传任意长度的int类型) //func test(a... int) { // fmt.Println(a) //切片类型 // fmt.Println(a[0]) //} //2 案例：输入一个数字，和一堆数字，判断第一个数字在不在后面一堆中 //func find(a int,b ...int) string { // for i:=0;i<len(b);i++ { // if a==b[i]{ // return "在" // } // } // return "不在" //} // 3 匿名函数（没有名字的函数） // 4 闭包函数（定义在函数内部，对外部作用域有引用） // 函数可以赋值给一个变量：函数是一等公民，头等函数 //func test(c int) func() { // a:=func (){ // fmt.Println(c) // } // return a //} //5 更高级的使用 //func test(a func(func()),b func())(func(a,b int),func()) { // return func(a, b int) { // // }, func() { // // } //} //函数的参数和返回值都是类型的一部分 //func() //func(a int) //func(a int)int func test(a,b int)func(c int)int{ f:= func(c int) int{ return a+b } return f }
最后
以上就是义气鼠标最近收集整理的关于go语言值变量命名规范,定义变量,数据类型,常量,函数基础,函数高级一.昨日回顾二.今日内容的全部内容，更多相关go语言值变量命名规范,定义变量,数据类型,常量,函数基础,函数高级一内容请搜索靠谱客的其他文章。
本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
发表评论 取消回复