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

🎈1. 简介

☃️ 1.1 什么是Go语言

高性能、高并发

语法简单、学习曲线平缓

丰富的标准库

完善的工具链

静态链接

快速编译

跨平台

垃圾回收

💻 1.2 有哪些公司在使用Go

🎠1.3 环境配置

官网：golang.google.cn/

从golang.org/dl/下载`MSI`安…

msi安装文件，Go语言的环境变量会自动设置好。我的电脑——右键“属性”——“高级系统设置”——“环境变量” —— “系统变量”

查看是否安装配置成功

使用快捷键win+R键，输入cmd，打开命令行提示符，在命令行中输入

go env  # 查看得到go的配置信息
go version  # 查看go的版本号

编辑器我这里使用的是GoLand by JetBrains: More than just a Go IDE

🏠2. 入门

🎄2.1 基础语法-Hello Word

在HOME/go的目录下，(就是GOPATH目录里)，创建一个目录叫src，然后再该目录下创建一个文件夹叫hello，在该目录下创建一个文件叫helloworld.go，并双击打开，输入以下内容：

package main

import "fmt"

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

执行go程序

🎍2.2 基于语法-变量

var名称类型是声明单个变量的语法。

以字母或下划线开头，由一个或多个字母、数字、下划线组成

👢声明一个变量

第一种，指定变量类型，声明后若不赋值，使用默认值

var name type
name = value

第二种，根据值自行判定变量类型(类型推断Type inference)

如果一个变量有一个初始值，Go将自动能够使用初始值来推断该变量的类型。因此，如果变量具有初始值，则可以省略变量声明中的类型。

var name = value

第三种，省略var, 注意 :=左侧的变量不应该是已经声明过的(多个变量同时声明时，至少保证一个是新变量)，否则会导致编译错误(简短声明)

name := value

// 例如
var a int = 10
var b = 10
c : = 10

这种方式它只能被用在函数体内，而不可以用于全局变量的声明与赋值

示例代码：

package main
var a = "Hello"
var b string = "World"
var c bool

func main(){
    println(a, b, c)
}

运行结果：

Hello World false

🩰多变量声明

第一种，以逗号分隔，声明与赋值分开，若不赋值，存在默认值

var name1, name2, name3 type
name1, name2, name3 = v1, v2, v3

第二种，直接赋值，下面的变量类型可以是不同的类型

var name1, name2, name3 = v1, v2, v3

第三种，集合类型

var (
    name1 type1
    name2 type2
)

🍭2.3 基础语法-if else

go语言里面的 if else 写法和 C 或者 C++ 类似。不同点1是 if 后面没有括号。如果你写括号的话，那么在保存的时候你的编辑器会自动把你去掉。第二个不同点是 Golang 里面的if ，它必须后面接大括号，就是你不能像 C 或者 C++ 一样，直接把 if 里面的语句同一行。

🥏语法格式：

if 布尔表达式 {
   /* 在布尔表达式为 true 时执行 */
}

if 布尔表达式 {
   /* 在布尔表达式为 true 时执行 */
} else {
  /* 在布尔表达式为 false 时执行 */
}

if 布尔表达式1 {
   /* 在布尔表达式1为 true 时执行 */
} else if 布尔表达式2{
   /* 在布尔表达式1为 false ,布尔表达式2为true时执行 */
} else{
   /* 在上面两个布尔表达式都为false时，执行*/
}

🚗示例代码

package main

import "fmt"

