Go基础语法&作业 ｜ 青训营笔记

3dfish
87 阅读4分钟

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

1 基础语法

1.1 Go的HelloWorld

package main//main包，程序入口文件
​
import (
    "fmt"//导入标准库format，输入输出字符串，格式化字符串的包
)
​
func main() {
    fmt.Println("hello world")
}

运行程序：go run main.go

1.2 变量

var a = "initial"//声明方式1
f := float32(e)//声明方式2
g := a + "foo"
const s string = "constant"//自动确定类型
const h = 500000000

1.3 if else

if后没有括号，if里语句必须加大括号

if 7%2 == 0 {
    fmt.Println("7 is even")
} else {
    fmt.Println("7 is odd")
}

1.4 循环

for j := 7; j < 9; j++ {
    fmt.Println(j)
}

1.5 switch

（1）不会跑其他分支，一个case直接break

（2）switch后不加条件，case后加条件分支

switch a {
    case 1:
    fmt.Println("one")
    case 2, 3:
    fmt.Println("four or five")
    default:
    fmt.Println("other")
}
​
t := time.Now()
switch {
    case t.Hour() < 12:
    fmt.Println("It's before noon")
    default:
    fmt.Println("It's after noon")
}

1.6 数组

var a [5]int
a[4] = 100
​
b := [5]int{1, 2, 3, 4, 5}
fmt.Println(b)
​
var twoD [2][3]int

很少用，常用切片

1.7 切片slice

可变长度数组

s := make([]string, 3)
s = append(s, "d")
s = append(s, "e", "f")
​
c := make([]string, len(s))
copy(c, s)

1.8 map

m := make(map[string]int)
m["one"] = 1
​
r, ok := m["unknow"]
fmt.Println(r, ok) // 0 false
​
delete(m, "one")
​
m2 := map[string]int{"one": 1, "two": 2}
var m3 = map[string]int{"one": 1, "two": 2}

注意是无序存储的

1.9 range

对于slice和map遍历

nums := []int{2, 3, 4}
sum := 0
for i, num := range nums {
    sum += num
}
m := map[string]string{"a": "A", "b": "B"}
for k, v := range m {
    fmt.Println(k, v) // b 8; a A
}
for k := range m {
    fmt.Println("key", k) // key a; key b
}

1.10 函数

变量类型后置

返回2个值

func add(a int, b int) int {
    return a + b
}
​
func add2(a, b int) int {
    return a + b
}
​
func exists(m map[string]string, k string) (v string, ok bool) {
    v, ok = m[k]
    return v, ok
}
​
func main() {
    res := add(1, 2)
    fmt.Println(res) // 3
​
    v, ok := exists(map[string]string{"a": "A"}, "a")
    fmt.Println(v, ok) // A True
}

1.11 指针

功能有限，对传入参数进行修改（类似C）

func add2ptr(n *int) {
    *n += 2
}
func main() {
    n := 5
    add2ptr(&n)
    fmt.Println(n) // 7
}

1.12 结构体

type user struct {
    name     string
    password string
}
​
func main() {
    a := user{name: "wang", password: "1024"}
    b := user{"wang", "1024"}
    c := user{name: "wang"}
    c.password = "1024"
    var d user
    d.name = "wang"
    d.password = "1024"
​
    fmt.Println(a, b, c, d)                 // {wang 1024} {wang 1024} {wang 1024} {wang 1024}
    fmt.Println(checkPassword(a, "haha"))   // false
    fmt.Println(checkPassword2(&a, "haha")) // false
}
​
func checkPassword(u user, password string) bool {
    return u.password == password
}
​
func checkPassword2(u *user, password string) bool {
    return u.password == password
}

作为函数参数也有非指针和指针

1.13 结构体方法

type user struct {
    name     string
    password string
}
​
func (u user) checkPassword(password string) bool {
    return u.password == password
}
​
func (u *user) resetPassword(password string) {
    u.password = password
}
​
func main() {
    a := user{name: "wang", password: "1024"}
    a.resetPassword("2048")
    fmt.Println(a.checkPassword("2048")) // true
}

