GO_note

GO入门学习遇到的一些小贴士，给自己当note

学习资料：https://www.liwenzhou.com/posts/Go/go_menu/

Snipples

VS CODE中使用快捷操作，如下

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
{
	// Place your snippets for go here. Each snippet is defined under a snippet name and has a prefix, body and 
	// description. The prefix is what is used to trigger the snippet and the body will be expanded and inserted. Possible variables are:
	// $1, $2 for tab stops, $0 for the final cursor position, and ${1:label}, ${2:another} for placeholders. Placeholders with the 
	// same ids are connected.
	// Example:
	// "Print to console": {
	// 	"prefix": "log",
	// 	"body": [
	// 		"console.log('$1');",
	// 		"$2"
	// 	],
	// 	"description": "Log output to console"
	// }
	"printin":{
		"prefix": "pln",
		"body": "fmt.Println($0)",
		"description": "output,printin"
	},
	"printf":{
		"prefix": "plf",
		"body": "fmt.Printf($0)",
		"description": "output,printf"
	}
}

字符串花操及变量

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
package main

import (
	"fmt"
	"math"
	"strings"
)

func main() {
	// max float of different type
	fmt.Println(math.MaxFloat64)
	fmt.Println(math.MaxFloat32)
	//complex number : 64 and 128
	var c complex64
	c = 1 + 2i
	fmt.Println(c)
	//str
	str1 := "Let's go!\r\n"
	str2 := "xiaoyuyu"
	fmt.Println(str1, str2) //拼接后自带一个空格
	//多行str 用` 但是当中所有转义字符失效
	str := `
	first line
	second line
	last
	+
	line
	\t\n\r
	`
	fmt.Println(str)

	//字符串花操
	//split 切割
	str3 := "how do you do"
	fmt.Println(strings.Split(str3, " "))
	fmt.Printf("%T\n", strings.Split(str3, " "))  //%T输出type
	//拼接切片
	str4 := []string{"how", "do", "you", "do"}
	fmt.Println(strings.Join(str4, "+"))

    //要修改字符串，需要先将其转换成[]rune或[]byte，完成后再转换为string。
	//无论哪种转换，都会重新分配内存，并复制字节数组
	s1 := "big"
	// 强制类型转换
	byteS1 := []byte(s1)
	byteS1[0] = 'p'
	fmt.Println(string(byteS1))

	s2 := "白萝卜"
	runeS2 := []rune(s2)
	runeS2[0] = '红'
	fmt.Println(string(runeS2))
    
	//字符类型1：byte   字符类型2：rune
	//byte unit8别名 ASCII码
	//rune int32别名 UTF-8字符 处理中文、日文或者其他复合字符
	var c1 byte
	var c2 rune
	fmt.Printf("c1:%T c2:%T", c1, c2)
}

for range（键值循环）

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

import (
	"fmt"
)

func main() {
	//每个 rune 字符和索引在 for range 循环中是一一对应的
	//它能够自动根据 UTF-8 规则识别 Unicode 编码的字符
	//便于我们输出中文
	str5 :="hello大娃的力量"
	for key,value:= range str5{
		fmt.Printf("%d %c\n",key,value)
	}
	for _,value:= range str5{
		fmt.Printf("%c\n",value)
	}
	//普通的for循环会出现乱码，因为中文字符无法识别
	for i:=0;i<len(str5);i++{
		fmt.Printf("%c\n",str5[i])
	}
}

reflect.TypeOf 获取类型

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

import (
	"fmt"
	"reflect"
)

//编写代码统计出字符串"hello沙河小王子"中汉字的数量
func main(){
	count:=0
	str:="hello沙河小王子"
	fmt.Println(reflect.TypeOf(str))
	for _,value:=range str{
		if value>256 {
			count++;
		}
	}
	fmt.Println(count)
}

if else :tips