func main() {

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

🧨2.4 基础语法-for

初始化语句只执行一次。在初始化循环之后，将检查该条件。如果条件计算为true，那么{}中的循环体将被执行，然后是post语句。post语句将在循环的每次成功迭代之后执行。在执行post语句之后，该条件将被重新检查。如果它是正确的，循环将继续执行，否则循环终止。

在for循环中声明的变量仅在循环范围内可用。因此，i不能在外部访问循环。

🥏语法格式：

for init; condition; post { }

所有的三个组成部分，即初始化、条件和post都是可选的。

for 循环的 range 格式可以对 slice、map、数组、字符串等进行迭代循环

for key, value := range oldMap {
    newMap[key] = value
}

✨break语句

跳出循环体。break语句用于在结束其正常执行之前突然终止for循环

🎉continue语句

跳出一次循环。continue语句用于跳过for循环的当前迭代。在continue语句后面的for循环中的所有代码将不会在当前迭代中执行。循环将继续到下一个迭代。

🚗示例代码

package main

import "fmt"

func main() {

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

🎐2.5 基础语法-switch

switch是一个条件语句，它计算表达式并将其与可能匹配的列表进行比较，并根据匹配执行代码块。它可以被认为是一种惯用的方式来写多个if else子句。

switch 语句用于基于不同条件执行不同动作，每一个 case 分支都是唯一的，从上直下逐一测试，直到匹配为止。 switch 语句执行的过程从上至下，直到找到匹配项，匹配项后面也不需要再加break。

而如果switch没有表达式，它会匹配true

Go里面switch默认相当于每个case最后带有break，匹配成功后不会自动向下执行其他case，而是跳出整个switch, 但是可以使用fallthrough强制执行后面的case代码。

变量 var1 可以是任何类型，而 val1 和 val2 则可以是同类型的任意值。类型不被局限于常量或整数，但必须是相同的类型；或者最终结果为相同类型的表达式。

switch var1 {
    case val1:
        ...
    case val2:
        ...
    default:
        ...
}

🚗示例代码

package main

import (
	"fmt"
	"time"
)

func main() {

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

🎑2.6 基础语法-数组

初始化数组中 {} 中的元素个数不能大于 [] 中的数字。如果忽略 [] 中的数字不设置数组大小，Go 语言会根据元素的个数来设置数组的大小：

  var a [4] float32 // 等价于：var arr2 = [4]float32{}
  fmt.Println(a) // [0 0 0 0]

  var b = [5] string{"ruby", "王二狗", "rose"}
  fmt.Println(b) // [ruby 王二狗 rose  ]

  var c = [5] int{'A', 'B', 'C', 'D', 'E'} // byte
  fmt.Println(c) // [65 66 67 68 69]

  d := [...] int{1,2,3,4,5}// 根据元素的个数，设置数组的大小
  fmt.Println(d)//[1 2 3 4 5]

  e := [5] int{4: 100} // [0 0 0 0 100]
  fmt.Println(e)

  f := [...] int{0: 1, 4: 1, 9: 1} // [1 0 0 0 1 0 0 0 0 1]
  fmt.Println(f)

通过将数组作为参数传递给len函数，可以获得数组的长度。

package main

import "fmt"

func main() {  
    a := [...]float64{67.7, 89.8, 21, 78}
    fmt.Println("length of a is",len(a))
}

数组是值类型 Go中的数组是值类型，而不是引用类型。这意味着当它们被分配给一个新变量时，将把原始数组的副本分配给新变量。如果对新变量进行了更改，则不会在原始数组中反映。

🚗示例代码

package main

import "fmt"

func main() {

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

🧧2.6 基础语法-切片

切片不同于数组可以任意更改长度，然后也有更多丰富的操作。

比如说我们可以用 make 来创建一个切片，可以像数组一样去取值，使用 append 来追加元素。注意 append 的用法的话，你必须把 append 的结果赋值为原数组。因为 slice 的原理实际上是它有一个它存储了一个长度和一个容量，加一个指向一个数组的指针，在你执行 append 操作的时候，如果容量不够的话，会扩容并且返回新的 slice。

slice 此初始化的时候也可以指定长度。 slice 拥有像 python 一样的切片操作，比如这个代表取出第二个到第五个位置的元素，不包括第五个元素。不过不同于python，这里不支持负数索引

package main

import "fmt"

func main() {

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

🎀2.7 基础语法-map

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

我们可以通过key获取map中对应的value值。语法为：

map[key]

但是当key如果不存在的时候，我们会得到该value值类型的默认值，比如string类型得到空字符串，int类型得到0。但是程序不会报错。

所以我们可以使用ok-idiom获取值，可知道key/value是否存在

value, ok := map[key]

🚗示例代码

package main

import "fmt"

func main() {

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

🎁2.8 基础语法-range

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

package main

import "fmt"

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

🎟️2.9 基础语法-struct

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

package main

import "fmt"

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
}

🎢2.10 基础语法-错误处理

如果一个函数或方法返回一个错误，那么按照惯例，它必须是函数返回的最后一个值。因此，Open 函数返回的值是最后一个值。

处理错误的惯用方法是将返回的错误与nil进行比较。nil值表示没有发生错误，而非nil值表示出现错误。在我们的例子中，我们检查错误是否为nil。如果它不是nil，我们只需打印错误并从主函数返回。

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

package main

import (
	"errors"
	"fmt"
)

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

🎡2.11 基础语法-字符串操作

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

package main

import (
	"fmt"
	"strings"
)

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
}

🎪2.12 基础语法-字符串格式化

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

package main

import "fmt"

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
}

🦺2.13 基础语法-Json序列化

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

package main

import (
	"encoding/json"
	"fmt"
)

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

🖼️2.14 基础语法-时间

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

package main

import (
	"fmt"
	"time"
)

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
}

🎭2.15 基础语法-数字解析

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

package main

import (
	"fmt"
	"strconv"
)

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

🧶3. 小案例实战

🪢3.1 猜数字

🛒3.1.1 随机数

我们先来生成这个随机数。为了生成随机数，我们需要用到 math/rand 包。我们的第一个版本的代码是这样子的，我们先导入 FMT 包和 math/rand 包，定义一个变量， max_num 是100。下面用 rand.Intn 来生成一个随机数，再打印出这个随机数。

package main

import (
	"fmt"
	"math/rand"
)

func main() {
	maxNum := 100
	secretNumber := rand.Intn(maxNum)
	fmt.Println("The secret number is ", secretNumber)
}

多次运行后我们会发现生成的随机数都是一样的。

👓3.1.2 随机数种子

我们可以用时间戳设置随机数种子rand.Seed(time.Now().UnixNano())

package main

import (
	"fmt"
	"math/rand"
	"time"
)

func main() {
	maxNum := 100
	rand.Seed(time.Now().UnixNano())
	secretNumber := rand.Intn(maxNum)
	fmt.Println("The secret number is ", secretNumber)
}

🥽3.1.3 读取用户输入

然后接下来我们需要实现用户输入输出，并理解析成数字。每个程序执行的时候都会打开几个文件，stdin stdout stderr等，stdin 文件可以用 os.Stdin 来得到。然后直接操作这个文件很不方便，我们会用 bufio.NewReader 把一个文件转换成一个 reader 变量。reader 变量上会有很多用来操作一个流的操作，我们可以用它的 ReadString 方法来读取一行。如果失败了的话，我们会打印错误并能退出。ReadString 返回的结果包含结尾的换行符，我们把它去掉，再转换成数字。如果转换失败，我们同样打印错误，退出。

package main

import (
	"bufio"
	"fmt"
	"math/rand"
	"os"
	"strconv"
	"strings"
	"time"
)

func main() {
	maxNum := 100
	rand.Seed(time.Now().UnixNano())
	secretNumber := rand.Intn(maxNum)
	fmt.Println("The secret number is ", secretNumber)

	fmt.Println("Please input your guess")
	reader := bufio.NewReader(os.Stdin)
	input, err := reader.ReadString('\n')
	if err != nil {
		fmt.Println("An error occured while reading input. Please try again", err)
		return
	}
	input = strings.Trim(input, "\r\n")

	guess, err := strconv.Atoi(input)
	if err != nil {
		fmt.Println("Invalid input. Please enter an integer value")
		return
	}
	fmt.Println("You guess is", guess)
}

🥼3.1.4 实现判断逻辑

现在我们有了一个秘密的值，然后也从用户的输入里面读到了一个值，我们来比较这两个值的大小。如果是用户输入的值比那个秘密的值要大的话，就告诉用户你猜的值太大了，请再试一次。如果是小了也同理，如果是相等的话，那么我们就告诉用户赢了。

package main

import (
	"bufio"
	"fmt"
	"math/rand"
	"os"
	"strconv"
	"strings"
	"time"
)

func main() {
	maxNum := 100
	rand.Seed(time.Now().UnixNano())
	secretNumber := rand.Intn(maxNum)
	fmt.Println("The secret number is ", secretNumber)

	fmt.Println("Please input your guess")
	reader := bufio.NewReader(os.Stdin)
	input, err := reader.ReadString('\n')
	if err != nil {
		fmt.Println("An error occured while reading input. Please try again", err)
		return
	}
	input = strings.Trim(input, "\r\n")

	guess, err := strconv.Atoi(input)
	if err != nil {
		fmt.Println("Invalid input. Please enter an integer value")
		return
	}
	fmt.Println("You guess is", guess)
	if guess > secretNumber {
		fmt.Println("Your guess is bigger than the secret number. Please try again")
	} else if guess < secretNumber {
		fmt.Println("Your guess is smaller than the secret number. Please try again")
	} else {
		fmt.Println("Correct, you Legend!")
	}
}

现在这个只能猜一次，那么接下来应该完成的功能是，让用户一直猜，直到猜对。

🧥3.1.5 一直猜

此时我们的程序大致可以正常工作了，但是玩家只能输入一次猜测，无论猜测是否正确，程序都会突退出。为了改变这种行为，让游戏可以正常玩下去，我们需要加一个循环。我们把刚刚的代码挪到一个 for 循环里面，再把 return 改成 continue 以便于在出错的时候能够继续循环。在用户输入正确的时候 break ，这样才能够在用户胜利的时候退出游戏。讲一下17行

package main

import (
	"bufio"
	"fmt"
	"math/rand"
	"os"
	"strconv"
	"strings"
	"time"
)

func main() {
	maxNum := 100
	rand.Seed(time.Now().UnixNano())
	secretNumber := rand.Intn(maxNum)
	// fmt.Println("The secret number is ", secretNumber)

	fmt.Println("Please input your guess")
	reader := bufio.NewReader(os.Stdin)
	for {
		input, err := reader.ReadString('\n')
		if err != nil {
			fmt.Println("An error occured while reading input. Please try again", err)
			continue
		}
		input = strings.Trim(input, "\r\n")

		guess, err := strconv.Atoi(input)
		if err != nil {
			fmt.Println("Invalid input. Please enter an integer value")
			continue
		}
		fmt.Println("You guess is", guess)
		if guess > secretNumber {
			fmt.Println("Your guess is bigger than the secret number. Please try again")
		} else if guess < secretNumber {
			fmt.Println("Your guess is smaller than the secret number. Please try again")
		} else {
			fmt.Println("Correct, you Legend!")
			break
		}
	}
}

🛖3.2 在线词典

用户可以在命令行里面查询一个单词。我们能通过调用第三方的 API 查询到单词的翻译并打印出来。这个例子里面，我们会学习如何用 go 语言来来发送 HTTP 请求、解析json 过来，还会学习如何使用代码生成来提高开发效率。

🏒3.2.1 抓包

我们先来看一下我们要用到的 API ，以彩云科技提供的在线翻译为例。先请打开彩云翻译的网页，然后右键检查打开浏览器的开发者工具。

此时我们点一下翻译按钮，浏览器会发送一系列请求，我们能很轻松地找到那个用来查询单词的请求。这是一个 HTTP 的 post 的请求，请求的 header 的相当的复杂，有十来个。然后请求头是一个 json 里面有两个字段，一个是代表你要你是从什么语言转化成什么语言， source 就是你要查询的单词。 API 的返回结果里面会有 Wiki 和 dictionary 两个字段。我们需要用的结果主要在dictionary.Explanations 字段里面。其他有些字段里面还包括音标等信息。

🏀3.2.2 发送GO请求

我们需要在 Golang 里面去发送这个请求。因为这个请求比较复杂，用代码构造很麻烦，实际上我们有一种非常简单的方式来生成代码，我们可以右键浏览器里面的 copy as curl。 copy完成之后大家可以在终端粘贴一下 curl 命令，应该可以成功返回一大串 json。

curl 'https://api.interpreter.caiyunai.com/v1/dict' \
  -H 'authority: api.interpreter.caiyunai.com' \
  -H 'accept: application/json, text/plain, */*' \
  -H 'accept-language: zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6' \
  -H 'app-name: xy' \
  -H 'content-type: application/json;charset=UTF-8' \
  -H 'device-id;' \
  -H 'dnt: 1' \
  -H 'origin: https://fanyi.caiyunapp.com' \
  -H 'os-type: web' \
  -H 'os-version;' \
  -H 'referer: https://fanyi.caiyunapp.com/' \
  -H 'sec-ch-ua: "Not_A Brand";v="99", "Microsoft Edge";v="109", "Chromium";v="109"' \
  -H 'sec-ch-ua-mobile: ?0' \
  -H 'sec-ch-ua-platform: "Windows"' \
  -H 'sec-fetch-dest: empty' \
  -H 'sec-fetch-mode: cors' \
  -H 'sec-fetch-site: cross-site' \
  -H 'user-agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36 Edg/109.0.1518.52' \
  -H 'x-authorization: token:qgemv4jr1y38jyq6vhvi' \
  --data-raw '{"trans_type":"en2zh","source":"good"}' \
  --compressed

然后我们就可以利用上边的内容构建go的请求了。但是内容太多，我们可以借助工具Convert curl commands to Go (curlconverter.com)

package main

import (
	"fmt"
	"io/ioutil"
	"log"
	"net/http"
	"strings"
)

func main() {
	client := &http.Client{}
	var data = strings.NewReader(`{"trans_type":"en2zh","source":"good"}`)
	req, err := http.NewRequest("POST", "https://api.interpreter.caiyunai.com/v1/dict", data)
	if err != nil {
		log.Fatal(err)
	}
	req.Header.Set("authority", "api.interpreter.caiyunai.com")
	req.Header.Set("accept", "application/json, text/plain, */*")
	req.Header.Set("accept-language", "zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6")
	req.Header.Set("app-name", "xy")
	req.Header.Set("content-type", "application/json;charset=UTF-8")
	req.Header.Set("device-id", "")
	req.Header.Set("dnt", "1")
	req.Header.Set("origin", "https://fanyi.caiyunapp.com")
	req.Header.Set("os-type", "web")
	req.Header.Set("os-version", "")
	req.Header.Set("referer", "https://fanyi.caiyunapp.com/")
	req.Header.Set("sec-ch-ua", `"Not_A Brand";v="99", "Microsoft Edge";v="109", "Chromium";v="109"`)
	req.Header.Set("sec-ch-ua-mobile", "?0")
	req.Header.Set("sec-ch-ua-platform", `"Windows"`)
	req.Header.Set("sec-fetch-dest", "empty")
	req.Header.Set("sec-fetch-mode", "cors")
	req.Header.Set("sec-fetch-site", "cross-site")
	req.Header.Set("user-agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36 Edg/109.0.1518.52")
	req.Header.Set("x-authorization", "token:qgemv4jr1y38jyq6vhvi")
	resp, err := client.Do(req)
	if err != nil {
		log.Fatal(err)
	}
	defer resp.Body.Close()
	bodyText, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%s\n", bodyText)
}

🪖3.2.3 反序列化

在 Golang 里面。我们需要生成一段 JSON ，常用的方式是我们先构造出来一个结构体，这个结构体和我们需要生成的 JSON 的结构是一一对应的。同样的我们可以利用工具JSON转Golang Struct - 在线工具 - OKTools。把返回结果复制过来即可。

然后，反序列化响应。绑定到go struct上

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"log"
	"net/http"
)

type DictRequest struct {
	TransType string `json:"trans_type"`
	Source    string `json:"source"`
	UserID    string `json:"user_id"`
}

type DictResponse struct {
	Rc   int `json:"rc"`
	Wiki struct {
		KnownInLaguages int `json:"known_in_laguages"`
		Description     struct {
			Source string      `json:"source"`
			Target interface{} `json:"target"`
		} `json:"description"`
		ID   string `json:"id"`
		Item struct {
			Source string `json:"source"`
			Target string `json:"target"`
		} `json:"item"`
		ImageURL  string `json:"image_url"`
		IsSubject string `json:"is_subject"`
		Sitelink  string `json:"sitelink"`
	} `json:"wiki"`
	Dictionary struct {
		Prons struct {
			EnUs string `json:"en-us"`
			En   string `json:"en"`
		} `json:"prons"`
		Explanations []string      `json:"explanations"`
		Synonym      []string      `json:"synonym"`
		Antonym      []string      `json:"antonym"`
		WqxExample   [][]string    `json:"wqx_example"`
		Entry        string        `json:"entry"`
		Type         string        `json:"type"`
		Related      []interface{} `json:"related"`
		Source       string        `json:"source"`
	} `json:"dictionary"`
}

func main() {
	client := &http.Client{}
	request := DictRequest{TransType: "en2zh", Source: "good"}
	buf, err := json.Marshal(request)
	if err != nil {
		log.Fatal(err)
	}
	var data = bytes.NewReader(buf)
	req, err := http.NewRequest("POST", "https://api.interpreter.caiyunai.com/v1/dict", data)
	if err != nil {
		log.Fatal(err)
	}
	req.Header.Set("Connection", "keep-alive")
	req.Header.Set("DNT", "1")
	req.Header.Set("os-version", "")
	req.Header.Set("sec-ch-ua-mobile", "?0")
	req.Header.Set("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.4844.51 Safari/537.36")
	req.Header.Set("app-name", "xy")
	req.Header.Set("Content-Type", "application/json;charset=UTF-8")
	req.Header.Set("Accept", "application/json, text/plain, */*")
	req.Header.Set("device-id", "")
	req.Header.Set("os-type", "web")
	req.Header.Set("X-Authorization", "token:qgemv4jr1y38jyq6vhvi")
	req.Header.Set("Origin", "https://fanyi.caiyunapp.com")
	req.Header.Set("Sec-Fetch-Site", "cross-site")
	req.Header.Set("Sec-Fetch-Mode", "cors")
	req.Header.Set("Sec-Fetch-Dest", "empty")
	req.Header.Set("Referer", "https://fanyi.caiyunapp.com/")
	req.Header.Set("Accept-Language", "zh-CN,zh;q=0.9")
	req.Header.Set("Cookie", "_ym_uid=16456948721020430059; _ym_d=1645694872")
	resp, err := client.Do(req)
	if err != nil {
		log.Fatal(err)
	}
	defer resp.Body.Close()
	bodyText, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		log.Fatal(err)
	}
	// 反序列化响应json
	var dictResponse DictResponse
	err = json.Unmarshal(bodyText, &dictResponse)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%#v\n", dictResponse)
}

