这是我参与「第三届青训营 -后端场」笔记创作活动的的第二篇笔记。笔记的内容总结并归纳了第一次课程的学习成果，并附有本人对课后作业的思考和回答。

课程1：Go语言基本上手

1 Go语言的优势

1.1 什么是Go语言

Go语言的特征

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

1.2 很多公司都在使用Go语言

包括但不限于字节跳动、Google、微软、美团、腾讯等等。

1.3 字节全面拥抱Go的历史进程

在使用Python语言时，遇到了性能瓶颈。最初的团队没有Java功底，因此转向了Go并获得了预想不到的效果。

2 Go环境安装

除去Go语言安装环境之外，IDE推荐使用Goland。

3 Go语言基础语法

简单的基础语法可以去查看Go语言圣经。此处列出几个与C++、Java等语言不同的部分:

3.1 if-else语句

1、if-else语句不包含括号，即使写了括号编译器也会自动去掉。
2、if-else语句之后都必须跟大括号，而不能像C++、Java一样写在一行内

go语言中的if-else语句示例如下：

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 one digit")
   } else {
      fmt.Println(num, " has multiple digits")
   }
}

3.2 循环

与C++、Java等语言不同的是，Go语言中只有for循环而没有while循环

go语言中for循环不同的使用策略如下：

func main() {
   i := 1
   for { //无穷循环，类似于while(true)
      fmt.Println("in endless loop ", i)
      i++
      if i == 5 {
         break
      }
   }

   for j := 7; j < 99; j++ { //经典for循环
      fmt.Println(j)
   }
   i = 1
   for i<=3{
      fmt.Println(i)
      i++
   }
}

3.3 切片与指针

切片本质上是对内存一段区域的引用；而与C++、Java不同的是，Go语言中的指针不支持直接运算

3.4 struct类型的方法定义

在Go语言官网中的常见问题解答一栏，有一个这样的问题：“Go语言是否是一种面向对象的语言？”。有意思的是，Go官方给出的回答是：“Yes and No”。

Go虽然有着面向对象语言的编程风格，但Go并不是典型的面向对象的语言。但是通过struct结构体类型，可以定义类似于Java中的class对象。

下面展示一个例子，如何让一个类拥有自己的方法：

type user struct {
   name     string
   password string
}

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

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

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

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

func main() {
   var war user
   war.name = "war"
   war.password = "zxy19991031"
   fmt.Println(checkPassword1(war, "123"))
   fmt.Println(checkPassword2(&war, "zxy19991031"))
   fmt.Println(war.checkPassword("123"))
   war.setPassword("123")
   fmt.Println(war.checkPassword("123"))
}

可以看到，在func后增加struct类型的变量，就代表了这个函数本质上是一个struct类型变量的方法。

3.5 json库的使用

对于后端开发工程师，对JSON的了解是至关重要的。标准库提供了encoding/json库来处理JSON。编码JSON，即从其他的数据类型编码成为JSON字符串，在该过程中我们会用到如下接口:

func Marshal(v interface{})([]byte,error)
func MarshalIndent(v interface{},prefix, indent string)([]byte,error)

大多数情况下，我们会使用struct结构体来进行快速的JSON编解码，特别是在JSON解码时，使用struct会相当方便。在定义struct字段的时候，可以通过在字段后边添加标签来控制编解码的过程：是否要编码或者解码某个字段，JSON中的字段名称是什么。可以选择的控制字段有3种： 1、-：不需要解析该字段 2、omitempty:当字段为空（默认值）时，不要解析该字段。比如false、0、nil、长度为0的array、map、slice、string 3、FieldName:当解析json的时候，使用这个名字

解码JSON会用到Unmarshal接口，也就是Marshal的反操作:

func Unmarshal(data []byte, v interface{}) error

Unmarshal函数解析JSON编码的数据并将结果存入v所指向的值。要将JSON的数据解码写入一个接口类型值，函数会将数据解码为不同的类型写入接口。

