边看春晚边学Go| 青训营笔记

语言: CN / TW / HK

theme: cyanosis highlight: github


这是我参与「第五届青训营 」伴学笔记创作活动的第 1 天

Go语言简介

Go语言是Google主导开发的通用性计算机编程语言,Go是具有高性能、高并发特性的编程语言,具有和C++Java可以媲美的性能并且天然支持高并发。

Go的语法相对简单,学习起来比较容易。另外Go还具有丰富的标准库、完善的工具链(编译、代码格式化、错误检查、包管理、代码提示、代码测试等),支持快速编译、跨平台、自动垃圾回收等特性。

开发环境

安装Go的开发环境,可以直接参考Go官网进行下载安装,过程比较简单。

使用Go模块代理可以加速Go的依赖下载速度。

Go开发编辑器主要有VSCodeGoLand,这两款编辑器都支持跨平台。GoLand相对于初学者来说比较友好,由于我的电脑已经安装VSCode了,所以就没再安装GoLand(收费的而且电脑扛不住😭)。

基础语法

快速入门

学习一门语言,当时是先“Hello World”一下啦。

```go package main

import "fmt"

func main() { fmt.Println("Hello World") } ```

package定义一个包,只有main这个包才能使用go rungo build直接运行。

import是导入本文件中所需要的包。

main是入口函数,main函数是每一个可执行程序所必须包含的,一般是在启动后第一个执行的函数(如果有init函数,先执行init)。

go运行代码的方式有两种,一种是直接运行,另一种是编译生成可执行文件再运行。

直接运行:go run main.go

编译运行:go build main.go

编译后会生成一个main文件,window上是main.exe,然后直接运行该文件即可。

变量

Go语言变量名由字母、数字、下划线组成,其中首个字符不能为数字。

变量类型包含:字符串、整形、浮点型、布尔型、其他类型(指针、结构体、channel、函数、切片、接口、Map等)。

变量声明

变量在使用前必须要提前声明,可以使用类型推断或者显示声明类型,声明变量的一般形式是使用 var 关键字。

使用类型推断时,需要为变量指定值,go会根据值来推断该变量是什么具体类型。

go var str = "我是字符串。" var num = 1 var 关键字其实也是可以省略的,不过要把=换成:=go str := "我是字符串。" num := 1

使用显示声明变量时,需要在变量后面执行该变量的具体类型,如果声明时不指定具体的值,则会被赋值为默认值。

go var str string // str的值为""(空字符串) var num int // num的值为0 可以在声明变量的同时给变量进行赋值。 go var str string = "我是字符串" var num int = 1

多个变量在同一行同时声明。 go var str1, str2 string = "字符串1", "字符串2" var num1, num2 int = 1, 2 a, b := 1, 2

常量声明

Go在声明常量时,使用const关键字。常量必须显示指定类型,并且值不可更改。

```go const str string = "我是字符串" const num int = 1

num = 2 // 若更改会报错 ```

流程控制

if语句

Goif语句和C、C++类似,只不过if后面没有括号,但是加上括号也能正确运行,在IDE中如果在if后面加上括号保存时可能会被直接去掉,另外if后面的开始大括号必须跟if在同一行,不能换行(会报错)。

```go num1 := 1 num2 := 2

if num1 < num2 { fmt.Println("num1 < num2") } else { fmt.Println("num1 >= num2") } ```

if语句后面也可以定义变量,但只能用一个分号。也支持if-else-if语句。

go 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里没有whiledo-while循环,只有for循环。Gofor循环包含了forwhile的功能。

for定义死循环,相当于while(true)

go for { fmt.Println("loop") } for true { fmt.Println("loop") }

for定义普通的循环,三段式,任何一段都可以省略,在for循环里也可以使用continuebreak来跳出循环。

go // 普通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的功能。

go num := 1 for num < 5 { fmt.Println(num) num++ }

switch

switch语句也和C、C++switch语句类似,只不过switch后面不需要加括号,case里也不需要加breakGoswitch默认情况下 case 最后自带 break 语句,匹配成功后就不会执行其他 case,如果我们需要执行后面的 case,可以使用 fallthrough

go num := 2 switch num { case 1: fmt.Println("one") case 2, 3: fmt.Println("two or three") default: fmt.Println("other") }

Goswitch可以匹配任意类型,也可以实现if-else的功能,在switch后面不加匹配条件,可以在case里进行匹配。

go t := time.Now() switch { case t.Hour() < 12: fmt.Println("It's before noon") default: fmt.Println("It's after noon") }

数组Array

数组(array)是具有相同唯一类型的一组已编号且长度固定的数据项序列,这种类型可以是任意的原始类型例如整型、字符串或者自定义类型。

一维数组

数组声明以及访问如下:

go // 声明一个长度为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

也可以通过:=声明并初始化一个数组。

多维数组