🪗3.2.4 动态翻译

现在我们的查询还是写死的，接下来改进一下。

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"log"
	"net/http"
	"os"
)

type DictRequest struct {
	TransType string `json:"trans_type"`
	Source    string `json:"source"`
	UserID    string `json:"user_id"`
}

type DictResponse struct {
	Rc   int `json:"rc"`
	Wiki struct {
		KnownInLaguages int `json:"known_in_laguages"`
		Description     struct {
			Source string      `json:"source"`
			Target interface{} `json:"target"`
		} `json:"description"`
		ID   string `json:"id"`
		Item struct {
			Source string `json:"source"`
			Target string `json:"target"`
		} `json:"item"`
		ImageURL  string `json:"image_url"`
		IsSubject string `json:"is_subject"`
		Sitelink  string `json:"sitelink"`
	} `json:"wiki"`
	Dictionary struct {
		Prons struct {
			EnUs string `json:"en-us"`
			En   string `json:"en"`
		} `json:"prons"`
		Explanations []string      `json:"explanations"`
		Synonym      []string      `json:"synonym"`
		Antonym      []string      `json:"antonym"`
		WqxExample   [][]string    `json:"wqx_example"`
		Entry        string        `json:"entry"`
		Type         string        `json:"type"`
		Related      []interface{} `json:"related"`
		Source       string        `json:"source"`
	} `json:"dictionary"`
}

