1
func main() {
2
  // 声明一个包含指定元素数量的数组
3
  var arr [5]int = [5]int{1, 2, 3, 4, 5}
4

5
  // 简写形式
6
  arr2 := [3]string{"Go", "Python", "Java"}
7

8
  // 让编译器推断长度,将[<长度>]换成[...]就可以
9
  arr3 := [...]int{10, 20, 30}
10

11
  fmt.Println(arr[0])   // 输出: 1
12
  fmt.Println(len(arr)) // 输出: 5
13
  fmt.Println(arr2)     // 输出: [Go Python Java]
14
  fmt.Println(arr3)     // 输出: [10 20 30]
15
}

1
// 声明结构体
2
// 这个与java中的class不同,它不能存储方法.
3
type Person struct {
4
  Name  string
5
  Age   int
6
  Email string
7
}
8

9
func main() {
10
  // 为结构体字段赋值
11
  // 方式1: 按字段顺序
12
  p1 := Person{"Alice", 30, "alice@example.com"}
13

14
  // 方式2: 指定字段名（推荐,也就是命名方式）
15
  p2 := Person{
16
    Name: "Bob",
17
    Age:  25,
18
  }
19

20
  // 方式3: 先声明再赋值,有点类似于class
21
  var p3 Person
22
  p3.Name = "Charlie"
23

24
  fmt.Println(p1.Name) // 输出: Alice
25
  fmt.Println(p2)      // 输出: {Bob 25 }
26
}

1
func main() {
2
  // channel: 通道
3
  // 用于在协程之间通信使用
4
  // 创建缓冲为 2 的 int 类型 channel
5
  bufferedChannel := make(chan int, 2)
6

7
  // 发送数据到 channel
8
  bufferedChannel <- 100
9
  bufferedChannel <- 200
10

11
  // 从 channel 接收数据
12
  // 先进先出,类似一个队列
13
  x := <-bufferedChannel
14
  y := <-bufferedChannel
15

16
  fmt.Println(x, y) // 输出: 100 200
17

18
  // 无缓冲 channel
19
  unbufferedChannel := make(chan string)
20
  // 异步发送数据
21
  go func() {
22
    unbufferedChannel <- "Hello from goroutine"
23
  }()
24
  msg := <-unbufferedChannel
25
  fmt.Println(msg)
26
}

1
// 示例1: 定义一个函数类型的接口
2
type AddFunc func(int, int) int
3

4
func main() {
5
    // 函数作为变量
6
    // 声明函数,并赋值给变量保存起来
7
    var add AddFunc = func(a, b int) int {
8
       return a + b
9
    }
10
    // 调用时,使用变量名作为函数名使用.
11
    result := add(3, 5)
12
    fmt.Println(result) // 输出: 8
13

14
    // 示例2: 函数作为参数
15
    // 参数1: a
16
    // 参数2: b:int
17
    // 参数3: op:func(int, int) int,是一个函数类型
18
    operate := func(a, b int, op func(int, int) int) int {
19
       return op(a, b)
20
    }
21

22
    // 使用,这里先声明一个函数,作用是将a,b相乘,并返回结果.
23
    multiply := func(a, b int) int { return a * b }
24
    // 使用operate函数,传入值a,b,以及函数multiply
25
    fmt.Println(operate(4, 5, multiply)) // 输出: 20
26

27
    // 示例3: 函数作为返回值
28
    // 函数名: makeMultiplier
29
    // 接收参数: factor int
30
    // 函数返回值类型: func(int) int
31
    makeMultiplier := func(factor int) func(int) int {
32
       // 在这里,返回了一个函数,用于计算x*factor.
33
       return func(x int) int {
34
          return x * factor
35
       }
36
    }
37

38
    double := makeMultiplier(2)
39
    fmt.Println(double(7)) // 输出: 14
40
}

1
func main() {
2
  // 方式1: 从数组创建
3
  arr := [5]int{10, 20, 30, 40, 50}
4
  s1 := arr[1:4]  // 包含索引 1,2,3
5
  fmt.Println(s1) // 输出: [20 30 40]
6

7
  // 方式2: make 创建
8
  s2 := make([]int, 3, 5) // 初始长度3,最大容量5
9
  s2[0] = 1
10
  s2[1] = 2
11
  fmt.Println(s2) // 输出: [1 2 0]
12

13
  // 方式3: 字面量
14
  s3 := []string{"a", "b", "c"}
15

16
  // 追加元素
17
  s3 = append(s3, "d", "e")
18
  fmt.Println(s3) // 输出: [a b c d e]
19

20
  // 切片复制
21
  s4 := make([]int, len(s2))
22
  copy(s4, s2)
23
}