JSON库的示例代码如下：

type userInfo struct {
   Name  string
   Age   int `json:"age"`
   Hobby []string
}

func main() {
   a := userInfo{Name: "wang", Age: 18, Hobby: []string{"Golang", "Java"}}
   buf, err := json.Marshal(a)
   if err != nil {
      panic(err)
   }

   fmt.Println(buf)
   fmt.Println(string(buf))

   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.Println("%#v\n", b)
}

3.6 数字解析

strconv包中，有许多方法将字符串变为对应的int或者float，类似于Java中对应的Integer.parseInt()和Double.parseDouble()等方法。当遇到错误时，会在第二个返回参数返回错误。

3.7 进程解析

在Go语言中，os包中包含了大量与操作系统和环境相关的函数。例如os.Argv可以得到程序运行时的命令行参数。一个简单的示例代码如下：

func main() {
   fmt.Println(os.Args)
   fmt.Println(os.Getenv("PATH"))
   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))
}

4 简单的项目

项目1 猜数字（过于简单直接贴作业代码 pass）

func main() {
   maxNum := 1000
   rand.Seed(time.Now().UnixNano())
   secretNum := rand.Intn(maxNum)
   fmt.Println("please input your guess:")
   for {
      var guess int
      _, err := fmt.Scanf("%d\n", &guess)
      if err != nil {
         fmt.Println("Invalid input, please input a number")
         continue
      }
      if guess > secretNum {
         fmt.Println("your guess in larger than the secret number.")
      } else if guess < secretNum {
         fmt.Println("your guess is smaller than the secret number.")
      } else {
         fmt.Println("Correct, you Legend!!!")
         break
      }
   }
}

项目2 在线词典

为了实现在线词典，我们可以调用别人的翻译引擎

首先是学会抓包,windows下应该是复制为curl(bash)

从网页调试工具里面查看随时收发的网络数据包，挨个查看它们的response，如果里面的json数据出现翻译结果，那么说明这个包就是返回的翻译结果！

那么我们只需要让go语言来做同样的两件事：

发起请求。
解析返回的json内容。

只要做好了这两件事，那么就很快得到了一个单词的翻译了。

第二步，利用工具生成代码

Curl转换器这个网页能够将curl请求变为各种语言的代码

JSON转Golang Struct - 在线工具 - OKTools 这个网页能够将JSON转换为Go语言的代码

通过这两步就能够实现JSON转换

第三步，更改代码实现功能

具体代码实现如下所示：

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{} //首先生成了一个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("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("Connection", "keep-alive")
   req.Header.Set("Content-Type", "application/json;charset=UTF-8")
   req.Header.Set("Origin", "https://fanyi.caiyunapp.com")
   req.Header.Set("Referer", "https://fanyi.caiyunapp.com/")
   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/101.0.4951.54 Safari/537.36 Edg/101.0.1210.39")
   req.Header.Set("X-Authorization", "token:qgemv4jr1y38jyq6vhvi")
   req.Header.Set("app-name", "xy")
   req.Header.Set("os-type", "web")
   req.Header.Set("sec-ch-ua", `" Not A;Brand";v="99", "Chromium";v="101", "Microsoft Edge";v="101"`)
   req.Header.Set("sec-ch-ua-mobile", "?0")
   req.Header.Set("sec-ch-ua-platform", `"Windows"`)
   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))
   }
   //fmt.Printf("%s\n", 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() {
   var word string
   for {
      fmt.Println("请输入您要查询的单词(0返回)")
      _, err := fmt.Scanf("%s\n", &word)
      if err != nil {
         return
      }
      if word == "0" {
         break
      }
      query(word)
   }
}