func query(word string) {
	client := &http.Client{}
	request := DictRequest{TransType: "en2zh", Source: word}
	buf, err := json.Marshal(request)
	if err != nil {
		log.Fatal(err)
	}
	var data = bytes.NewReader(buf)
	req, err := http.NewRequest("POST", "https://api.interpreter.caiyunai.com/v1/dict", data)
	if err != nil {
		log.Fatal(err)
	}
	req.Header.Set("Connection", "keep-alive")
	req.Header.Set("DNT", "1")
	req.Header.Set("os-version", "")
	req.Header.Set("sec-ch-ua-mobile", "?0")
	req.Header.Set("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.4844.51 Safari/537.36")
	req.Header.Set("app-name", "xy")
	req.Header.Set("Content-Type", "application/json;charset=UTF-8")
	req.Header.Set("Accept", "application/json, text/plain, */*")
	req.Header.Set("device-id", "")
	req.Header.Set("os-type", "web")
	req.Header.Set("X-Authorization", "token:qgemv4jr1y38jyq6vhvi")
	req.Header.Set("Origin", "https://fanyi.caiyunapp.com")
	req.Header.Set("Sec-Fetch-Site", "cross-site")
	req.Header.Set("Sec-Fetch-Mode", "cors")
	req.Header.Set("Sec-Fetch-Dest", "empty")
	req.Header.Set("Referer", "https://fanyi.caiyunapp.com/")
	req.Header.Set("Accept-Language", "zh-CN,zh;q=0.9")
	req.Header.Set("Cookie", "_ym_uid=16456948721020430059; _ym_d=1645694872")
	resp, err := client.Do(req)
	if err != nil {
		log.Fatal(err)
	}
	defer resp.Body.Close()
	bodyText, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		log.Fatal(err)
	}
	if resp.StatusCode != 200 {
		log.Fatal("bad StatusCode:", resp.StatusCode, "body", string(bodyText))
	}
	var dictResponse DictResponse
	err = json.Unmarshal(bodyText, &dictResponse)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(word, "UK:", dictResponse.Dictionary.Prons.En, "US:", dictResponse.Dictionary.Prons.EnUs)
	for _, item := range dictResponse.Dictionary.Explanations {
		fmt.Println(item)
	}
}

