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

重点内容

• 配置Go语言开发环境
• Golang变量、常量声明
• for循环
• if条件判断
• switch case
• array数组
• slice切片
• map集合
• range遍历
• func函数
• *取值 &取地址
• struct结构体
• 结构体方法
• error库
• strings库
• fmt库
• encoding/json库
• time库
• strconv库
• os库

知识点介绍

• Golang中有且只有for循环

  for{
      // code    
  }
  for i := 0; i < 5; i++{
      // code
  }
  for idx,item := range(切片、Map等等){
      // code
  }
  

• switch case

  • 可以代替if else
  • 不需要break分割
  • 可以使用fallthrough执行多个

temp := 1
switch temp {
    case 1:
    fmt.Println("a")
    fallthrough
    // 当case 1 时会强制执行2 
    case 2:
    fmt.Println("b")
    case 3:
    fmt.Println("c")
}
// 结果
// a
// b

• Golang中的map是一种无序的key/value对
• range可以用来迭代数组(array)、切片(slice)、通道(channel)、集合(map)
• Golang中使用返回值进行错误处理

实践

猜数字游戏

直接使用rand包中的Intn会生成伪随机数,每次启动程序的随机值一样。

我们可以使用Seed加时间戳实现真随机数。

输入输出的数据流可以使用标准库fmt优化。

翻译

主要学习如何使用代码生成工具

将json转换为Golang结构体:OKTools

使用curl命令生成函数:Curlconvert

结构体可以序列化为json字符串，json字符串通过tag标签可以反序列化为结构体。

Socket5代理

协议每部分的字节长度已知，可以通过顺序读取字节流获取信息。

使用context包中的WithCancel以及Done()控制程序结束实践。

课后总结

• 学习了如何配置Golang开发环境
• Golang基础语法
• 了解了一些标准库的使用

作业

使用fmt优化guess_game

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")
​
    for {
        var guess int
        _, err := fmt.Scan(&guess)
        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
        }
    }
}

新增一种翻译引擎并使用并发加快翻译速度

仅记录新增代码

