青训营第一天 | 青训营笔记

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

走进Go语言基础语言

变量声明

var a =  "asdasd"  自动推导变量类型
int = 1, 2      也可以显式写出类型
f := float32(e) 
const s string = "constant"   常量为const，也是自动确定类型

if - else

    if 7%2 == 0 {    // 条件语句没有括号
        fmt.Println("7 is even")
    } else {
        fmt.Println("7 is odd")
    }

循环语句

只有for循环
    i := 1
    for {
        fmt.Println("loop")
        break
    }
    for j := 7; j < 9; j++ {
        fmt.Println(j)
    }
​
    for n := 0; n < 5; n++ {
        if n%2 == 0 {
            continue
        }
        fmt.Println(n)
    }
    for i <= 3 {
        fmt.Println(i)
        i = i + 1
    }

switch语句

    a := 2
    switch a {
    case 1:
        fmt.Println("one")  // 不用加break即可自动跳出循环
    case 2:
        fmt.Println("two")
    case 3:
        fmt.Println("three")
    case 4, 5:
        fmt.Println("four or five")
    default:
        fmt.Println("other")
    }

数组

很少使用数组，因为长度固定，更多的用切片
    var a [5]int
    a[4] = 100
    fmt.Println("get:", a[2])
    fmt.Println("len:", len(a))
​
    b := [5]int{1, 2, 3, 4, 5}
    fmt.Println(b)
​
    var twoD [2][3]int
    for i := 0; i < 2; i++ {
        for j := 0; j < 3; j++ {
            twoD[i][j] = i + j
        }
    }
    fmt.Println("2d: ", twoD)

切片

切片长度可变
    // make创建切片
    s := make([]string, 3)
    s[0] = "a"
    s[1] = "b"
    s[2] = "c"
    fmt.Println("get:", s[2])   // c
    fmt.Println("len:", len(s)) // 3
    
    // append来追加元素
    s = append(s, "d")
    s = append(s, "e", "f")
    fmt.Println(s) // [a b c d e f]
​
    // 直接指定长度
    c := make([]string, len(s))
    // 拷贝
    copy(c, s)
    fmt.Println(c) // [a b c d e f]
    
    // 第2到第5个下标的元素，左闭右开
    fmt.Println(s[2:5]) // [c d e]
    fmt.Println(s[:5])  // [a b c d e]
    fmt.Println(s[2:])  // [c d e f]
​
    good := []string{"g", "o", "o", "d"}
    fmt.Println(good) // [g o o d]

map

    // 创建map, map[key][value]
    m := make(map[string]int)
    // 赋值
    m["one"] = 1
    m["two"] = 2
    fmt.Println(m)           // map[one:1 two:2]
    fmt.Println(len(m))      // 2
    fmt.Println(m["one"])    // 1
    fmt.Println(m["unknow"]) // 0
​
    // 这个ok是布尔类型，用来获取是否有这个key，r为所获取的value，默认为0
    r, ok := m["unknow"]
    fmt.Println(r, ok) // 0 false
​
    // 删除key-value对
    delete(m, "one")
​
    m2 := map[string]int{"one": 1, "two": 2}
    var m3 = map[string]int{"one": 1, "two": 2}
    fmt.Println(m2, m3)

range

    nums := []int{2, 3, 4}
    sum := 0
    
    // i为索引，num为对应的值，如果不需要索引可以用下划线 _ 代替
    for i, num := range nums {
        sum += num
        if num == 2 {
            fmt.Println("index:", i, "num:", num) // index: 0 num: 2
        }
    }
    fmt.Println(sum) // 9
​
    m := map[string]string{"a": "A", "b": "B"}
​
    // k为key, v为value
    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
    }

函数

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   // 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
}

指针

// 主要用途就是对值进行修改
func add2(n int) {
    n += 2 // 这里只是拷贝，不是修改
}
​
func add2ptr(n *int) {
    *n += 2  // 这里可以在n的基础上修改
}
​
func main() {
    n := 5
    add2(n)
    fmt.Println(n) // 5
    add2ptr(&n)  // 调用的时候要用一个 & 符号才能编译通过
    fmt.Println(n) // 7
}

结构体

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
}

结构体方法

type user struct {
    name     string
    password string
}
​
// 加上（u user） 就把普通方法变成了结构体方法
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
}

错误处理

type user struct {
    name     string
    password string
}
​
func findUser(users []user, name string) (v *user, err error) { // 加一个err
    for _, u := range users {
        if u.name == name {
            return &u, nil  // 没有错误返回 值，nil
        }
    }
    return nil, errors.New("not found")  // 有错误返回 nil值，错误
}
​
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)
    }
}

字符串

    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 // 一个中文对应多个字符

字符串格式化 fmt

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 // 保留两位小数
}

JSON处理

