Go语言基础速成篇 | 字节青训营笔记

这是我参与「第五届青训营」笔记创作活动的第1天。笔记旨在记录自己的学习过程以及跟更多人分享交流，重点讲干货，不扣细节，从整体认知。废话不多说，上内容！！！

本堂课重点内容

1. Go 语言简介
2. Go 语言开发入门，包括开发环境配置、基础语法、标准库
3. Go 实战，包括三个实战项目

详细知识点介绍

Go语言简介

1. 高性能、高并发
2. 语法简单、学习曲线平缓
3. 丰富的标准库
4. 完善的工具链
5. 静态链接
6. 快速编译
7. 跨平台
8. 垃圾回收

配置开发环境

1. 安装Golang；访问 链接 ，点击 Download，下载对应平台安装包，安装即可
2. 安装Goland；访问 链接，点击 Download，下载对应平台安装包，安装即可

基础语法

Hello World

package main

import (
   "fmt"
)

func main() {
   fmt.Println("hello world")
}

1. package main 代表这个文件属于main包的一部分，main包也就是程序的入口包。
2. import 导入了标准库里面的FMT包。这个包主要是用来往屏幕输入输出字符串、格式化字符串。
3. main 函数的话里面调用了fmt.Println输出helloword

变量

var a = "initial"
var b, c int = 1, 2
var d = true
var e float64

f := float32(e)
g := a + "foo"

fmt.Println(a, b, c, d, e, f) // initial 1 2 true 0 0
fmt.Println(g)                // initialapple

const s string = "constant"
const h = 500000000
const i = 3e20 / h

fmt.Println(s, h, i, math.Sin(h), math.Sin(i))

1. 常见的变量类型包括字符串、整数型、浮点型、布尔型等。
2. go 语言的字符串是内置类型，可以直接通过加号拼接，也能够直接用等于号去比较两个字符串。
3. 在 go 语言里面，大部分运算符的使用和优先级都和C或者C++类似，这里就不再概述。
4. 在 go 语言里面变量的声明有两种方式，一种是通过 var name String = " " 。声明变量的时侯，一般会自动去推导变量的类型。如果有需要，你也可以显示写出变量类型。另一种声明变量的方式是:使用变量冒号 := 等于值。
5. 常量的话就是把 var 改成 const，值在一提的是 go 语言里面的常量，它没有确定的类型，会根据使用的上下文来自动确定类型。

if else

if 7%2 == 0 {
   fmt.Println("7 is even")
} else {
   fmt.Println("7 is odd")
}

if 8%4 == 0 {
   fmt.Println("8 is divisible by 4")
}

if num := 9; num < 0 {
   fmt.Println(num, "is negative")
} else if num < 10 {
   fmt.Println(num, "has 1 digit")
} else {
   fmt.Println(num, "has multiple digits")
}

1. go 语言里面的 if else 写法和 C 或者 C++ 类似。不同点是 if 后面没有括号。
2. 第二个不同点是 Golang 里面的 if，它必须后面接大括号。

循环

i := 1
for {
   fmt.Println("loop")
   break
}

for j := 7; j < 9; j++ {
   fmt.Println(j)
}

for n := 0; n < 5; n++ {
   if n%2 == 0 {
      continue
   }
   fmt.Println(n)
}

for i <= 3 {
   fmt.Println(i)
   i = i + 1
}

1. 在 go 里面没有 while 循环、do while 循环，只有 for 循环。
2. 在循环里面，你可以用 break 或者 continue 来跳出或者继续循环。

switch

a := 2
switch a {
case 1:
   fmt.Println("one")
case 2:
   fmt.Println("two")
case 3:
   fmt.Println("three")
case 4, 5:
   fmt.Println("four or five")
default:
   fmt.Println("other")
}

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

1. go 语言里面的 switch 分支结构。看起来也 C 或者 C++ 比较类似。同样的在 switch 后面的那个变量名，并不是要括号。
2. 这里有个很大的一点不同的是，在 C++ 里面，switch case 如果不显示加 break 的话会继续往下跑完所有的 case，在 go 语言里面的话是不需要加 break 的。
3. 相比 C 或者 C++，go 语言里面的 switch 功能更强大。可以使用任意的变星类型。
4. 甚至可以用来取代任意的 if else 语句。你可以在 switch 后面不加任何变量，然后在 case 里面写条件分支，这样代码逻辑更清晰。