1.14 错误处理

函数返回值类型加err error表示函数可能返回错误，

函数实现时需要同时返回两个返回值

package main
​
import (
    "errors"
    "fmt"
)
​
type user struct {
    name     string
    password string
}
​
func findUser(users []user, name string) (v *user, err error) {
    for _, u := range users {
        if u.name == name {
            return &u, nil
        }
    }
    return nil, errors.New("not found")
}
​
func main() {
    u, err := findUser([]user{{"wang", "1024"}}, "wang")
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(u.name) // wang
​
    if u, err := findUser([]user{{"wang", "1024"}}, "li"); err != nil {
        fmt.Println(err) // not found
        return
    } else {
        fmt.Println(u.name)
    }
}
​

1.15 字符串操作

package main
​
import (
    "fmt"
    "strings"
)
​
func main() {
    a := "hello"
    fmt.Println(strings.Contains(a, "ll"))                // true
    fmt.Println(strings.Count(a, "l"))                    // 2
    fmt.Println(strings.HasPrefix(a, "he"))               // true
    fmt.Println(strings.HasSuffix(a, "llo"))              // true
    fmt.Println(strings.Index(a, "ll"))                   // 2
    fmt.Println(strings.Join([]string{"he", "llo"}, "-")) // he-llo
    fmt.Println(strings.Repeat(a, 2))                     // hellohello
    fmt.Println(strings.Replace(a, "e", "E", -1))         // hEllo
    fmt.Println(strings.Split("a-b-c", "-"))              // [a b c]
    fmt.Println(strings.ToLower(a))                       // hello
    fmt.Println(strings.ToUpper(a))                       // HELLO
    fmt.Println(len(a))                                   // 5
    b := "你好"
    fmt.Println(len(b)) // 6
}

1.16 字符串格式化

type point struct {
    x, y int
}
​
func main() {
    s := "hello"
    n := 123
    p := point{1, 2}
    fmt.Println(s, n) // hello 123
    fmt.Println(p)    // {1 2}
​
    fmt.Printf("s=%v\n", s)  // s=hello
    fmt.Printf("n=%v\n", n)  // n=123
    fmt.Printf("p=%v\n", p)  // p={1 2}
    fmt.Printf("p=%+v\n", p) // p={x:1 y:2}
    fmt.Printf("p=%#v\n", p) // p=main.point{x:1, y:2}
​
    f := 3.141592653
    fmt.Println(f)          // 3.141592653
    fmt.Printf("%.2f\n", f) // 3.14
}

1.17 JSON 处理

package main
​
import (
    "encoding/json"
    "fmt"
)
​
type userInfo struct {
    Name  string
    Age   int `json:"age"`
    Hobby []string
}
​
func main() {
    a := userInfo{Name: "wang", Age: 18, Hobby: []string{"Golang", "TypeScript"}}
    buf, err := json.Marshal(a)
    if err != nil {
        panic(err)
    }
    fmt.Println(buf)         // [123 34 78 97...]
    fmt.Println(string(buf)) // {"Name":"wang","age":18,"Hobby":["Golang","TypeScript"]}
​
    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.Printf("%#v\n", b) // main.userInfo{Name:"wang", Age:18, Hobby:[]string{"Golang", "TypeScript"}}
}
​

1.18 时间处理

package main
​
import (
    "fmt"
    "time"
)
​
func main() {
    now := time.Now()
    fmt.Println(now) // 2022-03-27 18:04:59.433297 +0800 CST m=+0.000087933
    t := time.Date(2022, 3, 27, 1, 25, 36, 0, time.UTC)
    t2 := time.Date(2022, 3, 27, 2, 30, 36, 0, time.UTC)
    fmt.Println(t)                                                  // 2022-03-27 01:25:36 +0000 UTC
    fmt.Println(t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute()) // 2022 March 27 1 25
    fmt.Println(t.Format("2006-01-02 15:04:05"))                    // 2022-03-27 01:25:36
    diff := t2.Sub(t)
    fmt.Println(diff)                           // 1h5m0s
    fmt.Println(diff.Minutes(), diff.Seconds()) // 65 3900
    t3, err := time.Parse("2006-01-02 15:04:05", "2022-03-27 01:25:36")
    if err != nil {
        panic(err)
    }
    fmt.Println(t3 == t)    // true
    fmt.Println(now.Unix()) // 1648738080
}