func main() {
	if len(os.Args) != 2 {
		fmt.Fprintf(os.Stderr, `usage: simpleDict WORD
example: simpleDict hello
		`)
		os.Exit(1)
	}
	word := os.Args[1]
	query(word)
}

🎰 3.3 SOCKS5 代理

我们来写一个 socks5 代理服务器，对于大家来说，一提到代理服务器，第一想到的是翻墙。不过很遗憾的是， socks5 协议它虽然是代理协议，但它并不能用来翻墙，它的协议都是明文传输。这个协议历史比较久远，诞生于互联网早期。它的用途是，比如某些企业的内网为了确保安全性，有很严格的防火墙策略，但是带来的副作用就是访问某些资源会很麻烦。 socks5 相当于在防火墙开了个口子，让授权的用户可以通过单个端口去访问内部的所有资源。实际上很多翻墙软件，最终暴露的也是一个 socks5 协议的端口。如果有同学开发过爬虫的话，就知道，在爬取过程中很容易会遇到IP访问频率超过限制。这个时候很多人就会去网上找一些代理 IP 池，这些代理 IP 池里面的很多代理的协议就是 socks5。

接下来我们来了解一下 socks5 协议的工作原理。正常浏览器访问一个网站，如果不经过代理服务器的话，就是先和对方的网站建立 TCP 连接，然后三次握手，握手完之后发起 HTTP 请求，然后服务返回 HTTP 响应。如果设置代理服务器之后，流程会变得复杂一些。