数组

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)

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)

1. 数组就是一个具有编号且长度固定的元素序列。比如这里的话是一个可以存放 5 个 int 元素的数组 A。
2. 对于一个数组，可以很方便地取特定索引的值或者往特定索引取存储值，然后也能够直接去打印一个数组。不过，在真实业务代码里面，我们很少直接使用数组，因为它长度是固定的，我们用的要多的是切片。

slice

s := make([]string, 3)
s[0] = "a"
s[1] = "b"
s[2] = "c"
fmt.Println("get:", s[2])   // c
fmt.Println("len:", len(s)) // 3

s = append(s, "d")
s = append(s, "e", "f")
fmt.Println(s) // [a b c d e f]

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

fmt.Println(s[2:5]) // [c d e]
fmt.Println(s[:5])  // [a b c d e]
fmt.Println(s[2:])  // [c d e f]

good := []string{"g", "o", "o", "d"}
fmt.Println(good) // [g o o d]

1. 切片不同于数组可以任意更改长度，然后也有更多丰富的操作。比如说我们可以用 make 来创建一个切片，可以像数组一样去取值，使用 append 来追加元素。注意 append 的用法的话，你必须把 append 的结果赋值为原数组。
2. 因为切片的原理实际上是它存储了一个长度和一个容量，加一个指向一个数组的指针，在你执行 append 操作的时候，如果容量不够的话，会扩容并且返回新的切片,切片初始化的时候也可以指定长度。
3. 拥有像 python 一样的切片操作，比如这个代表取出第二个到第五个位置的元素，不包括第五个元素。不过不同于 python，这里不支持负数索引。

map

m := make(map[string]int)
m["one"] = 1
m["two"] = 2
fmt.Println(m)           // map[one:1 two:2]
fmt.Println(len(m))      // 2
fmt.Println(m["one"])    // 1
fmt.Println(m["unknow"]) // 0

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

delete(m, "one")

m2 := map[string]int{"one": 1, "two": 2}
var m3 = map[string]int{"one": 1, "two": 2}
fmt.Println(m2, m3)

1. map 在其他编程语言里面，它可能可以叫做哈希或者字典。map 是实际使用过程中最频繁用到的数据结构。
2. 用 map 来创建一个空 map，这里会需要两个类型，第一个是 key 的类型，这里是 sting，另一个是 value 的类里，这里是 int。我们可以从里面去存储或者取出键值对。可以用 delete 从里面删除键值对。
3. golang 的 map 是完全无序的，遍历的时候不会按照字母顺序，也不会按照插入顺序输出，而是随机顺序。

range

nums := []int{2, 3, 4}
sum := 0
for i, num := range nums {
   sum += num
   if num == 2 {
      fmt.Println("index:", i, "num:", num) // index: 0 num: 2
   }
}
fmt.Println(sum) // 9

m := map[string]string{"a": "A", "b": "B"}
for k, v := range m {
   fmt.Println(k, v) // b 8; a A
}
for k := range m {
   fmt.Println("key", k) // key a; key b
}

对于一个 slice 或者一个 map 的话，我们可以用 range来快速遍历，这样代码能够更加简洁。range 遍历的时候，对于数组会返回两个值，第一个是索引，第二个是对应位置的值。如果我们不需要索引的话，我们可以用下划线来忽略。

函数

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

func add2(a, b int) int {
   return a + b
}

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

func main() {
   res := add(1, 2)
   fmt.Println(res) // 3

   v, ok := exists(map[string]string{"a": "A"}, "a")
   fmt.Println(v, ok) // A True
}

1. 这个是 Golang 里面一个简单的实现两个变量相加的函数。Golang 和其他很多语言不一样的是，变量类型是后置的。
2. Golang 里面的函数原生支持返回多个值。在实际的业务逻辑代码里面几乎所有的函数都返回两个值，第一个是真正的返回结果，第二个值是一个错误信息。

指针

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
}

