1
2
3
4
5
6
7
8

# go 打包为 exe 文件，默认在同目录下
$ go build <filename>.go
# 运行文件 exe 文件
$ <filename>
# 不打包直接运行 go 文件
$ go run <filename>.go
# 格式化代码，go 建议所有代码都是一种风格
$ gofmt -w <filename>.go

 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

package main // 入口包

import "fmt"

/* 全局变量不能省略 var */
var global string = "global"

func main() { // 入口函数
	/* 一对 {} 内部的为局部变量 */

	// 1、声明一个变量，默认值为 0
	var a int
	fmt.Printf("a = %d, type = %T\n", a, a) // a = 0, type = int

	// 2、声明并初始化
	var (
		str1 string = "str1"
		str2 string = "str2"
	)
	fmt.Printf("str1 = %s, type = %T\n", str1, str1) // str1 = str1, type = string
	fmt.Printf("str2 = %s, type = %T\n", str2, str2) // str2 = str2, type = string

	// 3、声明并初始化，自动推导类型
	var b, c = 100, 3.14
	fmt.Printf("b = %d, type = %T\n", b, b) // b = 100, type = int
	fmt.Printf("b = %f, type = %T\n", c, c) // b = 3.140000, type = float64

	// 4、省略 var（无法定义全局变量，只在方法体中使用）
	char := 'A'
	fmt.Printf("char = %c, charCode = %d, type = %T\n", char, char, char) // char = A, charCode = 65, type = int32
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

package main

import "fmt"

const (
	MALE   = 1
	FEMALE = 2
)

const (
	a, b = iota + 1, iota + 3	  // iota = 0, a = 1, b = 3
	c, d					 	// iota = 1, c = 2, d = 4
	e, f						// iota = 2, e = 3, f = 5
	g, h = iota * 10, iota * 20   // iota = 3, g = 30, h = 60
	i, j                          // iota = 4, i = 40, j = 80
)

func main() {
	fmt.Printf("MALE = %d, FEMALE = %d\n", MALE, FEMALE) // MALE = 1, FEMALE = 2
}

1
2
3
4
5
6
7

import "fmt"

func main() {
	var c int = 'A' // 定义一个整型变量并初始化为 'A'，必须为单引号，双引号表示的是字符串字面量
	fmt.Printf("%d", c) // 控制台打印：65
	fmt.Printf("%c", c) // 控制台打印：65
}

1
2
3
4
5
6
7

import "fmt"

func main() {
	var flag bool // 默认为 false
	fmt.Printf("%T\n", flag) // bool
	fmt.Printf("%v", flag)   // false
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

import "fmt"

func main() {
	var str string = "ABC" + "DEF" // + 拼接
	str2 := `fmt.Printf("str2")`   // 省略 var；类型推断；模板字符串原样输出
	fmt.Println(str)
	fmt.Println(str2)
	// 我们知道，字符串底层还是数组存储的，假如我们有以下操作
	str[0] = 'C' // error，原因是定义好的字符串，值不可再被修改
	fmt.Printf("%v", str[0]) // 65
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

import "fmt"

func main() {
	var str string = "100"
	var ptr *string = &str
	fmt.Println(ptr)  // str 的内存地址：0x********
	fmt.Println(*ptr) // str 的值：100
	fmt.Println(&ptr) // ptr 的内存地址：0x********
    
    /* 指针使用注意事项 */
	// 1、可以通过指针修改变量的值，但需要类型匹配
	*ptr = "200" // success
	*ptr = 200 // error
	// 2、指针类型的赋值需要指针类型匹配
	var ptr2 *string = ptr // success
	var ntr *int = ptr // error
	// 3、所有的基本类型都有对应的指针类型
}

1
2
3
4
5
6

// 定义一个数组，不初始化
var arr [3]int // arr = [0 0 0]
// 定义一个数组，并初始化
var arr2 [3]int = [3]int{1,2,3}
// 省略var
arr3 := [3]int{4,5,6}

 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

import "fmt"

func main() {
	// 定义一个定长数组
	var arr [3]int

	// 1、查看长度、容量、内容
    // 结果：len = 3, cap = 3, arr = [0 0 0]
	fmt.Printf("len = %d, cap = %d, arr = %v\n", len(arr), cap(arr), arr) 
	// 往 arr 整型数组末尾追加一个元素 1
	append(arr, 1) // error，定义定长数组无法被扩容

	// 2、变量参数传递：值拷贝
    // 结果：没有变化
	todoArr(arr)
	fmt.Printf("len = %d, cap = %d, arr = %v\n", len(arr), cap(arr), arr) 

	// 3、指针参数传递
    // 结果：数组第一个值变为 100
	todoArr2(&arr)
	fmt.Printf("len = %d, cap = %d, arr = %v\n", len(arr), cap(arr), arr)
}

// 定长数组参数的变量传递必须长度也是一致的，且是值拷贝，不会影响原数组
func todoArr(arr [3]int) {
	arr[0] = 100 // 修改第一个长度
    // 遍历，使用range
	for index, value := range arr {
		fmt.Printf("[%d], %v", index, value)
	}
}

// 定长数组参数的指针传递也必须长度也是一致的，但会影响原数组
func todoArr2(arrptr *[3]int) {
	(*arrptr)[0] = 100
}

1
2
3
4
5
6

// 定义一个切片，不初始化
var slice []int // slice = [] = nil
// 定义一个切片，并初始化
var slice2 []int = []int{1,2,3}
// 省略var，分配空间
slice3 := make([]int, 3, 5) //长度为3，容量为5

 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

import "fmt"

func main() {
	// 定义一个切片，不初始化
	var slice []int

	// 1、如果不初始化使用前需要先分配空间
	// 结果：len = 3, cap = 5, slice = [0 0 0]
	slice = make([]int, 3, 5)
	fmt.Printf("len = %d, cap = %d, slice = %v\n", len(slice), cap(slice), slice)

	// 2、参数传递
	// 结果：len = 3, cap = 3, slice = [100 0 0]
	todoArr(slice)
	fmt.Printf("len = %d, cap = %d, slice = %v\n", len(slice), cap(slice), slice)

	// 3、追加元素与扩容，旧的 slice 会被垃圾回收（GC）
	// 结果：len = 6, cap = 10, slice = [100 0 0 1 2 3]
	slice = append(slice, 1, 2, 3)
	fmt.Printf("len = %d, cap = %d, slice = %v\n", len(slice), cap(slice), slice)

	// 4、切片的拷贝
	// 结果：len = 4, cap = 4, slice2 = [100 0 0 1]
	slice2 := make([]int, 4)
	copy(slice2, slice)
	fmt.Printf("len = %d, cap = %d, slice2 = %v\n", len(slice2), cap(slice2), slice2)

	// 5、切片的读取
	// 结果：len = 2, cap = 10, slice3 = [100 0]
	slice3 := slice[0:2]
	fmt.Printf("len = %d, cap = %d, slice3 = %v\n", len(slice3), cap(slice3), slice3)
    
    // 6、特例：字符串的切片操作
    str := "world!"
	slice4 := append([]byte("hello "), 'A')
	slice5 := make([]byte, 6)
	copy(slice5, []byte(str))
	fmt.Println(slice4) // [104 101 108 108 111 32 65]
	fmt.Println(slice5) // [119 111 114 108 100 33]
}

// 切片参数传递是引用传递，会影响原切片
func todoArr(slice []int) {
	slice[0] = 100 // 修改第一个长度
	// 遍历，使用range
	for index, value := range slice {
		fmt.Printf("[%d], %v\n", index, value)
	}
}

1
2
3
4
5
6
7
8
9

// 定义一个映射，不初始化
var record map[string]string // record = map[] = nil
// 定义一个映射，并初始化
var record2 map[string]string = map[string]string{
    "中国": "北京",
    "美国": "纽约",
}
// 省略 var，分配空间
record3 := make(map[string]string, 2) // 第二个参数可省略

 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

import "fmt"

func main() {
	// 定义一个映射，分配空间
	record := make(map[string]string)
	// 结果：len = 0, cap = 0, record = []
	fmt.Printf("len = %d, record = %v\n", len(record), record)

	// 新增
	record["中国"] = "北京"
	record["美国"] = "纽约"

	// 修改
	record["美国"] = "华盛顿"

	// 删除
	delete(record, "美国")

	// 查看
	fmt.Printf("%s\n", record["中国"]) // 北京

	// 参数传递：引用传递
	todoMap(record)

	// 遍历
	for key, value := range record {
		fmt.Printf("[%s]: %s", key, value) // [中国]: 深圳
	
}

func todoMap(row map[string]string) {
	row["中国"] = "深圳"
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

import (
	"fmt"
)

func subTask(channel chan int) {
	defer fmt.Println("sub task end")
	fmt.Println("sub task running")
	channel <- 66 // 信道写入。当容量不够时，将会阻塞等待
}

func main() {
	c := make(chan int) // 无缓存的信道（容量为 1）
	go subTask(c)
	// <- c //只取不读（丢弃）
	num := <-c // 信道读取。当信道内无值时，将会阻塞等待
	fmt.Println("num = ", num)
	fmt.Println("main task end")
}

 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

import (
	"fmt"
	"time"
)

func subTask(channel chan int) {
	defer fmt.Println("sub task end")

	// 循环写入 4次
	for i := 0; i < 4; i++ {
		channel <- 'A' + i
		fmt.Printf("sub task running, send = %c\n", 'A'+i)
		// 容量满了，关闭信道
		if len(channel) == cap(channel) {
			close(channel)
			break
		}
	}
}

func main() {
	c := make(chan int, 3) // 有缓存的信道（容量为 3）
	go subTask(c)

	time.Sleep(2 * time.Second) // 睡眠 2s，让子线程写入堵塞

	// 循环读取
	for i := 0; i < 5; i++ { // 多读取几次
		val, ok := <-c
		fmt.Printf("main task running, get = %c, ok = %t\n", val, ok)
	}
	fmt.Println("main task end")
}

// 结果
// sub task running, send = A
// sub task running, send = B
// sub task running, send = C
// sub task end
// main task running, get = A, ok = true
// main task running, get = B, ok = true
// main task running, get = C, ok = true
// main task running, get = , ok = false 信道空
// main task running, get = , ok = false 信道空
// main task end

1
2
3
4

// 将上面循环读取的代码改为下面的内容
for val := range c {
    fmt.Printf("main task running, get = %c\n", val)
}

 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

import (
	"fmt"
)

// 斐波那契数列生成函数，长度为 channel 的长度
func fibnacii(channel, quit chan int) {
	x, y := 1, 1
	for {
		select {
		case <-quit: // 如果 quit 可读，不再写入
			return
		case channel <- x: // 如果 channel 可写，写入数据
			temp := x
			x = y     // 将写入的数改为保存的
			y += temp // 保存下一个数
		}
	}
}

// 读取数列的函数
func readFib(channel, quit chan int) {
	defer fmt.Println("\nsub task end")
	fmt.Println("reading")
	for i := 0; i < cap(channel); i++ {
		val := <-channel
		fmt.Printf("%d ", val)
	}
	quit <- 1
}

func main() {
	c := make(chan int, 10) // 有缓存的信道（容量为 10）
	q := make(chan int)
	go readFib(c, q)
	fibnacii(c, q)
}

// 结果
// reading
// 1 1 2 3 5 8 13 21 34 55
// sub task end

 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

import "fmt"

// 定义一个学生结构体
type Student struct {
	name string `info:"学生姓名"` // 属性标签
	age  uint8
}

func changeStu(s Student) {
	s.age = 20
}

func changeStu2(s *Student) {
	s.age = 25
}

func main() {
	// 初始化
	stu := Student{name: "Saly", age: 18}
	fmt.Printf("%s is %d years old\n", stu.name, stu.age) // Saly is 18 years old

	// 更改值
	stu.age = 19

	// 变量入参：值拷贝
	changeStu(stu)
	fmt.Println(stu) // {Saly 19}

	// 指针入参
	changeStu2(&stu)
	fmt.Println(stu) // {Saly 25}
}

 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

import "fmt"

type Student struct {
	name string
	age  uint8
}

func show(param interface{}) {
	// 类型断言
	value, ok := param.(Student)
	switch ok {
	case true:
		fmt.Printf("is Student, value = %v\n", value)
	case false:
		fmt.Printf("is not Student, value = %v\n", value)
	}
}

func main() {
	// 初始化
	stu := Student{name: "Saly", age: 18}

	show(stu) // is Student, value = {Saly 18}

	show("name") // is not Student, value = { 0}
	show(100)    // is not Student, value = { 0}
	show(true)   // is not Student, value = { 0}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

import "fmt"

type myInt int
func main() {
	var num myInt = 10
	var num2 int = 20
    // int 和 myInt 虽然最终都是 int 类型
    // 但是 Golang 认为不一样，不能直接赋值和运算，需要强制转换
	num = myInt(num2) 
	fmt.Println(num) // 20
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

import "fmt"

func main() {
	var name string
	var age uint8
	var isGraduate bool

	/* 单个输入 */
	fmt.Println("请输入学生信息：")
	fmt.Print("姓名：")
	fmt.Scanln(&name)

	fmt.Print("年龄：")
	fmt.Scanln(&age)

	fmt.Print("是否毕业：")
	fmt.Scanln(&isGraduate)

	/* 批量输入 */
	fmt.Println("请输入学生信息（空格分隔）：")
	fmt.Scanf("%s %d %t", &name, &age, &isGraduate)

	fmt.Printf("%s %d %t", name, age, isGraduate)
}

 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

import "fmt"

func main() {
	var score uint8 = 100

	/* if else */
	if score >= 90 { // 大括号必须写
		fmt.Println("A")
	} else if score >= 80 {
		fmt.Println("B")
	} else {
		fmt.Println("C")
	}

	/* switch */
	// switch 后面可以是一个表达式；也可为空（相当于 if else）；还可以定义变量，此时必须 ; 结尾
	switch score / 10 {
	default: 			// 位置任意，所有分支不满足走这里
		fmt.Println("C")
	case 9, 10: 		// 可以带多个值
		fmt.Println("A")
		fallthrough 	// 穿透这个分支，下一个分支语句也执行
	case 8:
		fmt.Println("B")
        break 			// 可省略
	}
}

 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

func main() {
	var text string = "Hello, Golang"
	for i := 0; i < len(text); i++ {
        if text[i] == 'G' {
            goto label 		// 跳转到 label; 位置
		}
        if i == 5 {
            continue 		// 跳过当前循环，逗号字符
        }
        if i == 6 {
            break 			// 跳出循环，空格字符
		}
        label;
        if text[i] == 'G' {
            return 			// 跳出循环并返回函数结果
        }
        fmt.Printf("[%d] %c\n", i, text[i])
	}
    
    //也可以这样写
    j := 0
    for i < len(text) {
		fmt.Printf("[%d] %c\n", j, text[j])
    	j++
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

func main() {
	var text string = "你好, Go语言"
	for index, value := range text {
		fmt.Printf("[%d] %c\n", index, value)
	}
    // 结果
	/*
	 * [0] 你
	 * [3] 好
	 * [6] ,
	 * [7]
	 * [8] G
	 * [9] o
	 * [10] 语
	 * [13] 言
	*/
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

import "fmt"

func main() {
	a := 20
	b := 30
	fmt.Printf("a = %d, b = %d\n", a, b) // a = 20, b = 30
	swap(&a, &b)
	fmt.Printf("a = %d, b = %d\n", a, b) // a = 30, b = 20
}

// 交换两数：改变原数
func swap(a *int, b *int) {
	*a = *a + *b
	*b = *a - *b
	*a = *a - *b
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

import "fmt"

func main() {
	a := 20
	b := 30
	fmt.Printf("a = %d, b = %d\n", a, b) // a = 20, b = 30
	c, d := swap(a, b)
	fmt.Printf("a = %d, b = %d\n", a, b) // a = 20, b = 30
	fmt.Printf("c = %d, d = %d\n", c, d) // c = 30, d = 20

	// 不需要的返回值使用 _ 替代，不可省略，否则无法编译通过
	e, _ := swap(100, 200)
	fmt.Printf("e = %d", e) // e = 200
}

// 交换两数：不会改变原数
func swap(a int, b int) (int, int) { // 定义两个返回值，当只有一个的时候可以省略 ()
	a = a + b
	b = a - b
	a = a - b
	return a, b // 返回的数据类型需对应：开头定义的类型
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

import "fmt"

func main() {
	f := fn // 函数也是一种数据类型，可以赋值给一个变量。等价于：var f func(args ...int) = fn
	f('A', 'B', 'C', 'D', 'E')
}

func fn(args ...int) {
	for index, value := range args {
		fmt.Printf("[%d] %c\n", index, value)
	}
}

 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

import "fmt"

// 定义一个函数类型：参数 —— int, int；无返回值
type callback func(int, int)

func main() {
	// 定义一个两数相除的函数
	divide := func(num1 int, num2 int) {
		fmt.Printf("%d\n", num1/num2) // 96/12 = 8
	}
	a, b := 55, 43
	sum, sub := sumSub(a, b, divide) // 返回之前执行了 divide 函数
	fmt.Printf("sum = %d, sub = %d", sum, sub) // sum = 98, sub = 12
}

// 定义一个函数类型
type myFunc func(int, int) (int, int)

// 求两个数的 和、差
func sumSub(a int, b int, back callback) (sum int, sub int) { // 这里命名了两个返回值：sum, sub
	sum = a + b
	sub = a - b
	back(sum, sub)
	return // 直接将命名的两个返回值返回
}

1
2
3
4
5
6
7
8
9

import "fmt"

func main() {
	ret := func(a int, b int) (sum int) {
		sum = a + b
		return
	}(10, 20)
	fmt.Println(ret) // 30
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

import "fmt"

type fn func(int) int

func getSum() fn {
	var sum int = 0
	return func(val int) int {
		sum += val
		return sum
	}
}

func main() {
	f := getSum()
	fmt.Println(f(1)) // 1
	fmt.Println(f(2)) // 3
	fmt.Println(f(3)) // 6
	fmt.Println(f(4)) // 10
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

import "fmt"

func getSum(a int, b int) int {
	defer fmt.Printf("a = %d\n", a) // 压入调用栈，同时保存 a 的值
	defer fmt.Printf("b = %d\n", b) // 压入调用栈，同时保存 b 的值
	a += 10
	b += 20
	return a + b // 执行完之后，以此取出 defer 压入栈的内容执行
}

func main() {
	fmt.Printf("sum = %d", getSum(5, 15))
	/**
	 * 返回结果如下：
	 * b = 15
	 * a = 5
	 * sum = 50
	 */
}

 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

import (
	"fmt"
	"runtime"
	"time"
)

func subTask() {
	defer fmt.Println("子线程关闭")
	for i := 0; i < 5; i++ {
		// 提前退出
		if i == 2 {
			runtime.Goexit()
		}

		fmt.Printf("sub task: %d\n", i)
		time.Sleep(1 * time.Second) // 睡眠 1s
	}
}

func main() {
	go subTask() // 创建子线程调用

	for i := 0; i < 5; i++ {
		fmt.Printf("main task: %d\n", i)
		time.Sleep(1 * time.Second) // 睡眠 1s
	}

	fmt.Println("主线程执行结束") // 如果主线程提前结束，所有子线程将会全部退出
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

package main

import "fmt" // 1、被导入包的全局变量执行。2、被导入包的 func init() 执行

// 3、本包的全局变量被执行，函数定义、全局变量定义和初始化会提升
func getNum() int {
	return 10
}

var num int = getNum()

// 4、本包的 init 函数执行。函数执行时，局部变量定义和初始化将会提升
func init() {
	fmt.Println(num) // 10
	num++
}

// 本包的 main 函数执行
func main() {
	fmt.Println(num) // 11
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

import "fmt"

/* 所有变量、方法、结构体：大写表示向外暴露，小写表示私有 */

// 定义一个类
type Animal struct {
	kind  string
	color string
}

// 定义 Animal 的方法
func (this *Animal) show() { // 这里如果不是指针，将会是值拷贝
	fmt.Printf("%s's color is %s\n", this.kind, this.color)
}

func main() {
	animal := Animal{kind: "cat", color: "white"}
	animal.show() // cat's color is white
}

 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

// 定义猫类，继承 Animal
type Cat struct {
	Animal // 直接继承
	age uint8 // 新的属性
}

// 重写 show 方法
func (this *Cat) show() {
	this.Animal.show() // 调用父类的方法，属性同
	fmt.Printf("age is %d\n", this.age)
}

// 新的 eat 方法
func (this *Cat) eat() {
	fmt.Printf("%s's is eating", this.kind)
}

func main() {
	var cat Cat
	cat.kind = "cat"
	cat.color = "white"
	cat.age = 1
	cat.show() // cat's color is white \n age is 1
	cat.eat()  // cat's is eating
}

 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
50
51
52

import "fmt"

// 定义接口，本质是一个指针
type AnimalIF interface {
	sleep()
	eat()
}

// Cat 类，只需要实现 AnimalIF 的全部方法
type Cat struct {
	name string
}

func (this *Cat) sleep() {
	fmt.Printf("(Cat)%s is sleeping\n", this.name)
}
func (this *Cat) eat() {
	fmt.Printf("(Cat)%s is eating\n", this.name)
}

// Dog 类，只需要实现 AnimalIF 的全部方法
type Dog struct {
	name string
}

func (this *Dog) sleep() {
	fmt.Printf("(Dog)%s is sleeping\n", this.name)
}
func (this *Dog) eat() {
	fmt.Printf("(Dog)%s is eating\n", this.name)
}

// 定义一个方法，执行 Animal 的动作
func dosth(animal AnimalIF) {
	animal.sleep()
	animal.eat()
}

func main() {
	cat := Cat{name: "Tom"}
	dog := Dog{name: "Jim"}

	// 注意这里传的是指针，因为 interface 本质是一个指针
	dosth(&cat)
	dosth(&dog)
}

// 结果
// (Cat)Tom is sleeping
// (Cat)Tom is eating
// (Dog)Jim is sleeping
// (Dog)Jim is eating

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

import "fmt"

func main() {
	var str string
	str = "hello" // pair<type: string, value: "hello">

	var any interface{}
	any = str // any 的 pair 结构仍然是：pair<type: string, value: "hello">

	newStr, _ := any.(string) // 所以这里可以类型断言成功
	fmt.Println(newStr) // hello
}

 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

import "fmt"

type ReadBook interface {
	read()
}
type WriteBook interface {
	write()
}
type Book struct {
	name string
}

// 实现 ReadBook 和 WriteBook
func (this *Book) read() {
	fmt.Printf("%s is reading\n", this.name)
}
func (this *Book) write() {
	fmt.Printf("%s is writing\n", this.name)
}

func main() {
	book := &Book{name: "西游记"} // pair<type: Book, value: book地址>

	var reader ReadBook
	reader = book // pair<type: Book, value: book地址>
	reader.read()

	var writer WriteBook
	writer = reader.(WriteBook) // 因为 pair 传递过程中不变，都是 Book，所以断言成功
	writer.write()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// 首先当前目录新建一个 `test.txt` 文件
import (
	"fmt"
	"io"
	"os"
)

func main() {
	// file: pair<type: *os.File, value: "./test.txt"文件描述符>
	file, err := os.OpenFile("./test.txt", os.O_RDWR, 0)
	if err != nil {
		fmt.Println("open file error")
		fmt.Println(err)
		return
	}

	var reader io.Reader = file // pair<type: *os.File, value: "./test.txt"文件描述符>

	var writer io.Writer
    // *os.File 同时实现了 io.Reader 和 io.Writer 接口
    // 所以断言成功，并把 pair 结构传递给 writer
	writer = reader.(io.Writer) 
	writer.Write([]byte("Hello, golang!")) // 成功写入
}

 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
50
51
52
53
54
55
56
57
58
59
60
61
62

import (
	"fmt"
	"reflect"
)

type User struct {
	Id   int    `info:"唯一id"` // 属性标签
	Name string `info:"名字"`
	Age  uint8  `info:"年龄" desc:"小于128"`
}

// 实现一个方法
func (this User) Call() {
	fmt.Println("User is called..")
	fmt.Printf("%v\n", this)
}

func main() {
	user := User{1, "Saly", 20}
	ref(user)
}

// 通过反射处理传入变量类型结构
func ref(input interface{}) {
	// 1、获取类型
	fmt.Println("======= type ======")
	inputType := reflect.TypeOf(input)
	fmt.Println("input type is: ", inputType)

	// 2、获取值
	fmt.Println("======= value ======")
	inputValue := reflect.ValueOf(input)
	fmt.Println("input value is: ", inputValue)

	// 3、获取字段、值、标签
	fmt.Println("======= field:value ======")
	for i := 0; i < inputType.NumField(); i++ {
		field := inputType.Field(i)
		filedValue := inputValue.Field(i).Interface()
		infoTag := field.Tag.Get("info")
		descTag := field.Tag.Get("desc")
		if len((descTag)) > 0 {
			descTag = ", " + descTag
		}
		fmt.Printf("%s %v = %v [%s%v]\n", field.Name, field.Type, filedValue, infoTag, descTag)
	}

	// 4、获取方法
	fmt.Println("======= method ======")
	// 注意：在 golang 17 版本以后，返回的是不传类型指针的方法的数量
	mNUm := inputType.NumMethod()
	for i := 0; i < mNUm; i++ {
		method := inputType.Method(i)
		fmt.Printf("%s %v\n", method.Name, method.Type)
	}

	fmt.Println("======= method by name ======")
	// 注意：在 golang 17 版本以后，只能获取不传类型指针的方法
	m, ok := inputType.MethodByName("Call")
	fmt.Println("ok = ", ok)
	fmt.Printf("%s %v\n", m.Name, m.Type)
}