依葫芦画瓢，例如网易有道词典，也可以得到对应的curl代码，然后对于作业中要求的并发实现，可以利用go关键字，代码如下所示：

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 query(word string) {
   client := &http.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("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("Connection", "keep-alive")
   req.Header.Set("Content-Type", "application/json;charset=UTF-8")
   req.Header.Set("Origin", "https://fanyi.caiyunapp.com")
   req.Header.Set("Referer", "https://fanyi.caiyunapp.com/")
   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/101.0.4951.54 Safari/537.36 Edg/101.0.1210.39")
   req.Header.Set("X-Authorization", "token:qgemv4jr1y38jyq6vhvi")
   req.Header.Set("app-name", "xy")
   req.Header.Set("os-type", "web")
   req.Header.Set("sec-ch-ua", `" Not A;Brand";v="99", "Chromium";v="101", "Microsoft Edge";v="101"`)
   req.Header.Set("sec-ch-ua-mobile", "?0")
   req.Header.Set("sec-ch-ua-platform", `"Windows"`)
   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))
   }
   //fmt.Printf("%s\n", 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)
   }
}

type DictResponse_yd struct {
   Result struct {
      Msg  string `json:"msg"`
      Code int    `json:"code"`
   } `json:"result"`
   Data struct {
      Entries []struct {
         Explain string `json:"explain"`
         Entry   string `json:"entry"`
      } `json:"entries"`
      Query    string `json:"query"`
      Language string `json:"language"`
      Type     string `json:"type"`
   } `json:"data"`
}

func query_yd(word string) {
   client := &http.Client{}

   req, err := http.NewRequest("GET", "https://dict.youdao.com/suggest?num=5&ver=3.0&doctype=json&cache=false&le=en&q="+word, nil)
   if err != nil {
      log.Fatal(err)
   }
   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("Connection", "keep-alive")
   req.Header.Set("Cookie", `OUTFOX_SEARCH_USER_ID_NCOO=1944269163.3572404; OUTFOX_SEARCH_USER_ID="-624887538@10.110.96.160"; search-popup-show=5-15`)
   req.Header.Set("Origin", "https://www.youdao.com")
   req.Header.Set("Referer", "https://www.youdao.com/")
   req.Header.Set("Sec-Fetch-Dest", "empty")
   req.Header.Set("Sec-Fetch-Mode", "cors")
   req.Header.Set("Sec-Fetch-Site", "same-site")
   req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.54 Safari/537.36 Edg/101.0.1210.39")
   req.Header.Set("sec-ch-ua", `" Not A;Brand";v="99", "Chromium";v="101", "Microsoft Edge";v="101"`)
   req.Header.Set("sec-ch-ua-mobile", "?0")
   req.Header.Set("sec-ch-ua-platform", `"Windows"`)
   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))
   }
   //fmt.Printf("%s\n", bodyText)
   var dictResponse DictResponse_yd
   err = json.Unmarshal(bodyText, &dictResponse)
   if err != nil {
      log.Fatal(err)
   }
   fmt.Println(word)
   for _, data := range dictResponse.Data.Entries {
      fmt.Println(data.Entry, ":", data.Explain)
   }
}

func main() {
   var word string
   for {
      fmt.Println("请输入您要查询的单词(0返回)")
      _, err := fmt.Scanf("%s\n", &word)
      if err != nil {
         return
      }
      if word == "0" {
         break
      }
      go query(word)
      query_yd(word)
   }
}

项目3 socks5代理服务器

socks5代理服务器的工作原理如下：正常浏览器访问一个网站，如果不经过代理服务器的话，就是先和对方的网站建立TCP连接，然后三次握手，握手结束之后发起HTTP请求，然后服务返回HTTP响应。而Socks5代理相当于浏览器与代理进行TCP连接，然后代理再与真正的服务器建立TCP连接。

代码总共四个函数，main(),process(),auth(),connect()，主要部分是认证函数auth()和连接函数connect()。代码内容大多都是些读取数据，在各种数据格式之间进行转换。

Go语言上手笔记|青训营笔记(二)