1
func main() {
2
  // 1. 判断字符串中汉字的数量
3
  // 难点是判断一个字符是汉字
4
  // s1 := "Hello沙河안녕하세요こんにちは"
5
  // // 1. 依次拿到字符串中的字符
6
  // var count int
7
  // for _, c := range s1 {
8
  //   // 2. 判断当前这个字符是不是汉字
9
  //   if unicode.Is(unicode.Javanese, c) {
10
  //     count++
11
  //   }
12
  // }
13
  // 3. 把汉字出现的次数累加得到最终结果
14
  // fmt.Println(count)
15
  // 2. how do you do 单词出现的次数
16
  // s2 := "how do you do"
17
  // // 2.1 把字符串按照空格切割得到切片
18
  // s3 := strings.Split(s2, " ")
19
  // // 2.2 遍历切片存储到一个map
20
  // m1 := make(map[string]int, 10)
21
  // for _, w := range s3 {
22
  //   // 1. 如果原来map中不存在w这个key那么出现次数=1
23
  //   if _, ok := m1[w]; !ok {
24
  //     m1[w] = 1
25
  //   } else {
26
  //     m1[w]++
27
  //   }
28
  //   // 2. 如果map中存在w这个key,那么出现次数+1
29
  // }
30
  // // 2.3 累加出现的次数
31
  // for key, value := range m1 {
32
  //   fmt.Println(key, value)
33
  // }
34

35
  // 回文判断
36
  // 字符串从左往右读和从右往左读是一样的，那么就是回文。
37
  // 上海自来水来自海上 s[0]  s[len(s)-1]
38
  // 山西运煤车煤运西山
39
  // 黄山落叶松叶落山黄
40
  ss := "a山西运煤车煤运西山a"
41
  // 解题思路：
42
  // 把字符串中的字符拿出来放到一个[]rune中
43

44
  // []int []string []bool []float64 []byte []rune []map[string]int
45
  r := make([]rune, 0, len(ss))
46
  for _, c := range ss {
47
    r = append(r, c)
48
  }
49
  fmt.Println("[]rune:", r)
50
  for i := 0; i < len(r)/2; i++ {
51
    // 山 ss[0]  ss[len(ss)-1]
52
    // 西 ss[1]  ss[len(ss)-1-1]
53
    // 运 ss[2]  ss[len(ss)-1-2]
54
    // 煤 ss[3]  ss[len(ss)-1-3]
55
    // ...
56
    // c  ss[i]  ss[len(ss)-1-i]
57
    if r[i] != r[len(r)-1-i] {
58
      fmt.Println("不是回文")
59
      return
60
    }
61
  }
62
  fmt.Println("是回文")
63
}

1
// 函数:一段代码的封装
2
func f1() {
3
  fmt.Println("Hello 沙河！")
4
}
5

6
func f2(name string) {
7
  fmt.Println("Hello", name)
8
}
9

10
// 带参数和返回值的函数
11
func f3(x int, y int) int {
12
  sum := x + y
13
  return sum
14
}
15

16
// 参数类型简写
17
func f4(x, y int) int {
18
  return x + y
19
}
20

21
// 可变参数
22
func f5(title string, y ...int) int {
23
  fmt.Println(y) // y是一个int类型的切片
24
  return 1
25
}
26

27
// 命名返回值
28
func f6(x, y int) (sum int) {
29
  sum = x + y // 如果使用命名的返回值，那么在函数中可以直接使用返回值变量
30
  return      // 如果使用命名的返回值,return后面可以省略返回值变量
31
}
32

33
// Go语言中支持多个返回值
34
func f7(x, y int) (sum int, sub int) {
35
  sum = x + y
36
  sub = x - y
37
  return
38
}
39

40

