Go 语言基础｜青训营笔记这是我参与「第五届青训营」伴学笔记创作活动的第 1 天一、Go 语言基础 Go 语言基

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

一、Go 语言基础

Go 语言基础在开营前就匆匆看了些，今天的30分钟视频也是扫了一眼就过了

但是还是会感慨切片 slice 的用法，是我以前用 C++ 没有见到过的，本质上可以看做指针和长度

map 用的是 hash 的原理，通过拉链法来防止哈希冲突，同时key也是无序（随机）的，具体的底层原理还没有抽空去深究，有空值得研究一下

二、实战案例

猜谜游戏

把输入改用了fmt.scanf，C++ 中习惯不用处理空格，发现每次读入都会有两个结果出现；通过调试发现原来是会自动读入行末的换行符

因此在读入的时候再读多一个 \n 即可

package main

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

func main() {
    maxNum := 100
    rand.Seed(time.Now().UnixNano())
    selectNum := rand.Intn(maxNum)
    fmt.Println("Please input your guess")

    for {
        var guess int
        fmt.Scanf("%d\n", &guess)
        if guess == selectNum {
            fmt.Println("Correct, you Legend!")
            break
        } else if guess > selectNum {
            fmt.Println("Your guess is bigger than the secret number. Please try again")
        } else {
            fmt.Println("Your guess is smaller than the secret number. Please try again")
        }
    }
}

在线词典

该实践主要是通过 https://curlconverter.com/go/ 通过 curl 生成请求头的代码，然后再根据所需要查询的内容，将请求的 body 填充好数据

接受 json 数据的时候，要根据返回的数据定义一个结构体，再将数据通过 json.Unmarshal() 填充到结构体中。结构体的定义可以直接通过 https://oktools.net/json2go 生成

在写入请求的单词那里，我没有通过 json.Marshal() 转化，尝试了一下 fmt.Sprintf() 直接变成字符串，再换成流输入，发现是可以的，不过确实麻烦

代码在主函数中用了并行请求，一开始发现主函数总是先退出，于是直接 time.Sleep(5 * time.Second)，但是发现太卡了。于是学习了一下 sync.WaitGroup 的基础用法，能够使得其余的 goroutine 结束后才退出主函数

package main

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

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, wg *sync.WaitGroup) {
    client := &http.Client{}
    var data = strings.NewReader(fmt.Sprintf("{\"trans_type\":\"en2zh\",\"source\":\"%s\"}", word))
    req, err := http.NewRequest("POST", "https://api.interpreter.caiyunai.com/v1/dict", data)
    if err != nil {
        log.Fatal(err)
    }
    req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:108.0) Gecko/20100101 Firefox/108.0")
    req.Header.Set("Accept", "application/json, text/plain, */*")
    req.Header.Set("Accept-Language", "zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2")
    // req.Header.Set("Accept-Encoding", "gzip, deflate, br")
    req.Header.Set("Content-Type", "application/json;charset=utf-8")
    req.Header.Set("X-Authorization", "token:qgemv4jr1y38jyq6vhvi")
    req.Header.Set("app-name", "xy")
    req.Header.Set("version", "1.8.0")
    req.Header.Set("os-type", "web")
    req.Header.Set("Origin", "https://fanyi.caiyunapp.com")
    req.Header.Set("Connection", "keep-alive")
    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("TE", "trailers")
    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)
    fmt.Println("US:", dictResponse.Dictionary.Prons.EnUs, " EN:", dictResponse.Dictionary.Prons.En)
    for _, i := range dictResponse.Dictionary.Explanations {
        fmt.Println(i)
    }
    fmt.Println()
    wg.Done()
}

func main() {
    var wg sync.WaitGroup
    if len(os.Args) > 1 {
        for _, s := range os.Args[1:] {
            wg.Add(1)
            go query(s, &wg)
        }
    }
    wg.Wait()
}

SOCKS5 代理

还没搞懂

三、感想

感觉第二个和第三个案例涉及好多计网原理，有点吃力

第二个案例目前还没办法实现在另一种翻译引擎上爬取，以有道翻译为例，它在爬取的时候存在一个 sign 的哈希值，虽然在他官网的 API 上找到了是如何计算的（看到很多 blog 都是在开发人员工具直接找到源码，复制过来的），但是要改的地方很多，第三个案例也没看懂，于是延后再研究

Go 语言基础 ｜ 青训营笔记

一、Go 语言基础

二、实战案例

三、感想

Go 语言基础｜青训营笔记