1
// 定义接口
2
type Animal interface {
3
  Speak() string
4
  Move() string
5
}
6

7
// Dog 实现 Animal 接口
8
// Go语言的接口,是隐式实现的,不需要显式声明实现的接口
9
// 只需要同时实现接口内的所有函数,就可以将实现赋值到接口类型的对象上,见下面的ShowAnimal函数,传入值是一个animal接口类型对象.
10
type Dog struct {
11
  Name string
12
}
13

14
func (d Dog) Speak() string {
15
  return "汪汪!"
16
}
17

18
func (d Dog) Move() string {
19
  return "四条腿跑"
20
}
21

22
// Cat 实现 Animal 接口
23
type Cat struct {
24
  Name string
25
}
26

27
func (c Cat) Speak() string {
28
  return "喵喵~"
29
}
30

31
func (c Cat) Move() string {
32
  return "悄无声息地走"
33
}
34

35
// 多态函数
36
func ShowAnimal(a Animal) {
37
  fmt.Printf("%s, %s\n", a.Speak(), a.Move())
38
}
39

40
func main() {
41
  // 声明两个实体类
42
  dog := Dog{"旺财"}
43
  cat := Cat{"咪咪"}
44
  // 这里调用了多态函数,传入了两个实体类,由多态函数自动处理.
45
  ShowAnimal(dog) // 输出: 汪汪!, 四条腿跑
46
  ShowAnimal(cat) // 输出: 喵喵~, 悄无声息地走
47

48
  // 空接口: 可以存储任意类型,限一个,如基本类型,函数类型,切片类型,结构体等.
49
  // 在Go中,所有的方法都实现了空接口
50
  var anything interface{} = "hello"
51
  anything = 42
52
  anything = 3.14
53
  fmt.Println(anything)
54
}

1
package main
2

3
import "fmt"
4

5
func main() {
6
  const LENGTH int = 10
7
  const WIDTH int = 5
8
  var area int
9
  const a, b, c = 1, false, "str" // 多重赋值
10

11
  area = LENGTH * WIDTH
12
  fmt.Printf("面积为 : %d", area) // 面积为 : 50
13
  fmt.Println()
14
  fmt.Println(a, b, c) // 1 false str
15
}

1
package main
2

3
import "fmt"
4

5
func main() {
6
  const (
7
    a = iota // 0
8
    b        // 1
9
    c        // 2
10
    d = "ha" // 独立值，iota += 1,实际值为给定的值而不是iota
11
    e        // "ha"，iota += 1,实际值为上一行的值而不是iota
12
    f = 100  // 独立值，iota += 1,同样的,实际值为上一行的值而不是iota
13
    g        // 100，iota += 1,同上.
14
    h = iota // 7，恢复使用 iota 值,iota经过中间几个变量后,值为7
15
    i        // 8
16
  )
17
  fmt.Printf("a=%d, b=%d, c=%d, d=%s, e=%s, f=%d, g=%d, h=%d, i=%d\n", a, b, c, d, e, f, g, h, i)
18
}

1
func main() {
2
  var a int
3
  var ptr *int
4
  var pptr **int // Go支持指向指针的指针,使用**就可以了
5

6
  a = 3000
7

8
  // 指针 ptr 地址
9
  ptr = &a
10

11
  // 指向指针 ptr 地址
12
  pptr = &ptr
13

14
  // 获取 pptr 的值
15
  fmt.Printf("变量 a = %d\n", a)
16
  fmt.Printf("指针变量 *ptr = %d\n", *ptr)
17
  fmt.Printf("指向指针的指针变量 **pptr = %d\n", **pptr)
18
}

1
const max = 3
2

3
func main() {
4
  number := [max]int{5, 6, 7}
5
  var ptrs [max]*int // 声明int类型的指针数组
6
  // 将number数组的值的地址赋给ptrs
7
    // &number: 指向了number数组,在这块内存区域中,使用for遍历
8
    // 注意,这里使用number也是可以的,number与&number的区别在于,number是将数组复制了一份,页&number是指向数组的一个指针,使用数组复制时,是有性能开销的,但适用于单线程环境或者多线程不修改数组的环境.
9
    // i: 键
10
    // x: 值
11
  for i, x := range &number {
12
        // 取出x的内存地址,赋给指针数组的对应元素
13
    ptrs[i] = &x
14
  }
15
    // 将
16
  for i, x := range ptrs {
17
    fmt.Printf("指针数组：索引:%d 值:%d 值的内存地址:%d\n", i, *&*x, x)
18
  }
19
}