Go基础语法

1.变量/常量

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
# var name = expression 根据expression判断type
var a = "initial"
fmt.Println(a)

# var name type = expression
var b, c int = 1, 2
fmt.Println(b, c)

# go中的零值 数字 > 0 布尔 > false, 字符串 > "" 接口和引用类型(slice, 指针, map, 通道, 函数) > nil
# var name type
var e int
fmt.Println(e)

# 短变量 name := expression
# 短小灵活,在局部变量声明和初始化主要使用
f := "apple"
fmt.Println(f)

# 常量
# const name type = expression
const s string = "constant"
# iota常量生成器 从0开始
type Currency int
const (
USD Currency iota
EUR
RMB

2.if else

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
if 7 % 2 == 0 {
fmt.Println("7 is even")
} else {
fmt.Println("7 is odd")
}

if 8 % 4 == 0 {
fmt.Println("8 is divisible by 4")
}

if num := 9; num < 0 {
fmt.Println(num, "is negative")
} else if num < 10 {
fmt.Println(num, "has 1 digit")
} else {
fmt.Println(num, "has multiple digits")
}

3.switch

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
i := 2
fmt.Print("Write ", i, " as ")
switch i {
case 1:
fmt.Println("one")
case 2:
fmt.Println("two")
case 3:
fmt.Println("three")
}

switch time.Now().Weekday() {
case time.Saturday, time.Sunday:
fmt.Println("It's the weekend")
default:
fmt.Println("It's a weekday")
}

4.for

go中唯一的循环语句

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
i := 1
for i <= 3 {
fmt.Println(i)
i = i + 1
}

for j := 7; j <= 9; j++ {
fmt.Println(j)
}

for {
fmt.Println("loop")
break
}

for n := 0; n <= 5; n++ {
if n % 2 == 0 {
continue
}
fmt.Println(n)
}

5.数组

数组长度固定,本身不可变,无法添加或者删除元素, 所以使用场景较少

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 默认 初始值是零值
var a [3]int

# 下标和值
for i, v in range a {
fmt.Println("%d %d\n", i, v)
}

# 不关心下标
for _, v in range a {
fmt.Println("%d\n", v)
}

# 元素初始化
var q [3]int = [3]int{1, 2, 3}
var r [3]int = [3]int{1, 2}

# 数组的长度由初始化数组的元素个数决定
q := [...]int{1, 2, 3}

# 100个元素的数组,出了最后是-1以外,其余都是0
r := [...]int{99: -1}

6.slice

[]T 拥有相同类型可变长度的序列
var x []int
x[m:n] 返回原始字节的一个子序列
三个属性 指针 长度(len) 容量(cap)
slice包含了指向数组元素的指针,所以将一个slice传递给函数时,可以在函数内部修改底层数组的元素

1
2
3
4
# 数组 
var list = [3]int{1, 2, 3}
# slice
seq = list[1:2]

检查slice是否为空 len(s) == 0
不能用==比较slice slice的元素非直接,有可能包含自身
不能用作map的key 如果底层数组元素改变,同一个slice在不同时间有不同的元素

使用内建函数make创建一个具有指定元素类型,长度和容量的slice
make([]T, len)
make([]T, len, cap)

7.map

map[k]v 具有键值对元素的无序集合
map中所有key拥有相同的数据类型
所有的value拥有相同的数据类型
key的类型 必须可以通过==来进行比较

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
ages := make(map[string]int)
ages := make(map[string]int){
"alice": 24,
"charlie": 34
}


# 先声明 后赋值
ages := make(map[string]int)
ages["alice"] = 31
ages["charlie"] = 34

# 删除
delete(ages, "alice")

for name, age in range ages {
fmt.Println("%s\t%d\n", name, age)
}

var ages map[string]int
fmt.Println(ages==nil) # "true"
fmt.Println(len(ages) == 0) # "true"
ages["carol"] = 21 # 报错, map必须初始化, 才可以赋值

# 如果key不在map中,则得到map值类型的零值
# bob不是字典的键,age==0, ok判断key是否存在
age, ok = ags["bob"], !ok { /* ... */}

go中没有集合类型 > 用map来模拟

8.结构体

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
type Employee struct {
ID int
Name, Address string
DoB time.Time
Position string
Salary int
ManagerID int
}

var dilbert Employee

# 相关操作
disbert.Salary += 5000
# 取得地址
position = &disber.Position
# 赋值
*position = "Senior" + *position

# 成员变量 可以包含指针类型
type tree struct {
value int
left, right *tree
}


# 可作为指针传递
func Bonus(e *Employee, precent int) int {
return e.Salery * precent / 100
}

# 结构体成员变量首字母大写 > 可导出, 否则不可导出

# 匿名成员
type Point struct {
X, Y int
}

type Circle struct {
Point
Radius int
}

type Wheel struct {
Point
Spokes int
}

var w Wheel
w.X = 8 # 等价于w.Circle.Point.X = 8
坚持原创技术分享,您的支持将鼓励我继续创作!