Go语言规定与if匹配的左括号{必须与if和表达式放在同一行，{放在其他位置会触发编译错误。 同理，与else匹配的{也必须与else写在同一行，else也必须与上一个if或else if右边的大括号在同一行

switch

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

import (
	"fmt"
)

func main() {
	//test switch
	score := 312
	switch {
	case score < 270: //可以用值，也可以用判别式，如用判别式，可以省略switch后面的变量填充
		fmt.Println("Go to find jobs")
	case score >= 280:
		fmt.Println("Try to find school")
		fallthrough //如满足本case，下一个case结果也输出
	case score == 312:
		fmt.Println("Keep going")
	case score >= 350 && score <= 500: //判别式用逻辑运算符分割，值用逗号分隔
		fmt.Println("Congratulations")
	}
}

九九乘法表

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

import (
	"fmt"
)

func main() {
	//九九乘法表
	for i:=1;i<=9;i++{
		for j:=1;j<=i;j++{
			fmt.Printf("%d * %d = %d\t",i,j,i*j)
		}
		fmt.Println()
	}
}

数组是值类型

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
package main

import (
	"fmt"
)

func main() {
	var x = [3][3]int{
		{1, 2, 3},
		{4, 5, 6},
		{7, 8, 9},
	}
	y := x
	//数组是值类型，赋值和传参会复制整个数组。因此改变副本的值，不会改变本身的值
	fmt.Println(y[0][0]) //1
	change(y)
	fmt.Println(y[0][0]) //1  没有发生改变
	y[0][0] = 100
	fmt.Println(y[0][0]) //100

	//找出数组中和为指定值的两个元素的下标，
	//比如从数组[1, 3, 5, 7, 8]中找出和为8的两个元素的下标分别为(0,3)和(1,2)
	a := [...]int{1, 3, 5, 7, 8}
	findSum(a, 8)
}

func change(a [3][3]int) {
	a[0][0] = 100
}

//如果这里改成a [...]int会报错，说明函数里不能这么写，要确定的值
func findSum(a [5]int, b int) {
	for index, value := range a {
		for i := index; i < len(a); i++ {
			if a[i]+value == b {
				fmt.Printf("(%d,%d)", index, i)
			}
		}
	}
}

切片

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
package main

import (
	"fmt"
	"sort"
)

func main() {
	//因为数组的长度是固定的并且数组长度属于类型的一部分，所以数组有很多的局限性
	//切片（Slice）是一个拥有相同类型元素的可变长度的序列。
	//它是基于数组类型做的一层封装。它非常灵活，支持自动扩容
	//切片是一个引用类型，它的内部结构包含地址、长度和容量。切片一般用于快速地操作一块数据集合
	//切片能直接定义；也能从数组传参；也能从切片再切片
	//还可以用make函数创造切片
	a := make([]int, 5, 10)
	fmt.Println(a)
	fmt.Printf("%T\n", a)
	fmt.Println(len(a))
	fmt.Println(cap(a))
	//切片之间是不能比较的，我们不能使用==操作符来判断两个切片是否含有全部相等元素
	//一个nil值的切片并没有底层数组，一个nil值的切片的长度和容量都是0
	//所以要判断一个切片是否是空的，要是用len(s) == 0来判断，不应该使用s == nil来判断

	//拷贝前后两个切片共享底层数组，对一个切片的修改会影响另一个切片的内容，这点需要特别和数组区别
	//这时就可以用copy函数，来创建一个空间不同，元素相同的切片
	b := []int{1, 2, 3, 4, 5, 6}
	c := b
	d := make([]int, 6, 10)
	copy(d, b)
	d[3] = 1000
	fmt.Println(d)
	fmt.Println(b)
	c[4] = 100
	fmt.Println(b)
	fmt.Println(c)

	//数组排序技巧
	//sort可以自动排序，但对象是切片
	//第一步先生成一个指向底层数组的切片
	//第二部对切片排序，从而也对数组排序
	x := [...]int{312, 335, 765, 11, 657, 90}
	//Ints sorts a slice of ints in increasing order.
	sort.Ints(x[:])
	fmt.Println(x)
}

map

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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
package main

import (
	"fmt"
	"math/rand"
	"reflect"
	"sort"
)

//map
func main() {
	//string to int
	var a map[string]int //未初始化，是nil
	fmt.Println(a == nil)
	//初始化，用make
	a = make(map[string]int, 8)
	//未初始化的话不能直接赋值键值对
	a["AAA"] = 100
	a["BBB"] = 200
	fmt.Println(a)
	fmt.Println(reflect.TypeOf(a))
	//生命同时初始化
	b := map[int]string{
		3: "xiaowang",
		1: "xiaoli",
		2: "xiaohong",
	}
	fmt.Println(b)
	b[7] = "xiaoming"
	b[0] = "xiaoxiao"

	//查询map中是否存在某键
	value, ok := b[5]
	fmt.Println(value, ok) //如果没有查询到，返回默认值，字符串就是空值
	value, ok = b[7]
	fmt.Println(value, ok)

	//删除键值对使用delete
	delete(b, 2)
	fmt.Println(b)

	//模拟map的排序功能
	scoreMap := make(map[string]int, 100)
	//生成随机序列
	for i := 0; i < 50; i++ {
		key := fmt.Sprintf("stu%02d", i)
		value := rand.Intn(101) //0~100
		scoreMap[key] = value
	}
	// fmt.Println(scoreMap)   确实是无序的
	// 按key排序输出scoremap
	// 1.将key放入切片
	keys := make([]string, 0, 100)
	for k := range scoreMap {
		keys = append(keys, k)
	}
	// 2.将key排序
	sort.Strings(keys)
	// 3.按找排序后的key顺序输出map的键值对
	for _, key := range keys {
		fmt.Println(key, scoreMap[key])
	}

	// 元素类型为map的slice
	// 先进行切片初始化
	mapSlice := make([]map[string]int, 8, 8)
	// 再进行map的初始化
	mapSlice[0] = make(map[string]int, 8)
	// 可以赋值了
	mapSlice[0]["AAAA"] = 100
	fmt.Println(mapSlice)

	// 元素类型为slice的map
	// 完成map的初始化
	sliceMap := make(map[string][]string, 8)
	sliceMap["中国"] = make([]string, 4, 8)
	sliceMap["中国"][0] = "上海"
	sliceMap["中国"][1] = "广州"
	sliceMap["中国"][2] = "深圳"
	fmt.Println(sliceMap)
	sliceMap["中国"] = append(sliceMap["中国"], "北京", "南京")
	fmt.Println(sliceMap)
}

函数：可变参数

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

import (
	"reflect"
	"fmt"
)

func main()  {
	ret:=changeE(10,20,40)
	fmt.Println(ret)
}

//函数接受可变参数，若输出，输出的type是slice
//可变参数一定要放在最后
func changeE(a ...int) int{
	fmt.Println(a)
	fmt.Println(reflect.TypeOf(a))
	ret:=0
	for _,value:= range a{
		ret+=value
	}
	return ret
	
}

defer：延迟执行

看一下结果与上面有何不同便知

在Go语言的函数中return语句在底层并不是原子操作，它分为给返回值赋值和RET指令两步。而defer语句执行的时机就在返回值赋值操作后，RET指令执行前

处理资源释放或者时间问题

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

import (
	"reflect"
	"fmt"
)

func main()  {
	ret:=changeE(10,20,40)
	fmt.Println(ret)
}

//函数接受可变参数，若输出，输出的type是slice
//可变参数一定要放在最后
func changeE(a ...int) int{
	defer fmt.Println(a)
	defer fmt.Println(reflect.TypeOf(a))
	ret:=0
	for _,value:= range a{
		ret+=value
	}
	return ret
}

局部变量

如果局部变量和全局变量重名，优先访问局部变量

定义函数类型：type

就像定义变量一样，将一类函数都定义为同一种

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

import (
	"reflect"
	"fmt"
)

func main()  {
	type calculation func (int,int)int
	var c calculation=add
	fmt.Println(c(1,2))
	fmt.Println(reflect.TypeOf(c))  //main.calculation
    fmt.Println(cal(20, 40, add))
}

func add(a,b int)int  {
	ret:=a+b
	return ret
}

func cal(a, b int, op func(int, int) int) int {
	return op(a, b)
}

匿名函数

有点鸡肋，目前不知道适合什么场景，只能说便于快速执行，闭包里很好用

匿名函数就是没有函数名的函数

闭包

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
package main

import (
	"fmt"
	"strings"
)

// 闭包
// 定义一个函数，返回值也是函数
func a() func() {
	name := "xiaoyuyu"
	// 内部创建了一个匿名函数
	return func() {
		fmt.Println("hello world!", name)
	}
}

// 细品
// 文件后缀名检测
func makeSuffixFunc(suffix string) func(string) string {
	return func(name string) string {
		if !strings.HasSuffix(name, suffix) {
			return name + suffix
		}
		return name
	}
}

func main() {
	// 闭包 = 函数 + 外层变量的应用(比如 name)
	r := a()
	r()
	ans := makeSuffixFunc(".txt") // suffix=.txt
	ret := ans("xiaoyuyu")        // name=xiaoyuyu
	fmt.Println(ret)              // xiaoyuyu.txt
}

panic/recover

  1. recover()必须搭配defer使用。
  2. defer一定要在可能引发panic的语句之前定义
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
package main

import "fmt"

// panic && recover
func funcA() {
	fmt.Println("func A")
}

// 用defer 配合 recover来抓取错误，并让程序继续运行
func funcB() {
	defer func() {
		err := recover()
		if err != nil {
			fmt.Println("funcB error!")
		}
	}()
	panic("panic in B")
}

func funcC() {
	fmt.Println("func C")
}
func main() {
	funcA()
	funcB()
	funcC()
}

指针：一定要初始化(new/make)

在Go语言中对于引用类型的变量，我们在使用的时候不仅要声明它，还要为它分配内存空间，否则我们的值就没办法存储。而对于值类型的声明不需要分配内存空间，是因为它们在声明的时候已经默认分配好了内存空间。要分配内存，就引出new和make

make函数是无可替代的，我们在使用slice、map以及channel的时候，都需要使用make进行初始化，然后才可以对它们进行操作

make也是用于内存分配的，区别于new，它只用于slice、map以及chan的内存创建，而且它返回的类型就是这三个类型本身，而不是他们的指针类型，因为这三种类型就是引用类型，所以就没有必要返回他们的指针了

自定义类型与类型别名

1
2
3
4
5
6
7
8
9
10
11
12
13
//类型定义
type NewInt int

//类型别名
type MyInt = int

func main() {
	var a NewInt
	var b MyInt
	
	fmt.Printf("type of a:%T\n", a) //type of a:main.NewInt
	fmt.Printf("type of b:%T\n", b) //type of b:int
}

结构体

构造函数

Go语言的结构体没有构造函数，我们可以自己实现。 例如，下方的代码就实现了一个person的构造函数。 因为struct是值类型，如果结构体比较复杂的话，值拷贝性能开销会比较大，所以该构造函数返回的是结构体指针类型

1
2
3
4
5
6
7
func newPerson(name, city string, age int8) *person {
	return &person{
		name: name,
		city: city,
		age:  age,
	}
}

方法和接收者

定义如下

1
2
3
func (接收者变量 接收者类型) 方法名(参数列表) (返回参数) {
    函数体
}
  • 接收者变量：接收者中的参数变量名在命名时，官方建议使用接收者类型名称首字母的小写，而不是self、this之类的命名。例如，Person类型的接收者变量应该命名为 p，Connector类型的接收者变量应该命名为c等。
  • 接收者类型：接收者类型和参数类似，可以是指针类型和非指针类型。
  • 方法名、参数列表、返回参数：具体格式与函数定义相同。

当方法作用于值类型接收者时，Go语言会在代码运行时将接收者的值复制一份。在值类型接收者的方法中可以获取接收者的成员值，但修改操作只是针对副本，无法修改接收者变量本身

什么时候应该使用指针类型接收者呢？

  1. 需要修改接收者中的值
  2. 接收者是拷贝代价比较大的大对象
  3. 保证一致性，如果有某个方法使用了指针接收者，那么其他的方法也应该使用指针接收者
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
package main

import "fmt"

// Student 结构体
type Student struct {
	name  string
	age   int
	score int
}

// NewStudent 构造函数
func NewStudent(name string, age int, score int) *Student {
	return &Student{
		name: name,
		age:  age,
	}
}

// Dream Student 一个方法例子
func (s Student) Dream() {
	fmt.Printf("%s's dream is to get into gradute school!\n", s.name)
}

// SetAge Student 修改学生的年龄
func (s *Student) SetAge(newAge int) {
	s.age = newAge
}

func main() {
	s1 := NewStudent("xiaoyuyu", 22, 312)
	s1.Dream()
	s1.SetAge(50)
	fmt.Println(s1.age)
}

嵌套结构体

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
//Address 地址结构体
type Address struct {
	Province string
	City     string
}

//User 用户结构体
type User struct {
	Name    string
	Gender  string
	Address Address
}

func main() {
	user1 := User{
		Name:   "小王子",
		Gender: "男",
		Address: Address{
			Province: "山东",
			City:     "威海",
		},
	}
	fmt.Printf("user1=%#v\n", user1)//user1=main.User{Name:"小王子", Gender:"男", Address:main.Address{Province:"山东", City:"威海"}}
}

结构体的“继承”

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
package main

import "fmt"

// Animal struct
type Animal struct {
	name string
}

// Move Animal
func (a Animal) Move() {
	fmt.Printf("%s can move\n", a.name)
}

// Dog struct
type Dog struct {
	speed   int
	*Animal // 匿名潜逃
}

// bark Dog
func (d Dog) bark() {
	fmt.Printf("%s can bark!\n",d.name)
}

func main() {
	d := Dog{
		speed: 20,
		Animal: &Animal{
			name: "xiaoli",
		},
	}
	d.Move()
	d.bark()
}

结构体字段的可见性

真的很方便，没有private,public这些花里胡哨的

结构体中字段大写开头表示可公开访问，小写表示私有（仅在定义当前结构体的包中可访问）

结构体与JSON序列化

这么多后端语言，瞧把大家逼疯了，统一出了一个json

JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。易于人阅读和编写。同时也易于机器解析和生成。JSON键值对是用来保存JS对象的一种方式，键/值对组合中的键名写在前面并用双引号""包裹，使用冒号:分隔，然后紧接着值；多个键值之间使用英文,分隔

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
package main

import (
	"encoding/json"
	"fmt"
)

//JSON

// Student struct
type Student struct {
	ID   int `json:"id!!!"` //Tag
	Name string
}

// NewStudent student的构造函数
func NewStudent(id int, name string) Student {
	return Student{
		ID:   id,
		Name: name,
	}
}

// class struct
type class struct {
	Title    string
	Students []Student
}

func main() {
	// create a class
	c := class{
		Title:    "shanghai zoo",
		Students: make([]Student, 0, 20),
	}
	// insert member
	for i := 0; i < 5; i++ {
		temp := NewStudent(i, fmt.Sprintf("stu%02d", i))
		c.Students = append(c.Students, temp)
	}
	fmt.Println(c)
	// JSON 序列化 ：GO -> JSOn
	data, err := json.Marshal(c)
	if err != nil {
		fmt.Println("json marshal failed, err:", err)
		return
	}
	fmt.Printf("%s\n", data)
	fmt.Printf("%T\n", data)
	fmt.Println()
	// JSON 反序列化 ：JSON -> GO
	jsonStr := `{"Title":"shanghai zoo","Students":[{"ID":0,"Name":"stu00"},{"ID":1,"Name":"stu01"},{"ID":2,"Name":"stu02"},{"ID":3,"Name":"stu03"},{"ID":4,"Name":"stu04"}]}`
	var c2 class
	err = json.Unmarshal([]byte(jsonStr), &c2)
	if err != nil {
		fmt.Println("json unmarshal failed, err:", err)
		return
	}
	fmt.Println(c2)
}

final(小结)

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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
package main

import (
	"fmt"
	"math/rand"
)

// 使用“面向对象”的思维方式编写一个学生信息管理系统。
// 学生有id、姓名、年龄、分数等信息
// 程序提供展示学生列表、添加学生、编辑学生信息、删除学生等功能

// Student struct
type Student struct {
	ID    int
	Name  string
	Age   int
	Score int
}

// NewStudent Student的构造函数
func NewStudent(id int, name string, age int, score int) *Student {
	return &Student{
		ID:    id,
		Name:  name,
		Age:   age,
		Score: score,
	}
}

// List struct
type List struct {
	Student []Student
}

// ShowList List 展示列表内学生的信息
func (l List) ShowList() {
	for _, value := range l.Student {
		fmt.Println(value)
	}
}

// AddStudent List 增添学生
func (l *List) AddStudent(id int, name string, age int, score int) {
	temp := NewStudent(id, name, age, score)
	l.Student = append(l.Student, *temp)
}

// DeleteStudent List 删除学生(按编号删除，因为编号必唯一)
func (l *List) DeleteStudent(id int) {
	for index, value := range l.Student {
		if value.ID == id {
			l.Student = append(l.Student[:index], l.Student[index+1:]...)
			break
		}
	}
}

// SetStudent List 修改列表中学生信息
func (l *List) SetStudent(id int, name string, age int, score int) {
	for index, value := range l.Student {
		if value.ID == id {
			l.Student[index].ID = id
			l.Student[index].Name = name
			l.Student[index].Age = age
			l.Student[index].Score = score
			break
		}
	}
}

func main() {
	// create a list
	List := List{
		Student: make([]Student, 0, 20),
	}
	// append
	for i := 0; i < 5; i++ {
		List.AddStudent(i, fmt.Sprintf("stu%02d", i), rand.Intn(21), rand.Intn(101))
	}
	List.ShowList()
	List.SetStudent(4, "xiaoyuyu", 3, 100)
	List.DeleteStudent(3)
	fmt.Println()
	List.ShowList()
}

本文作者： xiaoyuyu
本文链接： http://woaixiaoyuyu.github.io/2020/02/25/GO-note/
版权声明： 本作品采用 知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议 进行许可。转载请注明出处！
赏

谢谢你请我吃糖果

扫一扫，分享到微信

微信分享二维码
本站总访问量次 本站访客数人

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

记录成长的点滴<br><br>涉猎颇广的信息技术爱好者<br>希望未来的xiaoyuyu<br>可以成为优秀的工程师