首先是浏览器和 socks5 代理建立 TCP 连接，代理再和真正的服务器建立 TCP 连接。这里可以分成四个阶段，握手阶段、认证阶段、请求阶段、 relay 阶段。第一个握手阶段，浏览器会向 socks5 代理发送请求，包的内容包括一个协议的版本号，还有支持的认证的种类，socks5 服务器会选中一个认证方式，返回给浏览器。如果返回的是 00 的话就代表不需要认证，返回其他类型的话会开始认证流程，这里我们就不对认证流程进行概述了。第三个阶段是请求阶段，认证通过之后浏览器会 socks5 服务器发起请求。主要信息包括版本号，请求的类型，一般主要是 connection 请求，就代表代理服务器要和某个域名或者某个 IP 地址某个端口建立 TCP 连接。代理服务器收到响应之后，会真正和后端服务器建立连接，然后返回一个响应。第四个阶段是 relay 阶段。此时浏览器会发送正常发送请求，然后代理服务器接收到请求之后，会直接把请求转换到真正的服务器上。然后如果真正的服务器以后返回响应的话，那么也会把请求转发到浏览器这边。然后实际上代理服务器并不关心流量的细节，可以是 HTTP流量，也可以是其它 TCP 流量。这个就是 socks5 协议的工作原理，接下来我们就会试图去简单地实现它。

⛳3.3.1 TCP echo server

第一步，我们先在 go 里面写一个简单的 TCP echo server。为了方便测试， server 的工作逻辑很简单，你给他发送啥，他就回复啥，大概代码会长这样子：首先我们在 main 函数里面先用 net.listen 去监听一个端口，会返回一个 server，然后在一个死循环里面，每次去 accept 一个请求，成功就会返回一个连接。接下来的话我们在一个 process 函数里面去处理这个连接。注意这前面会有个 go 关键字，这个代表启动一个 goroutinue，可以暂时类比为其他语言里面的启动一个子线程。只是这里的 goroutinue 的开销会比子线程要小很多，可以很轻松地处理上万的并发。接下来是这个 process 函数的实现。首先第一步的话会先加一个 defer connection.close()， defer 是 Golang 里面的一个语法，这一行的含义就是代表在这个函数退出的时候要把这个连接关掉，否则会有资源的泄露。接下来的话我们会用 bufio.NewReader 来创建一个带缓冲的只读流，这个在前面的猜谜游戏里面也有用到，带缓冲的流的作用是，可以减少底层系统调用的次数，比如这里为了方便是一个字节一个字节的读取，但是底层可能合并成几次大的读取操作。并且带缓冲的流会有更多的一些工具函数用来读取数据。我们可以简单地调用那个 readbyte 函数来读取单个字节。再把这一个字节写进去连接。

package main

import (
	"bufio"
	"log"
	"net"
)

func main() {
	server, err := net.Listen("tcp", "127.0.0.1:1080")
	if err != nil {
		panic(err)
	}
	for {
		client, err := server.Accept()
		if err != nil {
			log.Printf("Accept failed %v", err)
			continue
		}
		go process(client)
	}
}

func process(conn net.Conn) {
	defer conn.Close()
	reader := bufio.NewReader(conn)
	for {
		b, err := reader.ReadByte()
		if err != nil {
			break
		}
		_, err = conn.Write([]byte{b})
		if err != nil {
			break
		}
	}
}

我们先启动服务端，然后用nc 127.0.0.1 1080进行连接。输入hello, 返回hello

# nc 127.0.0.1 1080
hello
hello

🎳3.3.2 auth

就这样我们就已经完成了一个能够返回你输入信息的一个 TCP server ，接下来我们是要开始实现协议的第一步，认证阶段，从这一部分开始会变得比较复杂。我们实现一个空的 auth 函数，在 process 函数里面调用，再来编写 auth 函数的代码。我们回忆一下认证阶段的逻辑，首先第一步的话，浏览器会给代理服务器发送一个包，然后这个包有三个字段，第一个字段， version 也就是协议版本号，固定是 5 第二个字段 methods，认证的方法数目第三个字段每个 method的编码， 0代表不需要认证， 2 代表用户名密码认证我们先用 read bytes 来把版本号读出来，然后如果版本号不是 socket 5 的话直接返回报错，接下来我们再读取 method size ，也是一个字节。然后我们需要我们去 make 一个相应长度的一个 slice ，用 io.ReadFull 把它去填充进去。

VER	NMETHODS	METHODS
1	1	1 to 255

写到这里，我们把获取到的版本号和认证方式打印一下。此时，代理服务器还需要返回一个response，返回包包括两个字段，一个是 version 一个是 method，也就是我们选中的鉴传方式，我们当前只准备实现不需要鉴传的方式，也就是00。我们用 curl 命令测试一下当前版本的效果，大家猜一下结果会是什么样子呢？

curl --socks5 127.0.0.1:1080 -v http://www.qq.com
*   Trying 127.0.0.1:1080...
* SOCKS5 connect to IPv4 183.194.238.117:80 (locally resolved)
* Failed to receive SOCKS5 connect request ack.
* Closing connection 0
curl: (97) Failed to receive SOCKS5 connect request ack.

服务端输出如下

2023/01/15 18:23:43 ver 5 method [0 1]
2023/01/15 18:23:43 auth success

此时curl 命令肯定是不成功的，因为我们的协议还没实现完成。但是我们看日志会发现， version和method 可以正常打印，说明当前我们的实现是正确的。

