1
func main() {
2
  // 当i=5时就跳出for循环
3
  for i := 0; i < 10; i++ {
4
    if i == 5 {
5
      break // 跳出for循环
6
    }
7
    fmt.Println(i)
8
  }
9
  fmt.Println("over")
10

11
  // 当i=5时，跳过此次for循环（不执行for循环内部的打印语句），继续下一次循环
12
  for i := 0; i < 10; i++ {
13
    if i == 5 {
14
      continue // 继续下一次循环
15
    }
16
    fmt.Println(i)
17
  }
18
  fmt.Println("over")
19
}

1
func main() {
2
  // 1. & : 取地址
3
  n := 18
4
  p := &n // 只赋值地址，不重新创建对象
5
  fmt.Println(p)
6
  fmt.Printf("%T", p) // *int : int类型的指针
7

8
  // 2: *: 根据地址取值
9
  m := *p
10
  fmt.Println(m)
11
  fmt.Printf("%T", m) // *int : int类型的指针
12

13
  var a1 *int // nil pointer
14
  fmt.Println(a1)
15
  var a2 = new(int) // new函数申请一个内存地址
16
  fmt.Println(a2)
17
  fmt.Println(*a2)
18
  *a2 = 100
19
  fmt.Println(*a2)
20
  a3 := 200
21
  fmt.Println(a3)
22
}

1
func main() {
2
  var m1 map[string]int
3
  fmt.Println(m1 == nil)        // 还没有初始化（没有在内存中开辟空间）
4
  m1 = make(map[string]int, 10) // 要估算好该map容量，避免在程序运行期间再动态扩容
5
  m1["理想"] = 18
6
  m1["jiwuming"] = 35
7

8
  fmt.Println(m1)
9
  fmt.Println(m1["理想"])
10
  // 约定成俗用ok接收返回的布尔值
11
  fmt.Println(m1["娜扎"]) // 如果不存在这个key拿到对应值类型的零值
12
  value, ok := m1["娜扎"]
13
  if !ok {
14
    fmt.Println("查无此key")
15
  } else {
16
    fmt.Println(value)
17
  }
18

19
  // map的遍历
20
  for k, v := range m1 {
21
    fmt.Println(k, v)
22
  }
23
  // 只遍历key
24
  for k := range m1 {
25
    fmt.Println(k)
26
  }
27
  // 只遍历value
28
  for _, v := range m1 {
29
    fmt.Println(v)
30
  }
31
  // 删除
32
  delete(m1, "jiwuming")
33
  fmt.Println(m1)
34
  delete(m1, "沙河") // 删除不存在的key
35
}
36

37
func main() {
38
  rand.Seed(time.Now().UnixNano()) //初始化随机数种子
39

40
  var scoreMap = make(map[string]int, 200)
41

42
  for i := 0; i < 100; i++ {
43
    key := fmt.Sprintf("stu%02d", i) //生成stu开头的字符串
44
    value := rand.Intn(100)          //生成0~99的随机整数
45
    scoreMap[key] = value
46
  }
47

48
  fmt.Println(scoreMap)
49
  //取出map中的所有key存入切片keys
50
  var keys = make([]string, 0, 200)
51
  for key := range scoreMap {
52
    keys = append(keys, key)
53
  }
54
  // //对切片进行排序
55
  sort.Strings(keys)
56
  //按照排序后的key遍历map
57
  for _, key := range keys {
58
    fmt.Println(key, scoreMap[key])
59
  }
60
}

1
// map和slice组合
2
func main() {
3
  // 元素类型为map的切片
4
  var s1 = make([]map[int]string, 10, 20)
5
  fmt.Println(s1)
6
  // 没有对内部的map做初始化
7
  s1[0] = make(map[int]string, 1)
8
  s1[0][10] = "沙河"
9
  fmt.Println(s1)
10
  // 值为切片类型的map key为字符串类型，value为数组类型
11
  var m1 = make(map[string][]int, 10)
12
  m1["北京"] = []int{10, 20, 30}
13
  m1["北京"] = []int{10, 20, 30}
14
  fmt.Println(m1)
15
}

1
// 函数
2

3
// 函数存在的意义？
4
// 函数是一段代码的封装
5
// 把一段逻辑抽象出来封装到一个函数中，给它起个名字，每次用到它的时候直接用函数名调用就可以了
6
// 使用函数能够让代码结构更清晰、更简洁。
7

8
// 函数的定义
9
func sum(x int, y int) (ret int) {
10
  return x + y
11
}
12

13
// 没有返回值
14
func f1(x int, y int) {
15
  fmt.Println(x + y)
16
}
17

18
// 没有参数没有返回值
19
func f2() {
20
  fmt.Println("f2")
21
}
22

23
// 没有参数但有返回值的
24
func f3() int {
25
  ret := 3
26
  return ret
27
}
28

29
// 返回值可以命名也可以不命名
30

