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

一、本节课重点内容

1. Go语言简介

2. Go语言入门

3. 实战项目

二、详细知识点介绍

1. Go语言简介

Go语言有时候被描述为“C类似语言”，或者是“21世纪的C语言”。Go从C语言继承了相似的表达式语法、控制流结构、基础数据类型、调用参数传值、指针等很多思想，还有C语言一直所看中的编译后机器码的运行效率以及和现有操作系统的无缝适配。（Go语言圣经）

由于Go语言具有语法简单、高性能等特点，因此国内外许多公司都逐步的开始使用Go语言进行开发，国内的如腾讯、字节跳动，国外的如谷歌、facebook等。特别是字节跳动，已经全面拥抱了Go语言，最初使用的python由于业务量的增长遇到了一些性能问题，而C++又不适合在线Web业务，再加上早期团队非Java背景，于是开始逐步尝试使用Go语言编程。Go语言具有以下几大特点：

• 语法简单、学习曲线平缓
• 高性能、高并发
• 丰富的标准库
• 完善的工具链
• 静态链接
• 快速编译
• 跨平台
• 垃圾回收 个人认为，相较于Java和C++的复杂语法，Go语言语法简单，上手快，同时还具有像Python一样丰富的标准库，同时具有高并发等特点，因此Go语言是值得大家去尝试学习的。

2. Go语言入门

（1）开发环境

本地编译环境：Goland、VSCode

云端开发环境：gitpod

（2）基础语法

Hello World

package main

import (
	"fmt"
)

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

package main 代表这个文件属于main包下的文件，是程序的入口包。 import导入了标准库里的fmt包，主要用于输入输出字符串、格式化字符串等。 func main()是main函数，函数里调用了fmt.Println来输出hello world。 使用go build来编译或者使用go run来编译并运行代码。

变量

go语言是一门强类型语言，每一个变量都有它自己的变量类型，声明变量的时候一般会自动推导变量的类型，也可以自己写出变量类型。变量的声明常用方式：

• var name type = value
• name := value

常量

常量就是把var改成const。go语言里的常量没有确定的类型，而是根据上下文自动确定类型。

if else

go语言的if else和C或者C++类似。需要注意的是，在go语言中，if后面是没有括号的，如果写了括号，在保存的时候编辑器会自动去掉括号。另外就是go语言中的if后必须接大括号。

循环

go语言中只有唯一的for循环。for中三个语句任何语句都可省略且for后没有括号，在for循环中，可以使用break或者continue来跳出或者继续循环。

switch

go语言中的switch和C或者C++比较类似。不同的是go语言中的switch后变量名没有括号，case中不需要加break，并且可以使用任意的变量类型。也可以用switch来取代任意的if else语句。

数组

go语言中的数组是一个具有编号且长度固定的元素序列，实际很少使用，更多使用切片。

切片

slice可以任意更改长度，使用make创建、append添加元素（使用append时必须把append结果赋值给原数组），slice可像python一样进行元素的截取。

map

map是在实际使用过程中最频繁用到的数据结构。使用make创建，常用写法：val,ok := m[key]，通过判断ok来判断是否存在key对应的val。在go语言中，map是完全无序的，遍历map时的顺序既不是按照字母顺序，也不是按照插入顺序，而是随机顺序。

range

常用range来快速遍历slice或者map。range在遍历数组的时候会返回索引和值，可以用"_"来忽略索引。

函数

在go语言中，函数的变量类型是后置的，支持返回多个值，在实际的业务逻辑代码里面几乎所有的函数都返回两个值，第一个是真正的返回结果，第二个值是错误信息。

指针

go语言中指针类似C或者C++，但是操作有限，主要的用途是对传入的参数进行修改。

结构体

结构体是带类型的字段的集合。构造结构体的时候需要传入每个字段的初始值，也可用键值对的方式去初始化。可以使用结构体的指针作为参数来实现对结构体的修改，也可以避免结构体的拷贝开销。

结构体方法

结构体方法类似其他语言里的类成员函数，具体的修改方法为：在函数名前带上结构体参数和括号。实现结构体方法的时候同样可以选择带指针或者不带指针，带指针的话就可以对结构体进行修改。

错误处理

常用做法是使用一个单独的返回值来传递错误信息，这样能够很清晰的知道哪个函数返回了错误，并能用简单的if else来处理错误。

字符串操作

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

字符串格式化

go语言的fmt包里有很多字符串格式化相关的方法。经常使用%v来打印任意类型变量，不需要区分数字字符串；%+v打印详细结果；%#v则更详细。

JSON处理

对于一个已有的结构体，只需要保证每个字段的第一个字母都是大写，也就是公开字段。那么这个结构体就能用JSON.marshaler去序列化变成一个JSON的字符串。序列化之后的字符串也可以用JSON.unmarshaler去反序列化到一个空的变量里。可以使用json tag修改输出JSON结果里字段名。

时间处理

time包含时间处理各种函数。time.now()获取当前时间，time.date构造一个带时区的时间，sub对两个时间进行减法，使用.Unix获取时间戳。

数字解析

字符串和数字类型直接的转换通过strconv包的函数，Atoi表示一个十进制字符串转数字，itoA表示把数字转字符串。

进程信息

os.Args得到程序执行的时候的指定的命令行参数，Command执行命令，os.Getenv读取环境变量。

三、实践练习例子

实战项目主要是为了巩固基础语法、使用基础语法进行一些简单的开发、达到快速掌握Go语言基础的目的。

猜谜游戏

使用程序启动的时间戳来初始化随机数种子，随机生成0~100的数字，提示用户输入，并解析为数字，然后比较用户输入的数和随机生成数的大小，根据大小提示信息，不断循环，直到用户正确猜出数字即可退出循环。通过猜谜游戏的例子，可以巩固变量循环、字符串处理、函数控制流和错误处理等知识

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

在线词典

抓包彩云小译翻译的api，并拷贝curl命令，通过网站转换成go代码，并拷贝服务端响应的json数据，通过网站生成go结构体，然后解析对应的字段输出，通过该例子学习发送http请求、解析json格式、使用代码生成提高开发效率等

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

SOCKS5代理

通过该例子，学习socks5协议的工作原理，分为四个阶段：

• 握手阶段：浏览器会向socks5代理发送请求，socks5服务器会选择一个认证方式返回给浏览器
• 认证阶段
• 请求阶段：认证通过之后浏览器会向socks5服务器发起请求，代理服务器收到响应之后，会和真正的后端服务器建立连接，然后返回一个响应。
• replay阶段：浏览器会发送正常请求，代理服务器在接收到请求之后转发给真正的服务器，也会把真正的服务器返回的响应转发给浏览器。

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
}

四、课后个人总结

通过本次课程的学习，对go语言有了一个初步的认识，了解了go语言的基础语法并通过几个简单的实战练习对基础知识进行了巩固，虽然go语言的语法简单，易上手，但是学习一门新的编程语言从来都不是一件容易的事情，要想更加熟悉的运用go语言，还需要对go语言的官方文档进行阅读和学习，快速浏览一遍go语言的标准库，知道常见函数的用法。在课后更需要不断的巩固学习，可以选择跟着课程，基于主流的框架做一些小项目。