func process(conn net.Conn) {
	defer conn.Close()
	reader := bufio.NewReader(conn)
	err := auth(reader, conn)
	if err != nil {
		log.Printf("client %v auth failed:%v", conn.RemoteAddr(), err)
		return
	}
	log.Println("auth success")
}

func auth(reader *bufio.Reader, conn net.Conn) (err error) {
	// +----+----------+----------+
	// |VER | NMETHODS | METHODS  |
	// +----+----------+----------+
	// | 1  |    1     | 1 to 255 |
	// +----+----------+----------+
	// VER: 协议版本，socks5为0x05
	// NMETHODS: 支持认证的方法数量
	// METHODS: 对应NMETHODS，NMETHODS的值为多少，METHODS就有多少个字节。RFC预定义了一些值的含义，内容如下:
	// X’00’ NO AUTHENTICATION REQUIRED
	// X’02’ USERNAME/PASSWORD

	ver, err := reader.ReadByte()
	if err != nil {
		return fmt.Errorf("read ver failed:%w", err)
	}
	if ver != socks5Ver {
		return fmt.Errorf("not supported ver:%v", ver)
	}
	methodSize, err := reader.ReadByte()
	if err != nil {
		return fmt.Errorf("read methodSize failed:%w", err)
	}
	method := make([]byte, methodSize)
	_, err = io.ReadFull(reader, method)
	if err != nil {
		return fmt.Errorf("read method failed:%w", err)
	}
	log.Println("ver", ver, "method", method)
	// +----+--------+
	// |VER | METHOD |
	// +----+--------+
	// | 1  |   1    |
	// +----+--------+
	_, err = conn.Write([]byte{socks5Ver, 0x00})
	if err != nil {
		return fmt.Errorf("write failed:%w", err)
	}
	return nil
}

🎣3.3.3 请求阶段

接下来我们开始做第三步，实现请求阶段，我们试图读取到携带 URL 或者 IP 地址+端口的包，然后把它打印出来。我们实现一个和 auth 函数类似的 connect 函数，同样在 process 里面去调用。再来实现 connect 函数的代码。

我们来回忆一下请求阶段的逻辑。浏览器会发送一个包，包里面包含如下6个字段，

version 版本号，还是 5。
command ，代表请求的类型，我们只支持 connection 请求，也就是让代理服务建立新的TCP连接。
RSV 保留字段，不理会。
atype 就是目标地址类型，可能是 IPV 4 IPV 6 或者域名下面是 addr，这个地址的长度是根据 atype 的类型而不同的 ,port 端口号，两个字节 , 我们需要逐个去读取这些字段。

面这四个字段总共四个字节，我们可以一次性把它读出来。我们定义一个长度为 4 的 buffer 然后把它读满。读满之后，然后第0 个、第1个、第3个、分别是 version cmd 和 type,version 需要判断是 socket 5， cmd 需要判断是 1。下面的 a type，可能是 ipv4 ，ipv6，或者是 host。如果 IPV 4 的话，我们再次读满这个buffer，因为这个buffer长度刚好也是4个字节，然后逐个字节打印成 IP 地址的格式保存到 addr变量。如果是个 host 的话，需要先读它的长度，再 make 一个相应长度的buf 填充它。再转换成字符串保存到 addr 变量。 IPV 6 用得比较少，我们就暂时先不支持。最后还有两个字节那个是 port ，我们读取它，然后按协议规定的大端字节序转换成数字。由于上面的 buffer 已经不会被其他变量使用了，我们可以直接复用之前的内存，建立一个临时的 slice ，长度是2用于读取，这样的话最多会只读两个字节回来。接下来我们把这个地址和端口打印出来用于调试。收到浏览器的这个请求包之后，我们需要返回一个包，这个包有很多字段，但其实大部分都不会使用。第一个是版本号还是 socket 5。第二个，就是返回的类型，这里是成功就返回0 第三个是保留字段填 0 第四个 atype 地址类型填 1 第五个，第六个暂时用不到，都填成 0。一共 4 + 4 + 2 个字节，后面6个字节都是 0 填充。

func connect(reader *bufio.Reader, conn net.Conn) (err error) {
	// +----+-----+-------+------+----------+----------+
	// |VER | CMD |  RSV  | ATYP | DST.ADDR | DST.PORT |
	// +----+-----+-------+------+----------+----------+
	// | 1  |  1  | X'00' |  1   | Variable |    2     |
	// +----+-----+-------+------+----------+----------+
	// VER 版本号，socks5的值为0x05
	// CMD 0x01表示CONNECT请求
	// RSV 保留字段，值为0x00
	// ATYP 目标地址类型，DST.ADDR的数据对应这个字段的类型。
	//   0x01表示IPv4地址，DST.ADDR为4个字节
	//   0x03表示域名，DST.ADDR是一个可变长度的域名
	// DST.ADDR 一个可变长度的值
	// DST.PORT 目标端口，固定2个字节

	buf := make([]byte, 4)
	_, err = io.ReadFull(reader, buf)
	if err != nil {
		return fmt.Errorf("read header failed:%w", err)
	}
	ver, cmd, atyp := buf[0], buf[1], buf[3]
	if ver != socks5Ver {
		return fmt.Errorf("not supported ver:%v", ver)
	}
	if cmd != cmdBind {
		return fmt.Errorf("not supported cmd:%v", ver)
	}
	addr := ""
	switch atyp {
	case atypIPV4:
		_, err = io.ReadFull(reader, buf)
		if err != nil {
			return fmt.Errorf("read atyp failed:%w", err)
		}
		addr = fmt.Sprintf("%d.%d.%d.%d", buf[0], buf[1], buf[2], buf[3])
	case atypeHOST:
		hostSize, err := reader.ReadByte()
		if err != nil {
			return fmt.Errorf("read hostSize failed:%w", err)
		}
		host := make([]byte, hostSize)
		_, err = io.ReadFull(reader, host)
		if err != nil {
			return fmt.Errorf("read host failed:%w", err)
		}
		addr = string(host)
	case atypeIPV6:
		return errors.New("IPv6: no supported yet")
	default:
		return errors.New("invalid atyp")
	}
	_, err = io.ReadFull(reader, buf[:2])
	if err != nil {
		return fmt.Errorf("read port failed:%w", err)
	}
	port := binary.BigEndian.Uint16(buf[:2])

	log.Println("dial", addr, port)
	_, err = conn.Write([]byte{0x05, 0x00, 0x00, 0x01, 0, 0, 0, 0, 0, 0})
	if err != nil {
		return fmt.Errorf("write failed: %w", err)
	}
	return nil
}

