【GO学习二】包,函数,常量和变量

主要介绍go语言的基本元素,包引入,变量,函数声明

引入包:

go语言通过import引入包
最佳实践:import顺序:系统package,第三方package,程序自己的package

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package main
import (
"fmt"
"math"
)
func main() {
fmt.Printf("math test number %g ",math.Sqrt(7))
}
# 运行输出
cuixiaozhuai:main cuixiaohuan$ ./hello
math test number 2.6457513110645907

函数定义

go中函数可以没有参数或者接受多个参数

基本格式

1
2
func xx(AA type,aa) Type {
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package main
import (
"fmt"
)
func funcNoParams() string {
return "Hello no params func"
}
func add(x int, y int) int {
return x + y
}
func main() {
fmt.Println(funcNoParams())
fmt.Println(add(3, 3))
}
cuixiaozhuai:main cuixiaohuan$ ./hello
Hello no params func
6

func 可以多值返回

1
2
3
4
5
6
7
8
9
10
11
func swap(a, b string) (string, string) {
return b, a
}
func main() {
a, b := swap("cuihuan_first", "cuihuan_second");
fmt.Println(a, b)
}
cuixiaozhuai:main cuixiaohuan$ ./hello
cuihuan_second cuihuan_first

变量操作

go 中通过var 定义变量,参数在前,类型在后

1
2
3
4
5
6
7
8
9
10
var boolVal, boolVal2 bool
func main() {
var intVal int
var stringVal string
fmt.Println(boolVal, boolVal2, intVal, stringVal)
}
cuixiaozhuai:main cuixiaohuan$ ./hello
false false 0

变量默认值

没有赋值的时候会给上默认值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
var boolVal, boolVal2 bool = true, false
func main() {
// 声明类型
var intVal int = 33
var stringVal string = "xiaozhuai string"
fmt.Println(boolVal, boolVal2, intVal, stringVal)
// 不声明类型
var undefineType1,undefineType2,undefineType3 = "yo yo yo","qiekenao",666
fmt.Println(undefineType1, undefineType2, undefineType3)
}
cuixiaozhuai:main cuixiaohuan$ ./hello
true false 33 xiaozhuai string
yo yo yo qiekenao 666

:= 赋值

函数中的赋值可以用 :=代替var 【:= 标示声明又赋值,但是只能用于函数内】

1
2
3
4
5
6
7
8
9
10
11
12
var boolVal, boolVal2 bool = true, false
func main() {
// 声明类型
var intVal int = 33
var stringVal string = "xiaozhuai string"
fmt.Println(boolVal, boolVal2, intVal, stringVal)
// 不声明类型 := 声明赋值
undefineType1,undefineType2,undefineType3 := "yo yo yo","qiekenao",666
fmt.Println(undefineType1, undefineType2, undefineType3)
}

注意:= 简介赋值,但是无法,声明,赋值,定义类型。和var的区别
函数外,必须用var func等等

变量基本类型

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
func main() {
// go 变量全部类型和默认值
var boolVal bool
fmt.Println("bool default:",boolVal)
var stringVal string
fmt.Println("string default:",stringVal)
// int 在32位上默认32 64位默认64,uint 和 uintptr类似
var intVal int
var int8Val int8
var int16Val int16
var int32Val int32
var int64Val int64
fmt.Println("int default:",intVal)
fmt.Println("int8 default:",int8Val)
fmt.Println("int16 default:",int16Val)
fmt.Println("int32 default:",int32Val)
fmt.Println("int64 default:",int64Val)
fmt.Println("max int 64:", uint64(1<<64-1))
var uintVal uint
var uint8Val uint8
var uint16Val uint16
var uint32Val uint32
var uint64Val uint64
var uintptrVal uintptr
fmt.Println("uint default:",uintVal)
fmt.Println("uint8 default:",uint8Val)
fmt.Println("uint16 default:",uint16Val)
fmt.Println("uint32 default:",uint32Val)
fmt.Println("uint64 default:",uint64Val)
fmt.Println("uintptr default:",uintptrVal)
// uint8 别名
var byteVal byte
fmt.Println("byte default:",byteVal)
// int 32 别名,代表一个unicode
var runeVal rune
fmt.Println("rune default:",runeVal)
// int 32 别名,代表一个unicode
var floatVal float32
fmt.Println("floatVal default:",floatVal)
// int 32 别名,代表一个unicode
var complexVal complex64
fmt.Println("complex64Val default:",complexVal)
}
cuixiaozhuai:main cuixiaohuan$ ./hello
bool default: false
string default:
int default: 0
int8 default: 0
int16 default: 0
int32 default: 0
int64 default: 0
max int 64: 18446744073709551615
uint default: 0
uint8 default: 0
uint16 default: 0
uint32 default: 0
uint64 default: 0
uintptr default: 0
byte default: 0
rune default: 0
floatVal default: 0
complex64Val default: (0+0i)

int 类型的零值 是0 bool 默认false 字符串为”” 空字符串

18446744073709551615 byte 到底多大 【2097152TB】
int 64 可以表示200wTB的数据,那么问题来了,PB的数据如何表示,float
这里也可以通俗的理解下:数据库中的int(11)类型作为主键,基本不用担心满,200wTB*8 的数据量,足以

变量类型推导:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
func main() {
v := 666
f := 666.666
s := "string 666"
i := v
fmt.Printf("666 is of type %T\n", v)
fmt.Printf("666.666 is of type %T\n", f)
fmt.Printf("'string666' is of type %T\n", s)
fmt.Printf("传递 is of type %T\n", i)
}
# 需要注意的是,go中属于强类型,一旦定义之后就不允许改变为其他类型。
cuixiaozhuai:main cuixiaohuan$ ./hello
666 is of type int
666.666 is of type float64
'string666' is of type string
传递 is of type int

另外变量的官方参考文档:
https://golang.org/ref/spec#Constant_expressions

常量:const

go中常量不能用:=
go中常量可以是字符,字符串,布尔和数字类型的值

1
2
3
4
5
6
7
8
const PI = 3.14
func main() {
const test = "test const";
fmt.Println(test, PI);
}
cuixiaozhuai:main cuixiaohuan$ ./hello
test const 3.14

崔小拽 wechat
欢迎您扫一扫上面的微信公众号,订阅小拽的博客!