type HSDictReq struct {
    Source         string   `json:"source"`
    Words          []string `json:"words"`
    SourceLanguage string   `json:"source_language"`
    TargetLanguage string   `json:"target_language"`
}
​
type HSDictResponse struct {
    Details []struct {
        Detail string `json:"detail"`
        Extra  string `json:"extra"`
    } `json:"details"`
    BaseResp struct {
        StatusCode    int    `json:"status_code"`
        StatusMessage string `json:"status_message"`
    } `json:"base_resp"`
}
​
type Details struct {
    ErrorCode string `json:"errorCode"`
    RequestID string `json:"requestId"`
    Msg       string `json:"msg"`
    Result    []struct {
        Ec struct {
            ReturnPhrase []string `json:"returnPhrase"`
            Synonyms     []struct {
                Pos   string   `json:"pos"`
                Words []string `json:"words"`
                Trans string   `json:"trans"`
            } `json:"synonyms"`
            Etymology struct {
                ZhCHS []struct {
                    Description string `json:"description"`
                    Detail      string `json:"detail"`
                    Source      string `json:"source"`
                } `json:"zh-CHS"`
            } `json:"etymology"`
            SentenceSample []struct {
                Sentence     string `json:"sentence"`
                SentenceBold string `json:"sentenceBold"`
                Translation  string `json:"translation"`
            } `json:"sentenceSample"`
            WebDict string `json:"webDict"`
            Web     []struct {
                Phrase   string   `json:"phrase"`
                Meanings []string `json:"meanings"`
            } `json:"web"`
            MTerminalDict string `json:"mTerminalDict"`
            RelWord       struct {
                Word string `json:"word"`
                Stem string `json:"stem"`
                Rels []struct {
                    Rel struct {
                        Pos   string `json:"pos"`
                        Words []struct {
                            Word string `json:"word"`
                            Tran string `json:"tran"`
                        } `json:"words"`
                    } `json:"rel"`
                } `json:"rels"`
            } `json:"relWord"`
            Dict  string `json:"dict"`
            Basic struct {
                UsPhonetic string   `json:"usPhonetic"`
                UsSpeech   string   `json:"usSpeech"`
                Phonetic   string   `json:"phonetic"`
                UkSpeech   string   `json:"ukSpeech"`
                ExamType   []string `json:"examType"`
                Explains   []struct {
                    Pos   string `json:"pos"`
                    Trans string `json:"trans"`
                } `json:"explains"`
                UkPhonetic  string `json:"ukPhonetic"`
                WordFormats []struct {
                    Name  string `json:"name"`
                    Value string `json:"value"`
                } `json:"wordFormats"`
            } `json:"basic"`
            Phrases []struct {
                Phrase   string   `json:"phrase"`
                Meanings []string `json:"meanings"`
            } `json:"phrases"`
            Lang   string `json:"lang"`
            IsWord bool   `json:"isWord"`
        } `json:"ec"`
    } `json:"result"`
}
​
func queryHuoShan(word string) {
    client := &http.Client{}
    request := HSDictReq{"youdao", []string{word}, "en", "zh"}
    buf, err := json.Marshal(request)
    if err != nil {
        log.Fatal(err)
    }
    var data = bytes.NewReader(buf)
    req, err := http.NewRequest("POST", "https://translate.volcengine.com/web/dict/detail/v1/?msToken=&X-Bogus=DFSzswVOQDaZVvKbSZUbXVXAIQ2a&_signature=_02B4Z6wo00001B7O8LgAAIDBfcQw0g53GJAezvQAAGR2VpMXmfgdHgCXt4qUcV0ujZJIIzsgogve15Now0CEot3vCcFKdbgTYHY5zMjAHYMSyunGev.5Al2F7Sb4GBxWeMuvCLbKKZd3XAWzb8", data)
    if err != nil {
        log.Fatal(err)
    }
    req.Header.Set("authority", "translate.volcengine.com")
    req.Header.Set("accept", "application/json, text/plain, */*")
    req.Header.Set("accept-language", "zh-CN,zh;q=0.9")
    req.Header.Set("content-type", "application/json")
    req.Header.Set("cookie", "x-jupiter-uuid=16737647316086264; i18next=zh-CN; s_v_web_id=verify_lcx0b13u_175PBAV8_sac1_4b1O_BHDz_9GgIAlnHe93G; ttcid=37563e1a38cb48a2aacecc67d1a16b8a38; tt_scid=lFMZaHHB.938uRZh.2UF1GPIIKNDOMYL.Iyw9DgIHxi0192MJcOVZQMNVObFtnfv4b5a")
    req.Header.Set("origin", "https://translate.volcengine.com")
    req.Header.Set("referer", "https://translate.volcengine.com/?category=&home_language=zh&ref=toolsdar.com&source_language=detect&target_language=zh&text=good")
    req.Header.Set("sec-ch-ua", `"Not?A_Brand";v="8", "Chromium";v="108", "Google Chrome";v="108"`)
    req.Header.Set("sec-ch-ua-mobile", "?0")
    req.Header.Set("sec-ch-ua-platform", `"Windows"`)
    req.Header.Set("sec-fetch-dest", "empty")
    req.Header.Set("sec-fetch-mode", "cors")
    req.Header.Set("sec-fetch-site", "same-origin")
    req.Header.Set("user-agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36")
    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 HSDictResponse
    err = json.Unmarshal(bodyText, &dictResponse)
    if err != nil {
        log.Fatal(err)
    }
    var detail Details
    err = json.Unmarshal([]byte(dictResponse.Details[0].Detail), &detail)
    if err != nil {
        log.Fatal(err)
    }
    for _, item := range detail.Result {
        fmt.Println("火山翻译结果")
        fmt.Println(word, "Uk:[", item.Ec.Basic.UkPhonetic, "]Us:[", item.Ec.Basic.UsPhonetic, "]") // 音标
        for _, item2 := range item.Ec.Basic.Explains {
            fmt.Printf("%s:\n%s\n", item2.Pos, item2.Trans)
        } // 翻译
    }
    fmt.Println("-----------------------")
}

难点

火山翻译的返回值中的Detail是含有转义字符的字符串，无法直接使用生成工具生成代码。

将结果中的details字符串保存为字符串，并新增对应结构体再次使用json.Marshal反序列化，成功得到结果。