现在我们来测试一下当前阶段的成果，简单 curl 一下。此时请求还是会失败，我们现在已经能看到正常打印出来访问的 IP 地址和端口，这说明我们当前的实现正常，这样我们就可以做最后一步，我们真正和这个端口建立连接，双向转发数据。

curl --socks5 127.0.0.1:1080 -v http://www.qq.com
*   Trying 127.0.0.1:1080...
* SOCKS5 connect to IPv4 183.194.238.19:80 (locally resolved)
* SOCKS5 request granted.
* Connected to 127.0.0.1 (127.0.0.1) port 1080 (#0)
> GET / HTTP/1.1
> Host: www.qq.com
> User-Agent: curl/7.83.1
> Accept: */*
>
* Recv failure: Connection was aborted
* Closing connection 0
curl: (56) Recv failure: Connection was aborted

🎣3.3.4 请求阶段

我们直接用 net.dial 建立一个 TCP 连接建立完连接之后，我们同样要加一个 defer 来关闭连接。接下来需要建立浏览器和下游服务器的双向数据转发。标准库的 io.copy 可以实现一个单向数据转发，双向转发的话，需要启动两个 goroutinue。

// +----+-----+-------+------+----------+----------+
	// |VER | REP |  RSV  | ATYP | BND.ADDR | BND.PORT |
	// +----+-----+-------+------+----------+----------+
	// | 1  |  1  | X'00' |  1   | Variable |    2     |
	// +----+-----+-------+------+----------+----------+
	// VER socks版本，这里为0x05
	// REP Relay field,内容取值如下 X’00’ succeeded
	// RSV 保留字段
	// ATYPE 地址类型
	// BND.ADDR 服务绑定的地址
	// BND.PORT 服务绑定的端口DST.PORT
	_, err = conn.Write([]byte{0x05, 0x00, 0x00, 0x01, 0, 0, 0, 0, 0, 0})
	if err != nil {
		return fmt.Errorf("write failed: %w", err)
	}
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	go func() {
		_, _ = io.Copy(dest, reader)
		cancel()
	}()
	go func() {
		_, _ = io.Copy(conn, dest)
		cancel()
	}()

	<-ctx.Done()

curl --socks5 127.0.0.1:1080 -v http://www.qq.com
*   Trying 127.0.0.1:1080...
* SOCKS5 connect to IPv4 183.194.238.19:80 (locally resolved)
* SOCKS5 request granted.
* Connected to 127.0.0.1 (127.0.0.1) port 1080 (#0)
> GET / HTTP/1.1
> Host: www.qq.com
> User-Agent: curl/7.83.1
> Accept: */*
>
* Mark bundle as not supporting multiuse
< HTTP/1.1 302 Moved Temporarily
< Server: stgw
< Date: Sun, 15 Jan 2023 10:36:54 GMT
< Content-Type: text/html
< Content-Length: 137
< Connection: keep-alive
< Location: https://www.qq.com/
<
<html>
<head><title>302 Found</title></head>
<body>
<center><h1>302 Found</h1></center>
<hr><center>stgw</center>
</body>
</html>
* Connection #0 to host 127.0.0.1 left intact

服务端输出

Go 语言原理与实践-基础实战 ｜ 青训营笔记

🎈1. 简介

☃️ 1.1 什么是Go语言

💻 1.2 有哪些公司在使用Go

🎠1.3 环境配置

🏠2. 入门

🎄2.1 基础语法-Hello Word

🎍2.2 基于语法-变量

🍭2.3 基础语法-if else

🧨2.4 基础语法-for

🎐2.5 基础语法-switch

🎑2.6 基础语法-数组

🧧2.6 基础语法-切片

🎀2.7 基础语法-map

🎁2.8 基础语法-range

🎟️2.9 基础语法-struct

🎢2.10 基础语法-错误处理

🎡2.11 基础语法-字符串操作

🎪2.12 基础语法-字符串格式化

🦺2.13 基础语法-Json序列化

🖼️2.14 基础语法-时间

🎭2.15 基础语法-数字解析

🧶3. 小案例实战

🪢3.1 猜数字

🛒3.1.1 随机数

👓3.1.2 随机数种子

🥽3.1.3 读取用户输入

🥼3.1.4 实现判断逻辑

🧥3.1.5 一直猜

🛖3.2 在线词典

🏒3.2.1 抓包

🏀3.2.2 发送GO请求

🪖3.2.3 反序列化

🪗3.2.4 动态翻译

🎰 3.3 SOCKS5 代理

⛳3.3.1 TCP echo server

🎳3.3.2 auth

🎣3.3.3 请求阶段

🎣3.3.4 请求阶段

Go 语言原理与实践-基础实战｜青训营笔记