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

阿里云国内75折回扣微信号：monov8

阿里云国际，腾讯云国际，低至75折。AWS 93折免费开户实名账号代冲值优惠多多微信号：monov8 飞机：@monov6

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

本堂课重点内容

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

详细知识点介绍

Go语言简介

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

配置开发环境

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

基础语法

Hello World

package main

import (
   "fmt"
)

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

package main 代表这个文件属于main包的一部分main包也就是程序的入口包。
import 导入了标准库里面的FMT包。这个包主要是用来往屏幕输入输出字符串、格式化字符串。
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))

常见的变量类型包括字符串、整数型、浮点型、布尔型等。
go 语言的字符串是内置类型可以直接通过加号拼接也能够直接用等于号去比较两个字符串。
在 go 语言里面大部分运算符的使用和优先级都和C或者C++类似这里就不再概述。
在 go 语言里面变量的声明有两种方式一种是通过 var name String = " " 。声明变量的时侯一般会自动去推导变量的类型。如果有需要你也可以显示写出变量类型。另一种声明变量的方式是:使用变量冒号 := 等于值。
常量的话就是把 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")
}

go 语言里面的 if else 写法和 C 或者 C++ 类似。不同点是 if 后面没有括号。
第二个不同点是 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
}

在 go 里面没有 while 循环、do while 循环只有 for 循环。
在循环里面你可以用 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")
}

go 语言里面的 switch 分支结构。看起来也 C 或者 C++ 比较类似。同样的在 switch 后面的那个变量名并不是要括号。
这里有个很大的一点不同的是在 C++ 里面switch case 如果不显示加 break 的话会继续往下跑完所有的 case在 go 语言里面的话是不需要加 break 的。
相比 C 或者 C++go 语言里面的 switch 功能更强大。可以使用任意的变星类型。
甚至可以用来取代任意的 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)

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

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]

切片不同于数组可以任意更改长度然后也有更多丰富的操作。比如说我们可以用 make 来创建一个切片可以像数组一样去取值使用 append 来追加元素。注意 append 的用法的话你必须把 append 的结果赋值为原数组。
因为切片的原理实际上是它存储了一个长度和一个容量加一个指向一个数组的指针在你执行 append 操作的时候如果容量不够的话会扩容并且返回新的切片,切片初始化的时候也可以指定长度。
拥有像 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)

map 在其他编程语言里面它可能可以叫做哈希或者字典。map 是实际使用过程中最频繁用到的数据结构。
用 map 来创建一个空 map这里会需要两个类型第一个是 key 的类型这里是 sting另一个是 value 的类里这里是 int。我们可以从里面去存储或者取出键值对。可以用 delete 从里面删除键值对。
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
}

这个是 Golang 里面一个简单的实现两个变量相加的函数。Golang 和其他很多语言不一样的是变量类型是后置的。
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
}

go 里面也支持指针。当然相比 C 和 C++ 里面的指针支持的操作很有限。指针的一个主要用途就是对于传入参数进行修改。
看这个函数。这个函数试图把一个变量 +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
}

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

结构体方法

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
}

在 Golang 里面可以为结构体去定义一些方法。会有一点类似其他语言里面的类成员函数。比如这里我们把上面一个例子的 checkPassword 的实现从一个普通函数改成了结构体方法。这样用户可以像 a.checkPassword(“xx”) 这样去调用。具体的代码修改就是把第一个参数加上括号写到函数名称前面。
在实现结构体的方法的时候也有两种写法一种是带指针一种是不带指针。这个它们的区别的话是说如果你带指针的话,那么你就可以对这个结构体去做修改。如果你不带指针的话那你实际上操作的是一个拷贝你就无法对结构体进行修改。

错误处理

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

错误处理在 go 语言里面符合语言习惯的做法就是使用一个单独的返回值来传递错误信息。
不同于Java自家家使用的异常。go语言的处理方式能够很清晰地知道哪个函数返回了错误并且能用简单的 if else 来处理错误。
在函数里面我们可以在那个函数的返回值类型里面后面加一个error就代表这个函数可能会返回错误。
那么在函数实现的时候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"}}
}

go 语言里面的 JSON 操作非常简单对于一个已有的结构体,我们可以什么都不做只要保证每个字段的第一个字母是大写也就是是公开字段。那么这个结构体就能用 JSON.marshaler 去序列化变成一个JSON的字符串。
序列化之后的字符串也能够用 JSON.unmarshaler 去反序列化到一个空的变量里面。
这样默认序列化出来的字符串的话它的风格是大写字母开头而不是下划线。我们可以在后面用 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
}

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

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

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

实践练习例子

猜谜游戏

生成随机数
生成随机数 V2
读取用户输入
实现判断逻辑
实现游戏循环

在线词典

抓包
代码生成
生成 request body
解析 request body
打印结果
完善代码

SOCKS5代理

原理
TCP echo server
auth
请求阶段
relay 阶段

课后个人总结

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