1. go 里面也支持指针。当然，相比 C 和 C++ 里面的指针，支持的操作很有限。指针的一个主要用途就是对于传入参数进行修改。
2. 看这个函数。这个函数试图把一个变量 +2。但是单纯像上面这种写法其实是无效的。因为传入函数的参数实际上是一个拷贝，那也说这个 +2，是对那个拷贝进行了 +2，并不起作用。如果我们需要起作用的话，那么我们需要把那个类型写成指针类型，那么为了类型匹配，调用的时候会加一个 & 符号。

结构体

type user struct {
   name     string
   password string
}

func main() {
   a := user{name: "wang", password: "1024"}
   b := user{"wang", "1024"}
   c := user{name: "wang"}
   c.password = "1024"
   var d user
   d.name = "wang"
   d.password = "1024"

   fmt.Println(a, b, c, d)                 // {wang 1024} {wang 1024} {wang 1024} {wang 1024}
   fmt.Println(checkPassword(a, "haha"))   // false
   fmt.Println(checkPassword2(&a, "haha")) // false
}

func checkPassword(u user, password string) bool {
   return u.password == password
}

func checkPassword2(u *user, password string) bool {
   return u.password == password
}

1. 结构体的话是带类型的字段的集合。
2. 比如这里 user 结构包含了两个字段，name 和password。我们可以用结构体的名称去初始化一个结构体变量，构造的时候需要传入每个字段的初始值。也可以用这种键值对的方式去指定初始值，这样可以只对一部分字段进行初始化。
3. 同样的，结构体我们也能支持指针，这样能够实现对于结构体的修改，也可以在某些情况下避免一些大结构体的拷贝开销。

结构体方法

type user struct {
   name     string
   password string
}

func (u user) checkPassword(password string) bool {
   return u.password == password
}

func (u *user) resetPassword(password string) {
   u.password = password
}

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

1. 在 Golang 里面可以为结构体去定义一些方法。会有一点类似其他语言里面的类成员函数。比如这里，我们把上面一个例子的 checkPassword 的实现，从一个普通函数，改成了结构体方法。这样用户可以像 a.checkPassword(“xx”) 这样去调用。具体的代码修改，就是把第一个参数，加上括号，写到函数名称前面。

2. 在实现结构体的方法的时候也有两种写法，一种是带指针，一种是不带指针。这个它们的区别的话是说如果你带指针的话,那么你就可以对这个结构体去做修改。如果你不带指针的话，那你实际上操作的是一个拷贝，你就无法对结构体进行修改。

错误处理

type user struct {
   name     string
   password string
}

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")
}

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

   if u, err := findUser([]user{{"wang", "1024"}}, "li"); err != nil {
      fmt.Println(err) // not found
      return
   } else {
      fmt.Println(u.name)
   }
}

1. 错误处理在 go 语言里面符合语言习惯的做法就是使用一个单独的返回值来传递错误信息。
2. 不同于Java自家家使用的异常。go语言的处理方式，能够很清晰地知道哪个函数返回了错误，并且能用简单的 if else 来处理错误。
3. 在函数里面，我们可以在那个函数的返回值类型里面，后面加一个error，就代表这个函数可能会返回错误。
4. 那么在函数实现的时候，return 需要同时 return 两个值，要么就是如果出现错误的话，那么可以 returm nil 和一个 error。如果没有的话，那么返回原本的结果和 nil。

字符串操作

func main() {
   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
   b := "你好"
   fmt.Println(len(b)) // 6
}

在标准库 strings 包里面有很多常用的字符串工具函数,比如 contains 判断一个字符串里面是否有包含另一个字符串，count 字符串计数, index 查找某个字符串的位置。join连接多个字符串，repeat 重复多个字符串， replace替换字符串。

字符串格式化

type point struct {
   x, y int
}

func main() {
   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
}

字符串格式化。在标准库的 FMT 包里面有很多的字符串格式相关的方法，比如 printf 这个类似于 C 语言里面的printf 函数。不同的是，在 go 语言里面的话，你可以很轻松地用 %v 来打印任意类型的变量，而不需要区分数字字符串。你也可以用%+v打印详细结果，%#v则更详细。

JSON处理

type userInfo struct {
   Name  string
   Age   int `json:"age"`
   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"}}
}

