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
18
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
22
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
28
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

Contents