多维数组的声明方式和一维数组类似,几维数组就加几个中括号,例如二维数据的声明以及赋值代码如下:

go 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) 对切片元素的操作,可以像数组一样操作:

go s := make([]string, 3) s[0] = "a" s[1] = "b" s[2] = "c"

可以通过append方法向切片中添加元素,因为切片会涉及到扩容,所以需要一个变量来接收返回值。

go s = append(s, "d") s = append(s, "e", "f")

可以通过copy方法对切片进行复制,复制后是两个独立的切片,更改元素值相互不影响。

go c := make([]string, len(s)) copy(c, s) fmt.Println(c) // [a b c d e f]

既然是切片,很容易联想到python的切片操作,下面来看下Go的切片功能,与python的切片相比,Go的切片不支持-1下标。

go // 返回下标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的声明如下:

go m := make(map[string]int) 这行代码是声明了一个键为string类型,值为int类型的空Map

也可以在声明的同时对其进行初始化操作:

go m2 := map[string]int{"one": 1, "two": 2}

Map的赋值和数组类似通过”下标“进行操作,只不过这个”下标“对应的是key

go m["one"] = 1 m["two"] = 2

Map元素的访问,也是通过”下标“来访问的,如果访问的key不存在的话会返回0

go fmt.Println(m["one"]) // 1 fmt.Println(m["unknow"]) // 0

对于不存在的key返回0,如果一个key的值也为0,就很容易产生不必要的误会,Go在查询key时返回了两个值,一个是结果,另一个是bool类型的值代表是否存在。

go r, ok := m["unknow"] fmt.Println(r, ok) // 0 false

可以使用delete函数来删除Map中的键值对。 go delete(m, "one")

range遍历

数组、切片、Map都可以使用range来遍历,通过range可以得到索引和对应的值。

go 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 }

函数

函数定义格式如下:

go func function_name( [parameter list] ) [return_types] { 函数体 } 例如,定义一个两个数相加的函数:

go func add(a int, b int) int { return a + b }

Go函数可以返回多个值,一般来说,第一个是函数的返回值,第二个是错误信息。

go func exists(m map[string]string, k string) (v string, ok bool) { v, ok = m[k] return v, ok }

指针

Go支持指针,相对于C语言Go的指针功能十分简单,当然功能也很有限,主要用途就是对函数传入的参数进行修改。

默认情况下,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 语句。

go type struct_variable_type struct { member definition ... member definition } 例如,定义一个包含namepassworduser结构体:

go type user struct { name string password string } 结构体的初始化,可以指定字段初始化,也可以全部初始化。

go a := user{name: "wang", password: "1024"} b := user{"wang", "1024"} c := user{name: "wang"}

对于结构体内部成员的访问可以通过.操作符来进行访问或赋值。

go var d user d.name = "wang" d.password = "1024" fmt.Println(d.password)

结构体方法

结构体方法可以理解为其他语言类的成员函数。

把一个普通方法的func关键字后面加上结构体信息,就代表这个方法是属于结构体的。

user结构体添加一个检查密码的函数: go func (u user) checkPassword(password string) bool { return u.password == password }

user结构体添加一个重置密码的函数,因为要修改结构体内部的值,所以要使用指针类型: go func (u *user) resetPassword(password string) { u.password = password }

结构体方法的调用:

go a := user{name: "wang", password: "1024"} a.resetPassword("2048") fmt.Println(a.checkPassword("2048")) // true

错误处理

Go内置的错误接口提供了非常简单的错误处理机制,error类型是一个接口类型,其定义如下:

go type error interface { Error() string }

Go函数可以返回多个值,通常函数的最后一个值用来代表错误信息,在函数内部可以使用errors.New可返回一个错误信息:

go 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

在调用函数的时候,需要用多个变量来接收函数的返回值,我们可以通过函数的返回值来判断是否发生了异常。

go u, err := findUser([]user{{"wang", "1024"}}, "wang") if err != nil { fmt.Println(err) return }

标准库

Go内置了非常丰富的标准库工具,包括字符串操作、字符串格式化、json处理、时间处理等。

字符串操作

go 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可以打印出整个结构体的构造以及详细信息。

```go 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中一些特殊的类型,比如Channelcomplexfunction是不能被解析成JSON的。

GoJSON对象只支持string作为key,对于map,那么必须是map[string]T这种类型,T可以是Go语言中任意的类型。

Gojson处理是通过MarshalUnmarshal方法来进行处理的。

Marshal 用于自定义编码json的方法,也就是将变量、对象转成json,转换之后需要用string方法强转一下,否则会打印出的是16进制字符串。

Unmarshal用于自定义解码json方法,也就是将json转为对象。

``go type userInfo struct { Name string Age intjson:"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包。

go // 获取当前时间 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

引用

字节内部课——Go 语言原理与实践

菜鸟教程——Go语言教程