这是我参与「第三届青训营 -后端场」笔记创作活动的的第1篇笔记！

1. Go语言的特性

go语言是一种静态、强类型、编译型语言。Go 语言语法与C相近，但功能上有：内存安全，GC（垃圾回收），结构形态及 CSP-style并发计算。以下便是go语言的一些主要特征：

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

2. 开发环境配置

2.1 go环境下载

go语言中文网下载对应版本的go语言环境。

下载完成之后一直next默认安装即可。

2.2 go编译器下载

· GoLand

GoLand官网下载对应版本后购买激活便可开始配置使用，也可以通过学生邮箱申请免费使用。

再根据网上的一些博客进行相关的环境配置即可。

· VSCode

VSCode官网下载安装，跟着网上的博客教程进行go语言的环境配置即可（博客1，博客2）。

3. 基础语法

3.1 Hello World

golang语言和python类似，都不需要 ";"去分句。

3.2 变量

golang里的变量类型是后置的，需要先定义变量名再定义变量类型。

3.3 if-else

和C/C++的语法类似，但有不太的是 if 之后不用跟上 ()，且条件语句之后必须跟上 {} —— 不能省去{}在同一行处理。

3.4 循环

go语言里只有一种循环方式 —— for循环，同样也支持continue、break等循环跳转操作。

3.5 switch

不同于C/C++的，go语言中的switch每一条分支不需要 break 来中断，匹配到对应的case后便不会再继续执行后面的case判断。
go语言里的switch支持更多变量类型(字符串、结构体等)，甚至可以省略条件变量在 case 里直接进行条件判断来取代繁杂的 if-else 嵌套。

3.6 数组

数组的定义需要固定长度，同样通过 var 来定义。

3.7 切片

利用make进行初始化。如果只用var声明，不用make初始化，变量对应的值为nil。

3.8 map

map同样利用make来初始化，且golang里的map里的存储是采用随机的方式——在遍历的时不会由大小排序，也不会由插入的先后进行排序。

3.9 range遍历

在range遍历时，第一个值为索引，第二个值为数据值；如果不需要用索引的话可以利用 "_"去覆盖即可。

3.10 函数

golang里的函数原生支持返回多个值，在实际业务代码中几乎所有的函数都返回多个值(真正返回值+错误信息)，例如下面的exists函数。

3.11 指针

golang里的指针相对C/C++的指针作用非常局限，主要用于传入参数值的修改。

3.12 结构体

3.13 结构体方法

结构体方法在函数(类成员函数)的定义时和自定义的函数(普通函数)有些区别，结构体方法是针对到结构体变量本身直接利用 "." 就可以调用的，而自定义方法还需要传入结构体参数。

3.14 错误处理

不同于java里的异常处理方法，golang里的异常处理习惯是通过一个单独的返回值 err 来判断异常，且能够清晰的判断是哪个函数发生了异常并利用 if-else 去处理错误。

3.15 字符串操作

golang的strings标准包内由很多便利的函数可以直接调用。

3.16 字符串格式化

3.17 JSON处理

3.18 时间处理

不同于java中的“yy-MM-dd HH:MM:SS”来格式化时间，golang里面是利用官方的某个特定时间格式去格式化时间。

3.19 数字解析

3.20 进程信息

4. 猜谜游戏

func main()  {
   maxx := 100
   rand.Seed(time.Now().UnixNano())  // 利用时间戳生成随机种子，避免生成同意数字
   secretNumber := rand.Intn(maxx)
   //fmt.Println(secretNumber)
   fmt.Println("请输入你猜测的数字：")
   //readder := bufio.NewReader(os.Stdin)
   for {
      //input, err := readder.ReadString('\n')    // 读入一行
      var guess int
      _, err := fmt.Scanf("%d", &guess)
      if err != nil {
         fmt.Println("输入错误， 请重新输入：", err)
         continue
      }
      //input = strings.TrimSuffix(input, "\n")   // 去除换行符
      //guess, err := strconv.Atoi(input)         // 转换成数字
      //if err != nil {
      // fmt.Println("输入错误，请输入整数：", err)
      // continue
      //}
      fmt.Println("你猜的数字是： ", guess)
      if guess > secretNumber {
         fmt.Println("猜大了，请重新猜一个：")
      } else if guess < secretNumber {
         fmt.Println("猜小了， 请重新猜一个：")
      } else {
         fmt.Println("猜对了！！")
         break
      }
   }
}

5. 在线词典实现

5.1 复制post请求

在彩云小译词典利用开发者工具检查复制一个post翻译请求的json字段。

5.2 生成post请求的go代码

通过代码生成网站生成对应的go语言代码。

5.3 编译运行go代码

在本地idea编译运行该代码，确保请求过程不会出错。

5.4 定义发送请求的结构体

