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

基础语法

01 简介

什么是 Go 语言

高性能、高并发
语法简单、学习曲线平缓
丰富的标准库
完善的工具链
静态链接：默认是静态编译的，只要拷可执行文件即可
快速编译：对于静态编译语言来说具有最快的编译速度
跨平台：支持Linux，Windows，macOS，树莓派，路由器等等，还有交叉编译特性
垃圾回收：和java一样，不需要考虑内存泄露，垃圾回收

02 入门

Go语言与 C/C++很类似，在 C++ 语言的基础上，主要注意几点区别：

if else 没有括号
只有for循环

// 没有条件就是死循环
for {
    fmt.Println("loop")
    break
}

// 类似while循环
i := 1
for i <= 3 {
    fmt.Println(i)
    i = i + 1
}

switch

go中case 可以不用加break（可以比较任意的类型：字符串、结构体等），但是 C/C++ 只允许比较特定类型，并且得加break

// switch 当 if-else 使用
switch {
    case t.Hour() < 12:
        fmt.Println("before noon")
    default:
        fmt.Println("after noon")
}

数组（固定长度）
切片（类似于C++中的vector）

可变长度；使用 make 创建

s := make([]string, 3)
s = append(s, "d")
c := make([]string, len(s))
// copy 在两个 slice 里面拷贝数据
// slice支持切片操作 [a,b) 左闭右开区间
copy(c, s)

map（go中的map是完全无序的，对应C++：unordered_map）

// 定义key-value
m := make(map[string]int)

// 取出map中的值
r, ok = m["unknown"]

// 删除键值对
delete(m, "one")

函数

函数支持返回多个值，一般来说，第一个值返回真正的返回值，第二个是错误信息

指针

相对C/C++中的指针，作用：只支持修改传入的参数值

结构体方法

类似于类成员函数，实现方法有两种，一种带指针，一种不带指针。带指针的可以对结构体的内容进行修改

package main

import "fmt"

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
}

错误处理

一般函数第二个返回值是错误（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)
	}
}

字符串

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
}

字符串格式化

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

json操作

a. 保证结构体的每一个字段第一个字母都是大写的，那么就可以使用 json.Marshal 进行序列化

b. 序列化后的json可以使用 json.Unmarshal 进行反序列化

c. 若是想要 json 中显示字段是小写的话，则在结构体声明的时候后面加上 json的tag （即下面代码第10行）

时间处理

a. t.Format 里面的时间 “2006-01-02 15:04:05”是写在官方文档上的，必须使用这个时间

b. time.Unix()：获取时间戳

数字解析

strconv包实现字符串与数字之间的转化(Atoi，Itoa)

进程信息

os.Args获取进程的命令行参数

exec.Command启动子进程并快速获取输入输出

03 实战

3.1 猜数字游戏（略）

3.2 在线词典

3.2.1 抓包

访问 fanyi.caiyunapp.com/

F12找到 network 中的 POST 请求

3.2.2 代码生成

右击 F12 中的那一条 POST 请求
copy->copy as cURL
找一个终端粘贴cURL，正常是一大段 Json
访问 curlconverter.com/#go ，将 json 粘贴进去，可以得到代码（注意使用linux，Windows会转义不出来）
若出现由转义导致编译错误的行，那就把那几行删掉即可

3.2.3 生成代码解读（略）

3.2.3 生成 request body

因为 Go 中结构体满足首字母大写即可被 json.Marshal 转化为 byte 数组 buf，再使用 bytes.NewReader(buf)，再使用 http.NewRequest，因此可以对 DictRequest 定义一个结构体，将该结构体转化为 json之后，通过 http.NewRequest 发送出去

3.2.4 解析 response body

访问 oktools.net/json2go
将浏览器中的 json 粘贴进去 -> 转换嵌套（代码会紧凑点）
这样就能够得到一个与响应json格式对应的结构体

3.2.5 打印结果

上述代码检查了响应是否为 200

并且将结果只打印想要的结果

3.2.6 完善代码

主函数获取用户输入的单词，调用 HTTP 请求彩云翻译的API 实现命令行词典

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 代理介绍

原理：

3.3.1 TCP echo server

go关键字会启动一个 goroutine ，即启动一个子线程
go里面 goroutine 的开销比子线程和子进程小很多，可以轻松处理上万的并发
reader.ReadByte 看上去是一个字节一个字节地读，但是实际上是带缓冲的，底层实现的时候可能在读第一个字节的时候会把后面 1k 字节的内容都读完，然后再一个字节一个字节返回，以减少系统调用

测试方法：使用 nc 命令：直接和某个 ip+端口建立 TCP 连接

3.3.2 认证（auth）

浏览器给服务器发送一个报文（version、认证方式的数目、认证方式编号）
服务器根据报文中的真正方式数目接收数据

3.2.3 请求

服务器在完成认证（auth）后执行连接（connect）
connect函数根据协议会先使用4个字节的byte数组读取出：版本号、命令、ATYP
再根据ATYP字段的类型来读取addr
最后复用4字节byte型数组读取出最后两位的port，使用binary.BigEndian.Uint16转换为大端序
得到addr和port之后连接

3.3.4 relay阶段

net.Dial("tcp", fmt.Sprintf("%v:%v", addr, port))可以实现和特定的地址和端口建立TCP连接
io.Copy(dst Writer, src Reader)（written int64, err error）可以实现从 src 到 dst 的一个单向数据转发（死循环从reader中复制数据到writer中）
开启两个线程：一个从浏览器获取数据发送到底层服务器；另一个从底层服务器发送数据到浏览器
因为创建goroutine几乎不花时间，因此启动完两个goroutine后可能会直接关闭连接，而我们需要等到任何一个方向的copy失败，因此需要使用go的context机制。
使用context.WithCancel（context.Background()）创建一个ctx
<-ctx.Done()：等待ctx执行完成。这个ctx.Done（）执行的时机就是cancel（）函数被调用的时机

package main

import (
	"bufio"
	"context"
	"encoding/binary"
	"errors"
	"fmt"
	"io"
	"log"
	"net"
)

const socks5Ver = 0x05
const cmdBind = 0x01
const atypIPV4 = 0x01
const atypeHOST = 0x03
const atypeIPV6 = 0x04

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)
	err := auth(reader, conn)
	if err != nil {
		log.Printf("client %v auth failed:%v", conn.RemoteAddr(), err)
		return
	}
	err = connect(reader, conn)
	if err != nil {
		log.Printf("client %v auth failed:%v", conn.RemoteAddr(), err)
		return
	}
}

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

	// +----+--------+
	// |VER | METHOD |
	// +----+--------+
	// | 1  |   1    |
	// +----+--------+
	_, err = conn.Write([]byte{socks5Ver, 0x00})
	if err != nil {
		return fmt.Errorf("write failed:%w", err)
	}
	return nil
}

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

	dest, err := net.Dial("tcp", fmt.Sprintf("%v:%v", addr, port))
	if err != nil {
		return fmt.Errorf("dial dst failed:%w", err)
	}
	defer dest.Close()
	log.Println("dial", addr, port)

	// +----+-----+-------+------+----------+----------+
	// |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()
	return nil
}

PS

本文主要作用是作为上课笔记，第一次发文章，如有错误，欢迎大家评论，我会及时改正

后端小白学习笔记（一）：Go语言基础 | 青训营笔记