1.19 数字解析

package main
​
import (
    "fmt"
    "strconv"
)
​
func main() {
    f, _ := strconv.ParseFloat("1.234", 64)
    fmt.Println(f) // 1.234
​
    n, _ := strconv.ParseInt("111", 10, 64)
    fmt.Println(n) // 111
​
    n, _ = strconv.ParseInt("0x1000", 0, 64)
    fmt.Println(n) // 4096
​
    n2, _ := strconv.Atoi("123")
    fmt.Println(n2) // 123
​
    n2, err := strconv.Atoi("AAA")
    fmt.Println(n2, err) // 0 strconv.Atoi: parsing "AAA": invalid syntax
}
​

1.20 进程信息

package main
​
import (
    "fmt"
    "os"
    "os/exec"
)
​
func main() {
    // go run example/20-env/main.go a b c d
    fmt.Println(os.Args)           // [/var/folders/8p/n34xxfnx38dg8bv_x8l62t_m0000gn/T/go-build3406981276/b001/exe/main a b c d]
    fmt.Println(os.Getenv("PATH")) // /usr/local/go/bin...
    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)) // 127.0.0.1       localhost
}

2 作业：

工具：

curl转go json转go

2.1 使用 fmt.Scanf 来简化猜数字代码实现

package main
​
import (
    "fmt"
    "math/rand"
    //"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.TrimSuffix(input, "\n")
        //
        //guess, err := strconv.Atoi(input)
        
        //---------------------------
        var guess int
        _, err := fmt.Scanf("%d", &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
        }
    }
}

2.2 新增火山翻译

打开火山翻译软件，随便输入一个单词翻译，右键检查，找到该POST请求：

dic_post.png

右键复制cURL(bash)格式，到curl转go转成go代码：

dic_post_curl.png

这就是我们要使用的方法：

package main
​
import (
    "fmt"
    "io/ioutil"
    "log"
    "net/http"
    "strings"
)
​
func main() {
    client := &http.Client{}
    var data = strings.NewReader(`{"text":"good\n\n","language":"en"}`)
    req, err := http.NewRequest("POST", "https://translate.volcengine.com/web/dict/match/v1/?msToken=&X-Bogus=DFSzKwGLQDGX3WfISWQuae9WX7jv&_signature=_02B4Z6wo000016rCTXwAAIDDKsC3PYdPQ0-q0knAAIjPqth8YSC6sDMWZzSsG3uLp727NAEfYcG9YaMYcfitaK.RW-kOspvcWgCDIJG62egJd8SHRstdunLSKsM-lNWT8ph8leIa6cOLUM7O78", 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,en-US;q=0.8,en;q=0.7")
    req.Header.Set("content-type", "application/json")
    req.Header.Set("cookie", "x-jupiter-uuid=16519219151363730; s_v_web_id=verify_9ef2a3f930b6726c75fce904bb19fd9c; _tea_utm_cache_2018=undefined; ttcid=6d46ed22021e4189ab2fd105c08d98b939; i18next=zh-CN; tt_scid=eRoYKoS3Np8-8jZG3ZRHK-ncRt.ZTd4NPlGTOZXpT2jNXntjq26Inn7yTs4E6Nk26f7d")
    req.Header.Set("origin", "https://translate.volcengine.com")
    req.Header.Set("referer", "https://translate.volcengine.com/translate?category=&home_language=zh&source_language=detect&target_language=zh&text=good%0A%0A")
    req.Header.Set("sec-ch-ua", `" Not A;Brand";v="99", "Chromium";v="101", "Google Chrome";v="101"`)
    req.Header.Set("sec-ch-ua-mobile", "?1")
    req.Header.Set("sec-ch-ua-platform", `"Android"`)
    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 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.54 Mobile 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)
    }
    fmt.Printf("%s\n", bodyText)
}

