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

这是我参加「第五届青训营 」伴学笔记创作活动的第 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

引用

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

菜鸟教程——Go言语教程