31
// 命名的返回值就相当于在函数中声明一个变量
32
func f4(x int, y int) (ret int) {
33
  ret = x + y
34
  return // 使用命名返回值可以return后省略
35
}
36

37
// 多个返回值
38
func f5() (int, string) {
39
  return 1, "沙河"
40
}
41

42
// 参数的类型简写:
43
// 当参数中连续多个参数的类型一致时，我们可以将非最后一个参数的类型省略
44
func f6(x, y, z int, m, n string, i, j bool) int {
45
  return x + y
46
}
47

48
// 可变长参数
49
// 可变长参数必须放在函数参数的最后
50
func f7(x string, y ...int) {
51
  fmt.Println(x)
52
  fmt.Println(y) // y的类型是切片 []int
53
}
54

55
// Go语言中函数没有默认参数这个概念
56

57
func main() {
58
  r := sum(1, 2)
59
  fmt.Println(r)
60

61
  _, n := f5()
62
  fmt.Println(n)
63

64
  f7("下雨了")
65
  f7("下雨了", 1, 2, 3, 4, 5, 6, 7)
66
}

1
func main() {
2
  //   var name string
3
  //   name = "理想"
4
  //   fmt.Println(name)
5
  //   var ages [30]int // 声明了一个变量ages,它是[30]int类型
6
  //   ages = [30]int{1, 2, 3, 4, 6}
7
  //   fmt.Println(ages)
8
  //   var ages2 = [...]int{1, 2, 3, 4, 5, 7, 8, 90}
9
  //   fmt.Println(ages2)
10
  //   var ages3 = [...]int{1: 100, 99: 200}
11
  //   fmt.Println(ages3)
12
  //   // 二维数组
13
  //   var a1 = [...][2]int{
14
  //     [2]int{1, 2},
15
  //     [2]int{3, 4},
16
  //     [2]int{5, 6},
17
  //   }
18
  //   fmt.Println(a1)
19
  //   // 多维数组只有最外层可以使用...
20

21
  //   // 数组是值类型
22

23
  //   x := [3]int{1, 2, 3}
24
  //   y := x     // ? 把x的值拷贝了一份给了y
25
  //   y[1] = 200 // 修改的是副本y,并不影响x
26

27
  //   fmt.Println(x) // [1 2 3]
28
  //   f1(x)
29
  //   fmt.Println(x) // ?[1 2 3]
30

31
  // 切片(Slice):
32
  // var s1 []int // 没有分配内存, == nil
33
  // fmt.Println(s1)
34
  // fmt.Println(s1 == nil)
35
  // s1 = []int{1, 2, 3}
36
  // fmt.Println(s1)
37
  // // make初始化 分配内存
38
  // s2 := make([]bool, 2, 4)
39
  // fmt.Println(s2) // [false false]
40
  // s3 := make([]int, 0, 4)
41
  // fmt.Println(s3 == nil)
42

43
  // s1 := []int{1, 2, 3} // [1 2 3]
44
  // s2 := s1
45
  // var s3 = make([]int, 3, 3)
46
  // copy(s3, s1)
47
  // fmt.Println(s2) // [1 2 3]
48
  // s2[1] = 200
49
  // fmt.Println(s2) // [1 200 3]
50
  // fmt.Println(s1) // [1 200 3]
51
  // fmt.Println(s3) // ?[1 2 3]
52

53
  // var s1 []int // nil
54
  // // s1 = make([]int, 1)
55
  // // s1[0] = 100
56
  // // fmt.Println(s1)
57
  // s1 = append(s1, 1) // 自动初始化切片
58
  // fmt.Println(s1)
59

60
  // 指针
61
  // Go里面的指针只能读不能修改，不能修改指针变量指向的地址
62
  // addr := "沙河"
63
  // addrP := &addr
64
  // fmt.Println(addrP) // 内存地址
65
  // fmt.Printf("%T\n", addrP)
66
  // addrV := *addrP // 根据内存地址找值
67
  // fmt.Println(addrV)
68

69
  // map
70
  var m1 map[string]int
71
  fmt.Println(m1 == nil)
72
  m1 = make(map[string]int, 10)
73
  m1["理想"] = 100
74
  fmt.Println(m1)
75
  fmt.Println(m1["ji"]) // 如果key不存在返回的是value对应类型的零值
76
  // 如果返回值是布尔型，我们通常用ok去接收它
77
  score, ok := m1["ji"]
78
  if !ok {
79
    fmt.Println("没有姬无命这个人")
80
  } else {
81
    fmt.Println("姬无命的分数是", score)
82
  }
83
  delete(m1, "lixiang") // 删除的key不存在什么都不干
84
  delete(m1, "理想")
85
  fmt.Println(m1)
86
  fmt.Println(m1 == nil) // 已经开辟了内存
87
}
88

89
func f1(a [3]int) {
90
  // Go语言中的函数传递的都是值（Ctrl+C Ctrl+V）
91
  a[1] = 100 // 此处修改的是副本的值
92
}