把请求载荷使用json转goRequest结构体：

dic_paylod.png

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

同理，把返回结果转为Response结构体：

dic_pre.png

type AutoGenerated 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"`
}

将上述结构体和方法重新命名方便后续使用，见下方具体实现代码。

2.3 并行请求提高响应速度

参考资料 深入浅出 WaitGroup 和 Errgroup

见main方法具体实现：

package main
​
import (
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "log"
    "net/http"
    "os"
    "sync"
)
​
type DictRequest struct {
    TransType string `json:"trans_type"`
    Source    string `json:"source"`
    UserID    string `json:"user_id"`
}
type DictRequestHuoshan struct {
    Text string `json:"text"`
    Language string `json:"language"`
}
​
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"`
}
type DictResponseHuoshan 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"`
}
​
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 queryHuoshan(word string) {
    client := &http.Client{}
    request := DictRequestHuoshan{Text: word, Language: "en"}
    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/match/v1/?msToken=&X-Bogus=DFSzKwVLQDVeE2IFSWQl/e9WX7rV&_signature=_02B4Z6wo00001Fd2n1wAAIDA13RlHhUomDhXZpvAAHezHnMhEdf2lJl2uj7spsIKZdDAQqj9wYNk.7DMwteLJctMlgcb6cjmtoyJqBuwJ9r9-xo4qmf9RPcCEt4ZdwpLgC6PQWjqCROY6aTU21", 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,en-US;q=0.8,en;q=0.7")
    req.Header.Set("content-type", "application/json")
    req.Header.Set("cookie", "x-jupiter-uuid=16519219151363730; s_v_web_id=verify_9ef2a3f930b6726c75fce904bb19fd9c; _tea_utm_cache_2018=undefined; ttcid=6d46ed22021e4189ab2fd105c08d98b939; i18next=translate; tt_scid=qg6u4nCXbmvYO2HC2xbB0VqBD9NIOPvyhZ8v3tztf0bhwWIsuaalpY7yCe8lSE7Baff0")
    req.Header.Set("origin", "https://translate.volcengine.com")
    req.Header.Set("referer", "https://translate.volcengine.com/translate?category=&home_language=zh&source_language=en&target_language=zh&text=student%0A%0A")
    req.Header.Set("sec-ch-ua", `" Not A;Brand";v="99", "Chromium";v="101", "Google Chrome";v="101"`)
    req.Header.Set("sec-ch-ua-mobile", "?1")
    req.Header.Set("sec-ch-ua-platform", `"Android"`)
    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 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.54 Mobile 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 DictResponseHuoshan
    err = json.Unmarshal(bodyText, &dictResponse)
    if err != nil {
        log.Fatal(err)
    }
    //根据Response结构体的成员来输出需要的结果
    fmt.Println(word, "UK:", dictResponse.Words[0].PosList[0].Phonetics[0].Text, "US:", dictResponse.Words[0].PosList[0].Phonetics[1].Text)
    for idx, item := range dictResponse.Words[0].PosList {
        fmt.Println(idx, item.Explanations[0].Text)
    }
}
​
func main() {
    if len(os.Args) != 2 {
        fmt.Fprintf(os.Stderr, `usage: simpleDict WORD
example: simpleDict hello
        `)
        os.Exit(1)
    }
    word := os.Args[1]
    var flg = 0
    var wg sync.WaitGroup
    wg.Add(1)
    go func() {
        defer wg.Done()
        query(word)
        flg = 1
    }()
    go func() {
        defer wg.Done()
        queryHuoshan(word)
        flg = 2
    }()
    wg.Wait()
    if flg == 1 {
        fmt.Println("from 彩云翻译")
    } else {
        fmt.Println("from 火山翻译")
    }
}
avatar
文章
阅读
粉丝