type userInfo struct {
    Name  string    // 只要保证每个字段的第一个字母是大写
    Age   int `json:"age"`  // 如果真的需要小写需要在后面加一个 `json:"age"` 这种tag
    Hobby []string
}
​
func main() {
    a := userInfo{Name: "wang", Age: 18, Hobby: []string{"Golang", "TypeScript"}}
    buf, err := json.Marshal(a)  // 序列化后变成buf数组
    if err != nil {
        panic(err)
    }
    fmt.Println(buf)         // [123 34 78 97...] 不加string会打印出16禁止编码
    fmt.Println(string(buf)) // {"Name":"wang","age":18,"Hobby":["Golang","TypeScript"]} // 加了string正常打印
​
    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"}}
}

时间处理

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  获取时间戳
}

字符串与数字之间的转换 strconv 包

    f, _ := strconv.ParseFloat("1.234", 64)
    fmt.Println(f) // 1.234
​
    n, _ := strconv.ParseInt("111", 10, 64) // 字符串，进制，64位精度
    fmt.Println(n) // 111
​
    n, _ = strconv.ParseInt("0x1000", 0, 64) // 如果为0就自动推测进制
    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

进程信息

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
}

Go语言的实战案例

猜数字游戏

v1 缺点：每次的随机数都一样

import (
    "fmt"
    "math/rand"  // 随机数包
)
​
func main() {
    maxNum := 100
    secretNumber := rand.Intn(maxNum) 
    fmt.Println("The secret number is ", secretNumber)
}

v2

import (
    "fmt"
    "math/rand"
    "time" 
)
​
func main() {
    maxNum := 100
    rand.Seed(time.Now().UnixNano())  // 用时间戳做随机数种子
    secretNumber := rand.Intn(maxNum)
    fmt.Println("The secret number is ", secretNumber)
}

v3

import (
    "bufio"
    "fmt"
    "math/rand"
    "os"
    "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)
    input, err := reader.ReadString('\n')
    if err != nil {
        fmt.Println("An error occured while reading input. Please try again", err)
        return
    }
    ---------------------------------------------
    // 去掉多余的换行符
    input = strings.Trim(input, "\r\n")
    
    // 转成数字
    guess, err := strconv.Atoi(input)
    if err != nil {
        fmt.Println("Invalid input. Please enter an integer value")
        return
    }
    fmt.Println("You guess is", guess)
}

v4 此时只能猜一次程序就退出了

    guess, err := strconv.Atoi(input)
    if err != nil {
        fmt.Println("Invalid input. Please enter an integer value")
        return
    }
    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!")
    }

v5 加个for循环， for{} 死循环，结束时加个break

    for {
        input, err := reader.ReadString('\n')
        if err != nil {
            fmt.Println("An error occured while reading input. Please try again", err)
            continue
        }
        input = strings.Trim(input, "\r\n")
​
        guess, err := strconv.Atoi(input)
        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 // 跳出
        }
    }

命令行在线词典：输入一个单词输出音标和注释

打开彩云翻译

右键dict文件 copy as cURL(bash)

打开转换网址

client := &http.Client{}
// 这里的是一个确定的字符串，我们实际使用是要输入一个可变的
var data = strings.NewReader(`{"trans_type":"en2zh","source":"good"}`) 
req, err := http.NewRequest("POST", "https://api.interpreter.caiyunai.com/v1/dict", data)

所以这里要新建一个结构体作为序列化的对象

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"`
}
​
func main() {
    client := &http.Client{}
    request := DictRequest{TransType: "en2zh", Source: "good"}
    buf, err := json.Marshal(request)
    if err != nil {
        log.Fatal(err)
    }
    var data = bytes.NewReader(buf)  // byte数组
    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)
    }
    fmt.Printf("%s\n", bodyText)
}

下面获取response并进行反序列化

打开OKTools，进行JSON转Go的结构体 -- 转换-嵌套

    var dictResponse DictResponse
    err = json.Unmarshal(bodyText, &dictResponse)  // 反序列化

留下需要的

    fmt.Println(word, "UK:", dictResponse.Dictionary.Prons.En, "US:", dictResponse.Dictionary.Prons.EnUs)
    for _, item := range dictResponse.Dictionary.Explanations {
        fmt.Println(item)
    }

完善代码

运行成功！

SOCKS5代理服务器

v1 TCP echo server

package main
​
import (
    "bufio"
    "log"
    "net"
)
​
func main() {
    server, err := net.Listen("tcp", "127.0.0.1:1080")  // 创建一个服务器
    if err != nil {
        panic(err)
    }
    for {
        client, err := server.Accept()  // 创建连接
        if err != nil {
            log.Printf("Accept failed %v", err)
            continue
        }
        go process(client)  // 处理连接
    }
}
​
func process(conn net.Conn) {
    defer conn.Close()
    reader := bufio.NewReader(conn)
    for {
        b, err := reader.ReadByte() // 读字节
        if err != nil {
            break
        }
        _, err = conn.Write([]byte{b}) // 写字节
        if err != nil {
            break
        }
    }
}

v2 添加认证阶段

v3 添加请求阶段

v5 relay阶段