41
func main() {
42
  f1()
43
  f2("理想")
44
  f2("姬无命")
45
  fmt.Println(f3(100, 200)) // 调用函数
46

47
  ret := f3(100, 200)
48
  fmt.Println(ret)
49

50
  f5("lixiang", 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
51
  // 在一个命名的函数中不能够再声明命名函数
52
  // func f8(){
53

54
  // }
55

56

57
}

1
// defer
2

3
// defer多用于函数结束之前释放资源（文件句柄、数据库连接、socket连接）
4
func deferDemo() {
5
  fmt.Println("start")
6
  defer fmt.Println("嘿嘿嘿") // defer把它后面的语句延迟到函数即将返回的时候再执行
7
  defer fmt.Println("呵呵呵") // 一个函数中可以有多个defer语句
8
  defer fmt.Println("哈哈哈") // 多个defer语言按照先进后出（后进先出）的顺序延迟执行
9
  fmt.Println("end")
10
}
11

12
func main() {
13
  deferDemo()
14
}

1
// Go语言中函数的return不是原子操作，在底层是分为两步来执行
2
// 第一步：返回值赋值
3
// defer
4
// 第二步：真正的RET返回
5
// 函数中如果存在defer，那么defer执行的时机是在第一步和第二步之间
6

7
func f1() int {
8
  x := 5
9
  defer func() {
10
    x++ // 修改的是x不是返回值
11
  }()
12
  return x // 1. 返回值赋值 2. defer 3. 真正的RET指令
13
}
14

15
func f2() (x int) {
16
  defer func() {
17
    x++
18
  }()
19
  return 5 // 返回值=x
20
}
21

22
func f3() (y int) {
23
  x := 5
24
  defer func() {
25
    x++ // 修改的是x
26
  }()
27
  return x // 1. 返回值 = y = x = 5 2. defer修改的是x 3. 真正的返回
28
}
29

30
func f4() (x int) {
31
  defer func(x int) {
32
    x++ // 改变的是函数中x的副本
33
  }(x)
34
  return 5 // 返回值 = x = 5
35
}
36

37
func f5() (x int) {
38
  defer func(x int) int {
39
    x++
40
    return x
41
  }(x)
42
  return 5
43
}
44

45
// 传一个x的指针到匿名函数中
46
func f6() (x int) {
47
  defer func(x *int) {
48
    (*x)++
49
  }(&x)
50
  return 5 // 1. 返回值=x=5  2. defer x=6 3. RET返回
51
}
52

53
func main() {
54
  fmt.Println(f1()) // 5
55
  fmt.Println(f2()) // 6
56
  fmt.Println(f3()) // 5
57
  fmt.Println(f4()) // 5
58
  fmt.Println(f5()) // 5
59
  fmt.Println(f6()) // 6
60
}

1
// 变量的作用域
2
var x = 100 // 定义一个全局变量
3
// 定义一个函数
4
func f1() {
5
  // x := 10
6
  name := "理想"
7
  // 函数中查找变量的顺序
8
  // 1. 先在函数内部查找
9
  // 2. 找不到就往函数的外面查找,一直找到全局
10
  fmt.Println(x, name)
11
}
12

13
func main() {
14
  f1()
15
  // fmt.Println(name) // 函数内部定义的变脸只能在该函数内部使用
16

17
  // 语句块作用域
18
  if i := 10; i < 18 {
19
    fmt.Println("乖乖上学")
20
  }
21
  // fmt.Println(i) // 不存在i
22
  for j := 0; j < 5; j++ {
23
    fmt.Println(j)
24
  }
25
  // fmt.Println(j) // 不存在j
26
}

1
// 函数类型
2
func f1() {
3
  fmt.Println("Hello 沙河")
4
}
5
func f2() int {
6
  return 10
7
}
8
func f4(x, y int) int {
9
  return x + y
10
}
11
// 函数也可以作为参数的类型
12
func f3(x func() int) {
13
  ret := x()
14
  fmt.Println(ret)
15
}
16
func ff(a, b int) int {
17
  return a + b
18
}
19
// 函数还可以作为返回值
20
func f5(x func() int) func(int, int) int {
21
  return ff
22
}
23
func main() {
24
  a := f1
25
  fmt.Printf("%T\n", a)
26
  b := f2
27
  fmt.Printf("%T\n", b)
28

29
  f3(f2)
30
  f3(b)
31
  fmt.Printf("%T\n", f4)
32
  // f3(f4)
33
  f7 := f5(f2)
34
  fmt.Printf("%T\n", f7)
35
}

1
// 匿名函数
2
// var f1 = func(x, y int) {
3
//   fmt.Println(x + y)
4
// }
5
func main() {
6

7
  // 函数内部没有办法声明带名字的函数
8
  // 匿名函数
9
  f1 := func(x, y int) {
10
    fmt.Println(x + y)
11
  }
12
  f1(10, 20)
13

14
  // 如果只是调用一次的函数，还可以简写成立即执行函数
15
  func(x, y int) {
16
    fmt.Println(x + y)
17
    fmt.Println("Hello world!")
18
  }(100, 200)
19
}

1
// 闭包
2
func f1(f func()) {
3
  fmt.Println("this is f1")
4
  f()
5
}
6
func f2(x, y int) {
7
  fmt.Println("this is f2")
8
  fmt.Println(x + y)
9
}
10
// 要求：
11
// f1(f2)
12
func f3(f func(int, int), x, y int) func() {
13
  tmp := func() {
14
    f(x, y)
15
  }
16
  return tmp
17
}
18
func main() {
19
  ret := f3(f2, 100, 200) // 把原来需要传递两个int类型的参数包装成一个不需要传参的函数
20
  fmt.Printf("%T\n", ret)
21
  // ret()
22
  f1(ret)
23
}

1
// 闭包是什么？
2
// 闭包是一个函数，这个函数包含了他外部作用域的一个变量
3
// 底层的原理：
4
// 1. 函数可以作为返回值
5
// 2. 函数内部查找变量的顺序，先在自己内部找，找不到往外层找
6
func adder1() func(int) int {
7
  var x int = 100
8
  return func(y int) int {
9
    x += y
10
    return x
11
  }
12
}
13
func adder2(x int) func(int) int {
14
  return func(y int) int {
15
    x += y
16
    return x
17
  }
18
}
19
func main() {
20
  ret := adder2(100)
21

22
  ret2 := ret(200)
23

24
  fmt.Println(ret2)
25
}

1
// 闭包
2
func makeSuffixFunc(suffix string) func(string) string {
3
  return func(name string) string {
4
    if !strings.HasSuffix(name, suffix) {
5
      return name + suffix
6
    }
7
    return name
8
  }
9
}
10

11
func main() {
12
  jpgFunc := makeSuffixFunc(".jpg")
13
  txtFunc := makeSuffixFunc(".txt")
14
  fmt.Println(jpgFunc("test")) //test.jpg
15
  fmt.Println(jpgFunc("呵呵.jpg"))
16
  fmt.Println(txtFunc("test")) //test.txt
17
  fmt.Println(txtFunc("呵呵.txt"))
18
}

1
// 关键字 函数名(参数)（返回值）{}
2
func calc(base int) (func(int) int, func(int) int) {
3
  add := func(i int) int {
4
    base += i
5
    return base
6
  }
7

8
  sub := func(i int) int {
9
    base -= i
10
    return base
11
  }
12
  return add, sub
13
}
14

15
func main() {
16
  f1, f2 := calc(10)
17
  fmt.Println(f1(1), f2(2)) // 11 9
18
  fmt.Println(f1(3), f2(4)) // 12 8;13 9
19
  fmt.Println(f1(5), f2(6)) // 13 7
20
}

1
// defer
2

3
func calc(index string, a, b int) int {
4
  ret := a + b
5
  fmt.Println(index, a, b, ret)
6
  return ret
7
}
8

9
func main() {
10
  a := 1
11
  b := 2
12
  defer calc("1", a, calc("10", a, b))
13
  a = 0
14
  defer calc("2", a, calc("20", a, b))
15
  b = 1
16
}
17

18
// 1. a:=1
19
// 2. b:=2
20
// 3. defer calc("1", 1, calc("10", 1, 2))
21
// 4. calc("10", 1, 2) // "10" 1 2 3
22
// 5. defer calc("1", 1, 3)
23
// 6. a = 0
24
// 7. defer calc("2", 0, calc("20", 0, 2))
25
// 8. calc("20", 0, 2) // "20" 0 2 2
26
// 9. defer calc("2", 0, 2)
27
// 10. b = 1
28
// calc("2", 0, 2) // "2" 0 2 2
29
// calc("1", 1, 3) // "1" 1 3 4
30

31
// 最终的答案：
32
// "10" 1 2 3
33
// "20" 0 2 2
34
//  "2" 0 2 2

1
// panic 和 recover
2
// panic和recover其实就类似于其他语言中的throw和catch，方便进行多层嵌套的错误处理
3
func funcA() {
4
  fmt.Println("a")
5
}
6

7
func funcB() {
8
  // 刚刚打开数据库连接
9
  defer func() {
10
    err := recover()
11
    fmt.Println(err)
12
    fmt.Println("释放数据库连接...")
13
  }()
14
  panic("出现了严重的错误！！！") // 程序崩溃退出
15
  fmt.Println("b")
16
}
17

18
func funcC() {
19
  fmt.Println("c")
20
}
21
func main() {
22
  funcA()
23
  funcB()
24
  funcC()
25
}

1
func main() {
2
  // fmt.Print("沙河")
3
  // fmt.Print("娜扎")
4
  // fmt.Println("--------")
5
  // fmt.Println("沙河")
6
  // fmt.Println("娜扎")
7
  // Printf("格式化字符串", 值)
8
  // %T :查看类型
9
  // %d :十进制数
10
  // %b ：二进制数
11
  // %o :八进制数
12
  // %x ：十六进制数
13
  // %c : 字符
14
  // %s ：字符串
15
  // %p： 指针
16
  // %v： 值
17
  // %f：浮点数
18
  // %t ：布尔值
19

20
  // var m1 = make(map[string]int, 1)
21
  // m1["理想"] = 100
22
  // fmt.Printf("%v\n", m1)
23
  // fmt.Printf("%#v\n", m1)
24

25
  // printBaifenbi(90)
26

27
  // fmt.Printf("%v\n", 100)
28
  // // 整数->字符
29
  // fmt.Printf("%q\n", 65)
30
  // // 浮点数和复数
31
  // fmt.Printf("%b\n", 3.14159265354697)
32
  // // 字符串
33
  // fmt.Printf("%q\n", "李想有理想")
34
  // fmt.Printf("%7.3s\n", "李想有理想")
35

36
  // 获取用户输入
37
  // var s string
38
  // fmt.Scan(&s)
39
  // fmt.Println("用户输入的内容是：", s)
40

41
  // var (
42
  //   name  string
43
  //   age   int
44
  //   class string
45
  // )
46
  // // fmt.Scanf("%s %d %s\n", &name, &age, &class)
47
  // // fmt.Println(name, age, class)
48

49
  // fmt.Scanln(&name, &age, &class)
50
  // fmt.Println(name, age, class)
51

52
  fmt.Printf("%b\n", 1024)
53
}
54

55
func printBaifenbi(num int) {
56
  fmt.Printf("%d%%\n", num)
57
}

1
package main
2

3
import "fmt"
4

5
/*
6
你有50枚金币，需要分配给以下几个人：Matthew,Sarah,Augustus,Heidi,Emilie,Peter,Giana,Adriano,Aaron,Elizabeth。
7
分配规则如下：
8
a. 名字中每包含1个'e'或'E'分1枚金币
9
b. 名字中每包含1个'i'或'I'分2枚金币
10
c. 名字中每包含1个'o'或'O'分3枚金币
11
d: 名字中每包含1个'u'或'U'分4枚金币
12

13
写一个程序，计算每个用户分到多少金币，以及最后剩余多少金币？
14
程序结构如下，请实现 ‘dispatchCoin’ 函数
15
*/
16
var (
17
  coins = 5000
18
  users = []string{
19
    "Matthew", "Sarah", "Augustus", "Heidi", "Emilie", "Peter", "Giana", "Adriano", "Aaron", "Elizabeth",
20
  }
21
  distribution = make(map[string]int, len(users))
22
)
23

24
func main() {
25
  left := dispatchCoin()
26
  fmt.Println("剩下：", left)
27
}
28

29
func dispatchCoin() (left int) {
30
  // 1. 依次拿到每个人的名字
31
  // 2. 拿到一个人名根据分金币的规则去分金币,
32
  // 2.1 每个人分的金币数应该保存到 distribution 中
33
  // 2.2 还要记录下剩余的金币数
34
  // 3. 整个第2步执行完就能得到最终每个人分的金币数和剩余金币数
35
  return
36
}