上面的代码中需要翻译的内容不便于更改，这个适合就需要自行定义一个与请求相适应的结构体，去生成用户需要翻译内容对应的请求数据格式。

再 new 一个变量去替代原先的请求data。

到此，再次编译运行得到的json结果应与之前的内容一致。

5.5 生成结果解析的结构体代码

通过另一个代码生成网站将本地运行得到的json结果生成对应的结构体代码，这里选择嵌套的形式即可。

生成一个庞大的结构体，贴入本地编译器利用即可。

5.6 反序列化结果Json串并获取关键信息

由于即便反序列化后的数据依旧是个jeson串，很多数据都是不太关键的，我们需要筛选关键的内容进行打印陈列。

注意：添加一个状态码的判断语句，避免错误的数据返回导致程序出现异常，便于排查问题。

5.7 设置用户查询的输入

将原先的main函数修改成具体的query查询函数，并将原先固有的查询值替换成传递的参数 word。

利用 os.Args 获取进程传递的信息进行翻译

5.8 完整程序代码

type DictRequest struct {   // 创建一个结构体去对应json请求的字段, 便于自定义翻译的具体内容
   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() {
func query( word string) {
   client := &http.Client{}
   //var data = strings.NewReader(`{"trans_type":"en2zh","source":"good"}`)

   //request := DictRequest{"en2zh", "good"}
   request := DictRequest{"en2zh", 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)  // 创建一个post请求
   if err != nil {
      log.Fatal(err)
   }
   req.Header.Set("Connection", "keep-alive")   // 设置请求头
   req.Header.Set("sec-ch-ua", `" Not A;Brand";v="99", "Chromium";v="98", "Google Chrome";v="98"`)
   req.Header.Set("sec-ch-ua-mobile", "?0")
   req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/98.0.4758.102 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("os-type", "web")
   req.Header.Set("X-Authorization", "token:qgemv4jr1y38jyq6vhvi")
   req.Header.Set("sec-ch-ua-platform", `"Windows"`)
   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")
   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)  // 得到的json字符串

   if resp.StatusCode != 200 {
      log.Fatal("bad StatusCode: ", resp.StatusCode, " body: ", string(bodyText))
   }

   var dictResponse DictResponse
   err = json.Unmarshal(bodyText, &dictResponse)   // 反序列化结果的json串
   if err != nil {
      log.Fatal(err)
   }
   //fmt.Printf("%#v\n", dictResponse)
   // 筛选单词和音标
   fmt.Println(dictResponse.Wiki.Item.Source, "  UK:", dictResponse.Dictionary.Prons.En, "  US:", dictResponse.Dictionary.Prons.EnUs)
   for _, item := range dictResponse.Dictionary.Explanations {
      fmt.Print(item, " ")
   }
}

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

5.9 扩展翻译 - 并行计算

追加火山翻译，利用并行计算方式提高响应速度，以下是火山翻译对应的结构体：

type DictRequests struct {
   Text string `json:"text"`
   Language string `json:"language"`
}

type DictResponses struct {
   Words []struct {
      Source int `json:"source"`
      Text string `json:"text"`
      PosList []struct {
         Type int `json:"type"`
         Phonetics []struct {
            Type int `json:"type"`
            Text string `json:"text"`
         } `json:"phonetics"`
         Explanations []struct {
            Text string `json:"text"`
            Examples []struct {
               Type int `json:"type"`
               Sentences []struct {
                  Text string `json:"text"`
                  TransText string `json:"trans_text"`
               } `json:"sentences"`
            } `json:"examples"`
            Synonyms []interface{} `json:"synonyms"`
         } `json:"explanations"`
         Relevancys []interface{} `json:"relevancys"`
      } `json:"pos_list"`
   } `json:"words"`
   Phrases []interface{} `json:"phrases"`
   BaseResp struct {
      StatusCode int `json:"status_code"`
      StatusMessage string `json:"status_message"`
   } `json:"base_resp"`
}

对应的请求数据与结果数据的处理：

// 设置对应 word 的请求 data
request := DictRequests{word, "en"}
buf, err := json.Marshal(request)
if err != nil {
   log.Fatal(err)
}
var data = bytes.NewReader(buf)


// 只输出第一组结果
for _, word := range dictResponses.Words {
   fmt.Print(word.Text)
   for _, polist := range word.PosList {
      idx := 0
      for _, phonetics := range polist.Phonetics {
         if idx == 0 {
            fmt.Print("  UK:", phonetics.Text)
            idx = 1
         } else {
            fmt.Println("  US:", phonetics.Text)
         }
      }
      for _, explanation := range polist.Explanations {
         fmt.Println(explanation.Text)
      }
      break
   }
   break
}

· 并行计算

*因此在每个进程中需要传递 wg 参数，以便在结尾利用wg.Done()结束任务，否则会无法结束程序。

6. Socks5 代理

learning...

Go 语言上手 | 青训营笔记