这是我参与「第五届青训营 」伴学笔记创作活动的第 1 天
Go语言简介
Go语言是Google主导开发的通用性计算机编程语言，Go是具有高性能、高并发特性的编程语言，具有和C++、Java可以媲美的性能并且天然支持高并发。
Go的语法相对简单，学习起来比较容易。另外Go还具有丰富的标准库、完善的工具链(编译、代码格式化、错误检查、包管理、代码提示、代码测试等)，支持快速编译、跨平台、自动垃圾回收等特性。
开发环境
安装Go的开发环境，可以直接参考Go官网进行下载安装，过程比较简单。
使用Go模块代理可以加速Go的依赖下载速度。
Go开发编辑器主要有VSCode和GoLand，这两款编辑器都支持跨平台。GoLand相对于初学者来说比较友好，由于我的电脑已经安装VSCode了，所以就没再安装GoLand（收费的而且电脑扛不住😭）。
基础语法
快速入门
学习一门语言，当时是先“Hello World”一下啦。
package main
import "fmt"
func main() {
fmt.Println("Hello World")
}
package定义一个包，只有main这个包才能使用go run 或go build直接运行。
import是导入本文件中所需要的包。
main是入口函数，main函数是每一个可执行程序所必须包含的，一般是在启动后第一个执行的函数（如果有init函数，先执行init）。
go运行代码的方式有两种，一种是直接运行，另一种是编译生成可执行文件再运行。
直接运行：go run main.go
编译运行：go build main.go
编译后会生成一个main文件，window上是main.exe，然后直接运行该文件即可。
变量
Go语言变量名由字母、数字、下划线组成，其中首个字符不能为数字。
变量类型包含：字符串、整形、浮点型、布尔型、其他类型(指针、结构体、channel、函数、切片、接口、Map等)。
变量声明
变量在使用前必须要提前声明，可以使用类型推断或者显示声明类型，声明变量的一般形式是使用 var 关键字。
使用类型推断时，需要为变量指定值，go会根据值来推断该变量是什么具体类型。
var str = "我是字符串。"
var num = 1
var 关键字其实也是可以省略的，不过要把=换成:=。
str := "我是字符串。"
num := 1
使用显示声明变量时，需要在变量后面执行该变量的具体类型，如果声明时不指定具体的值，则会被赋值为默认值。
var str string // str的值为""(空字符串)
var num int // num的值为0
可以在声明变量的同时给变量进行赋值。
var str string = "我是字符串"
var num int = 1
多个变量在同一行同时声明。
var str1, str2 string = "字符串1", "字符串2"
var num1, num2 int = 1, 2
a, b := 1, 2
常量声明
Go在声明常量时，使用const关键字。常量的值一旦初始化好后就不可更改。
const str string = "我是字符串"
const num int = 1
const a, b = 3, 4
num = 2 // 若更改会报错
流程控制
if语句
Go的if语句和C、C++类似，只不过if后面没有括号，但是加上括号也能正确运行，在IDE中如果在if后面加上括号保存时可能会被直接去掉，另外if后面的开始大括号必须跟if在同一行，不能换行(会报错)。
num1 := 1
num2 := 2
if num1 < num2 {
fmt.Println("num1 < num2")
} else {
fmt.Println("num1 >= num2")
}
if语句后面也可以定义变量，但只能用一个分号。也支持if-else-if语句。
if num1, num2 := 1, 2; num1 < num2 {
fmt.Println("num1 < num2")
} else if num1 > num2 {
fmt.Println("num1 < num2")
} else {
fmt.Println("num1 = num2")
}
for循环
在Go里没有while和do-while循环，只有for循环。Go的for循环包含了for和while的功能。
用for定义死循环，相当于while(true)。
for {
fmt.Println("loop")
}
for true {
fmt.Println("loop")
}
用for定义普通的循环，三段式，任何一段都可以省略，在for循环里也可以使用continue和break来跳出循环。
// 普通for循环
for i := 0; i < 5; i++ {
fmt.Println(i)
}
// 使用continue
for i := 0; i < 5; i++ {
if i == 3 {
continue
}
fmt.Println(i)
}
// 使用break
for i := 0; i < 5; i++ {
if i == 3 {
break
}
fmt.Println(i)
}
用for定义while的功能。
num := 1
for num < 5 {
fmt.Println(num)
num++
}
switch
switch语句也和C、C++的switch语句类似，只不过switch后面不需要加括号，case里也不需要加break，Go的switch 默认情况下 case 最后自带 break 语句，匹配成功后就不会执行其他 case，如果我们需要执行后面的 case，可以使用 fallthrough 。
num := 2
switch num {
case 1:
fmt.Println("one")
case 2, 3:
fmt.Println("two or three")
default:
fmt.Println("other")
}
Go的switch可以匹配任意类型，也可以实现if-else的功能，在switch后面不加匹配条件，可以在case里进行匹配。
t := time.Now()
switch {
case t.Hour() < 12:
fmt.Println("It's before noon")
default:
fmt.Println("It's after noon")
}
数组Array
数组（array）是具有相同唯一类型的一组已编号且长度固定的数据项序列，这种类型可以是任意的原始类型例如整型、字符串或者自定义类型。
一维数组
数组声明以及访问如下：
// 声明一个长度为5的数组
var a [5]int
a[4] = 100
fmt.Println("get:", a[2])
fmt.Println("len:", len(a))
// 声明并初始化
b := [5]int{1, 2, 3, 4, 5}
fmt.Println(b)
上述代码，a为长度为5的数组，为数组的某个元素赋值，可以通过数组下标进行赋值，如a[4] = 100。
也可以通过:=声明并初始化一个数组。
多维数组
多维数组的声明方式和一维数组类似，几维数组就加几个中括号，例如二维数据的声明以及赋值代码如下：
var twoD [2][3]int
for i := 0; i < 2; i++ {
for j := 0; j < 3; j++ {
twoD[i][j] = i + j
}
}
fmt.Println("2d: ", twoD)
切片Slice
切片（slice）与数组的区别是切片的长度不是固定的而是可变的，比数组的用途更加广泛。
切片声明需要通过make来进行，需要指定切片的类型以及长度，例如下面为创建一个长度为3的string类型的切片。
// 声明一个空切片
s1 := make([]string, 3)
// 声明并初始化
s2 :=[] int {1,2,3,4,5,6}
切片除了长度还有一个容量（capacity）的概念，可以在声明切片的时候同时指定长度和容量。
s := make([]string, 3, 10)
对切片元素的操作，可以像数组一样操作：
s := make([]string, 3)
s[0] = "a"
s[1] = "b"
s[2] = "c"
可以通过append方法向切片中添加元素，因为切片会涉及到扩容，所以需要一个变量来接收返回值。
s = append(s, "d")
s = append(s, "e", "f")
可以通过copy方法对切片进行复制，复制后是两个独立的切片，更改元素值相互不影响。
c := make([]string, len(s))
copy(c, s)
fmt.Println(c) // [a b c d e f]
既然是切片，很容易联想到python的切片操作，下面来看下Go的切片功能，与python的切片相比，Go的切片不支持-1下标。
// 返回下标2到4的值
fmt.Println(s[2:5]) // [c d e]
// 返回下标0到4的值
fmt.Println(s[:5]) // [a b c d e]
// 返回下标2到最后一个元素
fmt.Println(s[2:]) // [c d e f]
集合Map
Map 是一种无序的键(key)值(value)对的集合，也被称为映射、字典。
Map是无序的，支持类似数组和切片的操作。
Map的声明如下：
m := make(map[string]int)
这行代码是声明了一个键为string类型，值为int类型的空Map。
也可以在声明的同时对其进行初始化操作：
m2 := map[string]int{"one": 1, "two": 2}
对Map的赋值和数组类似通过”下标“进行操作，只不过这个”下标“对应的是key。
m["one"] = 1
m["two"] = 2
对Map元素的访问，也是通过”下标“来访问的，如果访问的key不存在的话会返回0。
fmt.Println(m["one"]) // 1
fmt.Println(m["unknow"]) // 0
对于不存在的key返回0，如果一个key的值也为0，就很容易产生不必要的误会，Go在查询key时返回了两个值，一个是结果，另一个是bool类型的值代表是否存在。
r, ok := m["unknow"]
fmt.Println(r, ok) // 0 false
可以使用delete函数来删除Map中的键值对。
delete(m, "one")
range遍历
数组、切片、Map都可以使用range来遍历，通过range可以得到索引和对应的值。
nums := []int{2, 3, 4}
sum := 0
// 遍历切片
for i, num := range nums {
fmt.Println("index:", i, "num:", num)
}
// 遍历Map
m := map[string]string{"a": "A", "b": "B"}
for k, v := range m {
fmt.Println(k, v) // b 8; a A
}
// 只获取key
for k := range m {
fmt.Println("key", k) // key a; key b
}
// 只获取value
for _, v := range m {
fmt.Println("value", v) // value A; value B
}
函数
函数定义格式如下：
func function_name( [parameter list] ) [return_types] {
函数体
}
例如，定义一个两个数相加的函数：
func add(a int, b int) int {
return a + b
}
Go函数可以返回多个值，一般来说，第一个是函数的返回值，第二个是错误信息。
func exists(m map[string]string, k string) (v string, ok bool) {
v, ok = m[k]
return v, ok
}
指针
Go支持指针，相对于C语言，Go的指针功能十分简单，当然功能也很有限，主要用途就是对函数传入的参数进行修改。
默认情况下，Go函数的参数传参是值传递，也就是拷贝了一个副本，对其修改不会影响原来的值，如果要对原来的值也要变的话，需要使用指针。
定义指针时，需要用*号来表示指针，传参时需要用到&符号。
func add2(n int) {
n += 2
}
func add2ptr(n *int) {
*n += 2
}
func main() {
n := 5
add2(n)
fmt.Println(n) // 5
add2ptr(&n)
fmt.Println(n) // 7
}
结构体
结构体是由一系列具有相同类型或不同类型的数据构成的数据集合，相当于其他语言中的类。
结构体定义
结构体定义需要使用 type 和 struct 语句。
type struct_variable_type struct {
member definition
...
member definition
}
例如，定义一个包含name和password的user结构体：
type user struct {
name string
password string
}
结构体的初始化，可以指定字段初始化，也可以全部初始化。
a := user{name: "wang", password: "1024"}
b := user{"wang", "1024"}
c := user{name: "wang"}
对于结构体内部成员的访问可以通过.操作符来进行访问或赋值。
var d user
d.name = "wang"
d.password = "1024"
fmt.Println(d.password)
结构体方法
结构体方法可以理解为其他语言类的成员函数。
把一个普通方法的func关键字后面加上结构体信息，就代表这个方法是属于结构体的。
为user结构体添加一个检查密码的函数：
func (u user) checkPassword(password string) bool {
return u.password == password
}
为user结构体添加一个重置密码的函数，因为要修改结构体内部的值，所以要使用指针类型：
func (u *user) resetPassword(password string) {
u.password = password
}
结构体方法的调用：
a := user{name: "wang", password: "1024"}
a.resetPassword("2048")
fmt.Println(a.checkPassword("2048")) // true
错误处理
Go内置的错误接口提供了非常简单的错误处理机制，error类型是一个接口类型，其定义如下：
type error interface {
Error() string
}
Go函数可以返回多个值，通常函数的最后一个值用来代表错误信息，在函数内部可以使用errors.New 可返回一个错误信息：
func findUser(users []user, name string) (v *user, err error) {
for _, u := range users {
if u.name == name {
return &u, nil
}
}
return nil, errors.New("not found")
}
如果函数不出现错误的话，可以直接返回nil。
在调用函数的时候，需要用多个变量来接收函数的返回值，我们可以通过函数的返回值来判断是否发生了异常。
u, err := findUser([]user{{"wang", "1024"}}, "wang")
if err != nil {
fmt.Println(err)
return
}
标准库
Go内置了非常丰富的标准库工具，包括字符串操作、字符串格式化、json处理、时间处理等。
字符串操作
a := "hello"
// 是否包含
fmt.Println(strings.Contains(a, "ll")) // true
// 字符统计
fmt.Println(strings.Count(a, "l")) // 2
// 判断字符串开头
fmt.Println(strings.HasPrefix(a, "he")) // true
// 判断字符串结尾
fmt.Println(strings.HasSuffix(a, "llo")) // true
// 查找字符串
fmt.Println(strings.Index(a, "ll")) // 2
// 字符串拼接
fmt.Println(strings.Join([]string{"he", "llo"}, "-")) // he-llo
// 复制字符串指定次数
fmt.Println(strings.Repeat(a, 2)) // hellohello
// 字符串替换
fmt.Println(strings.Replace(a, "e", "E", -1)) // hEllo
// 字符串分割
fmt.Println(strings.Split("a-b-c", "-")) // [a b c]
// 转为小写
fmt.Println(strings.ToLower(a)) // hello
// 转为大写
fmt.Println(strings.ToUpper(a)) // HELLO
// 字符串长度
fmt.Println(len(a)) // 5
字符串格式化
Println最为常用作用为打印并换行，Printf可以按指定格式打印字符串。
+v可以打印字段和值详细信息。
#v可以打印出整个结构体的构造以及详细信息。
s := "hello"
n := 123
p := point{1, 2}
fmt.Println(s, n) // hello 123
fmt.Println(p) // {1 2}
fmt.Printf("s=%v\n", s) // s=hello
fmt.Printf("n=%v\n", n) // n=123
fmt.Printf("p=%v\n", p) // p={1 2}
fmt.Printf("p=%+v\n", p) // p={x:1 y:2}
fmt.Printf("p=%#v\n", p) // p=main.point{x:1, y:2}
f := 3.141592653
fmt.Println(f) // 3.141592653
fmt.Printf("%.2f\n", f) // 3.14
json处理
Go在处理json时十分简单，只需要将结构体中的字段第一个字母变成大写就能用内置的JSON工具进行处理。
Go中一些特殊的类型，比如Channel、complex、function是不能被解析成JSON的。
Go中JSON对象只支持string作为key，对于map，那么必须是map[string]T这种类型，T可以是Go语言中任意的类型。
Go的json处理是通过Marshal、Unmarshal方法来进行处理的。
Marshal 用于自定义编码json的方法，也就是将变量、对象转成json，转换之后需要用string方法强转一下，否则会打印出的是16进制字符串。
Unmarshal用于自定义解码json方法，也就是将json转为对象。
type userInfo struct {
Name string
Age int `json:"age"` // 自定义json输出的字段
Hobby []string
}
func main() {
a := userInfo{Name: "wang", Age: 18, Hobby: []string{"Golang", "TypeScript"}}
buf, err := json.Marshal(a)
if err != nil {
panic(err)
}
fmt.Println(buf) // [123 34 78 97...]
fmt.Println(string(buf)) // {"Name":"wang","age":18,"Hobby":["Golang","TypeScript"]}
buf, err = json.MarshalIndent(a, "", "\t")
if err != nil {
panic(err)
}
fmt.Println(string(buf))
var b userInfo
err = json.Unmarshal(buf, &b)
if err != nil {
panic(err)
}
fmt.Printf("%#v\n", b) // main.userInfo{Name:"wang", Age:18, Hobby:[]string{"Golang", "TypeScript"}}
时间处理
Go提供了很多常用的时间处理函数，例如Now、解析字符串、转字符串、获取时间戳等。在操作时间相关的方法时，需要导入time包。
// 获取当前时间
now := time.Now()
fmt.Println(now) // 2022-03-27 18:04:59.433297 +0800 CST m=+0.000087933
t := time.Date(2022, 3, 27, 1, 25, 36, 0, time.UTC)
t2 := time.Date(2022, 3, 27, 2, 30, 36, 0, time.UTC)
fmt.Println(t) // 2022-03-27 01:25:36 +0000 UTC
// 获取时间的年月日
fmt.Println(t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute()) // 2022 March 27 1 25
// 时间转字符串
fmt.Println(t.Format("2006-01-02 15:04:05")) // 2022-03-27 01:25:36
// 获取时间差
diff := t2.Sub(t)
fmt.Println(diff) // 1h5m0s
fmt.Println(diff.Minutes(), diff.Seconds()) // 65 3900
// 解析字符串
t3, err := time.Parse("2006-01-02 15:04:05", "2022-03-27 01:25:36")
if err != nil {
panic(err)
}
fmt.Println(t3 == t) // true
// 获取时间戳
fmt.Println(now.Unix()) // 1648738080