1. go 语言里面的 JSON 操作非常简单，对于 一 个已有的结构体,我们可以什么都不做，只要保证每个字段的第一个字母是大写，也就是是公开字段。那么这个结构体就能用 JSON.marshaler 去序列化，变成一个JSON的字符串。
2. 序列化之后的字符串也能够用 JSON.unmarshaler 去反序列化到一个空的变量里面。
3. 这样默认序列化出来的字符串的话，它的风格是大写字母开头，而不是下划线。我们可以在后面用 json tag 等语法来去修改输出 JSON 结果里面的字段名。

时间处理

func main() {
   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
}

1. 在 go 语言里面最常用的就是 time.now() 来获取当前时间，然后你也可以用 time.date 去构造一个带时区的时间。上面有很多方法来获取这个时间点的年月日小时分钟秒，然后也能用点 sub 去对两个时间进行减法，得到一个时间段。时间段又可以去得到它有多少小时，多少分钟、多少秒。
2. 在和某些系统交互的时候，我们经常会用到时间戳。那您可以用 .UNIX 来获取时间戳。

数字解析

f, _ := strconv.ParseFloat("1.234", 64)
fmt.Println(f) // 1.234

n, _ := strconv.ParseInt("111", 10, 64)
fmt.Println(n) // 111

n, _ = strconv.ParseInt("0x1000", 0, 64)
fmt.Println(n) // 4096

n2, _ := strconv.Atoi("123")
fmt.Println(n2) // 123

n2, err := strconv.Atoi("AAA")
fmt.Println(n2, err) // 0 strconv.Atoi: parsing "AAA": invalid syntax

1. 在go语言当中，关于字符串和数字类型之间的转换都在 STR conv 这个包下，这个包是 string convert 这两个单词的缩写。
2. 我们可以用 parseInt 或者 parseFloat 来解析一个字符串。
3. 我们可以用 Atoi 把一个十进制字符串转成数字。可以用 itoA 把数字转成字符串。
4. 如果输入不合法，那么这些函数都会返回 error。

进程信息

// go run example/20-env/main.go a b c d
fmt.Println(os.Args)           // [/var/folders/8p/n34xxfnx38dg8bv_x8l62t_m0000gn/T/go-build3406981276/b001/exe/main a b c d]
fmt.Println(os.Getenv("PATH")) // /usr/local/go/bin...
fmt.Println(os.Setenv("AA", "BB"))

buf, err := exec.Command("grep", "127.0.0.1", "/etc/hosts").CombinedOutput()
if err != nil {
   panic(err)
}
fmt.Println(string(buf)) // 127.0.0.1       localhost

1. 在go里面，我们能够用 os.argv 来得到程序执行的时候的指定的命令行参数。
2. 比如我们编译的一个二进制文件，command。后面接 abcd 来启动，输出就是 os.argv 会是一个长度为 5 的 slice ,第一个成员代表二进制自身的名字。
3. 我们可以用 so.getenv 来读取环境变量。

实践练习例子

猜谜游戏

1. 生成随机数
2. 生成随机数 V2
3. 读取用户输入
4. 实现判断逻辑
5. 实现游戏循环

在线词典

1. 抓包
2. 代码生成
3. 生成 request body
4. 解析 request body
5. 打印结果
6. 完善代码

SOCKS5代理

1. 原理
2. TCP echo server
3. auth
4. 请求阶段
5. relay 阶段

课后个人总结

1. 大体了解 Go 语言基础语法,感觉风格跟 Scala 语言有相似的地方,都在很多基础的设计上都作了进一步的简化,使得代码应用上更加简洁高效。（Go 语言是类 C 语言，Scala 语言是从 Java 语言改进设计）比起 C++ 执行速度快但是编译速度并不理想,或 Java 编译速度较快但执行效率不佳, Go 做到了最佳的平衡：快速编译，高效执行，易于开发;
2. 对于实战,在语法和相关库还不太清晰的情况下,大致读懂每行代码的作用,然后再慢慢化为己用;

关于文中代码项目下载

1. 安装 Git,参考 链接
2. 登录 Github 链接 clone
3. 从 Github 上克隆项目,参考 链接

引用参考

1. 稀土掘金字节内部课
2. Go语言上手基础语法
3. C语言中文网的Go语言