Go基础与实战｜青训营笔记

nostrawberry
118 阅读10分钟

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

1.Go语言特点

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

2.语法

借用demo对go内容基本过一遍，包含基础语法、常用库等，详细内容还需要参考go官方文档和编辑器的提示

2.1 编译运行

运行

go run xxx

编译二进制

go build xxx

2.2 变量

package main
​
import (
  "fmt"
  "math"
)
​
func main() {
​
  var a = "initial" //go会自动识别变量类型
​
  var b, c int = 1, 2 //变量名写在前面，变量类型写在后面，且可以分开写
​
  var d = true
​
  var e float64
​
  f := float32(e) //类型转换
​
  g := a + "foo" //可以像python直接拼接
  fmt.Println(a, b, c, d, e, f) // initial 1 2 true 0 0
  fmt.Println(g)                // initialapple
​
  const s string = "constant"
  const h = 500000000
  const i = 3e20 / h
  fmt.Println(s, h, i, math.Sin(h), math.Sin(i))
}

2.3 if-else

  • if后面没有括号
  • if后面直接跟大括号，不可以写一行
package main
​
import "fmt"
​
func main() {
​
  if 7%2 == 0 {
    fmt.Println("7 is even")
  } else {
    fmt.Println("7 is odd")
  }
​
  if 8%4 == 0 {
    fmt.Println("8 is divisible by 4")
  }
​
  if num := 9; num < 0 {
    fmt.Println(num, "is negative")
  } else if num < 10 {
    fmt.Println(num, "has 1 digit")
  } else {
    fmt.Println(num, "has multiple digits")
  }
}

2.4 循环

package main
​
import "fmt"
​
func main() {
​
  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
  }
}

2.5 switch

  • 不用加break，不会把后面都执行(c++)
  • case后面可以跟任意类型，贼舒服
package main
​
import (
  "fmt"
  "time"
)
​
func main() {
​
  a := "2"
  switch a {
  case "1":
    fmt.Println("one")
  case "2":
    fmt.Println("two")
  case "3":
    fmt.Println("three")
  case "4", "5":
    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")
  }
}

2.6 数组

  • 因为长度固定，所以在业务场景中很少使用，更多用的是切片
package main
​
import "fmt"
​
func main() {
​
  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)
}

2.7 切片

  • 相当于可变长度的数组，使用和数组差不多
package main
​
import "fmt"
​
func main() {
​
  s := make([]string, 3) //make也可以不指定长度
  s[0] = "a"
  s[1] = "b"
  s[2] = "c"
  fmt.Println("get:", s[2])   // c
  fmt.Println("len:", len(s)) // 3
​
  s = append(s, "d") //append函数需要传回s，因为新增后是在新的地址空间申请了一个新的切片并返回了指针和长度
  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]
​
  fmt.Println(s[2:5]) // [c d e] 前闭后开，不支持指定步长取（python）
  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]
}

2.8 map

map也非常强大，存储key:value

  • map完全无序
package main
​
import "fmt"
​
func main() {
  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
​
  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}
  fmt.Println(m2, m3)
}

2.9 range

  • 用于遍历
package main
​
import "fmt"
​
func main() {
  nums := []int{2, 3, 4}
  sum := 0
  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"}
  for k, v := range m {
    fmt.Println(k, v) // a A; b B
  }
  for k := range m {
    fmt.Println("key", k) // key a; key b
  }
}

2.10 函数

  • 实际业务中基本返回两个值，第一个实际业务值，第二个错误信息（因为go没有try catch，而要写if err!=nil...）
package main
​
import "fmt"
​
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
}

2.11 指针

  • 相比较c，指针操作有限，主要用途是对传入参数进行修改（非常好）
package main

import "fmt"

//值传递
func add2(n int) {
	n += 2
}

//指针传递
func add2ptr(n *int) {
	*n += 2
}

func main() {
	n := 5
	add2(n)
	fmt.Println(n) // 5
	add2ptr(&n)
	fmt.Println(n) // 7
}

2.12 结构体

package main
​
import "fmt"
​
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
}

2.13 结构体方法

go是面向过程的语言，在方法后面加个结构体伪装成对象的方法

package main

import "fmt"

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
}

2.14 错误处理

根据返回err进行判断

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

2.15 字符串操作

strings库里有很多操作

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
}

2.16 字符串格式化

package main
​
import "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}
​
  //很像printf，%v可以打印任何类型的值
  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
}

2.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) //结构体->json
	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") //加上换行和tab键
	if err != nil {
		panic(err)
	}
	fmt.Println(string(buf))

	var b userInfo
	err = json.Unmarshal(buf, &b) //结构，json->结构体
	if err != nil {
		panic(err)
	}
	fmt.Printf("%#v\n", b) // main.userInfo{Name:"wang", Age:18, Hobby:[]string{"Golang", "TypeScript"}}
}

2.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 时间戳
}

ps:时间减法真的很好用

2.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) //parseint(字符串，进制，位数)
  fmt.Println(n) // 111
​
  n, _ = strconv.ParseInt("0x1000", 0, 64)
  fmt.Println(n) // 4096
​
  n2, _ := strconv.Atoi("123") //效果和parseint一样
  fmt.Println(n2) // 123
​
  n2, err := strconv.Atoi("AAA") 
  fmt.Println(n2, err) // 0 strconv.Atoi: parsing "AAA": invalid syntax
}

2.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.Setenv("AA", "BB"))
  fmt.Println(os.Getenv("PATH")) // /usr/local/go/bin...
​
  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
}

3.实战

3.1 猜数游戏（rand生成随机数）

v1初始版本

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

发现输出的一直是同一个数，查询官方文档发现需要给rand库用时间戳初始化种子:

rand.Seed(time.Now().UnixNano())

V2实现用户输入输出

package main

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") //去除换行和return

	guess, err := strconv.Atoi(input) //字符串->数字
	if err != nil {
		fmt.Println("Invalid input. Please enter an integer value")
		return
	}
	fmt.Println("You guess is", guess)
}

ps:虽然但是,if err!=nil有点丑

v4比较大小

package main
​
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)
  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加入循环

package main
​
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)
  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
    }
  }
}

3.2 命令行词典（HTTP发请求）

抓包

使用彩云小译

image-20230115133641328

image-20230115133717454

对该请求copy as cURL

复制内容：

curl 'api.interpreter.caiyunai.com/v1/dict' \ -H 'authority: api.interpreter.caiyunai.com' \ -H 'accept: application/json, text/plain, / ' \ -H 'accept-language: zh-CN,zh;q=0.9' \ -H 'app-name: xy' \ -H 'content-type: application/json;charset=UTF-8' \ -H 'device-id;' \ -H 'dnt: 1' \ -H 'origin: fanyi.caiyunapp.com' \ -H 'os-type: web' \ -H 'os-version;' \ -H 'referer: fanyi.caiyunapp.com/' \ -H 'sec-ch-ua: "Chromium";v="109", "Not_A Brand";v="99"' \ -H 'sec-ch-ua-mobile: ?0' \ -H 'sec-ch-ua-platform: "macOS"' \ -H 'sec-fetch-dest: empty' \ -H 'sec-fetch-mode: cors' \ -H 'sec-fetch-site: cross-site' \ -H 'user-agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36' \ -H 'x-authorization: token:qgemv4jr1y38jyq6vhvi' \ --data-raw '{"trans_type":"en2zh","source":"good"}' \ --compressed

对该内容进行转换

curlconverter.com/#go

image-20230115134114127

直接就生成代码了，对header进行一些修改即可使用

V1

package main
​
import (
  "fmt"
  "io/ioutil"
  "log"
  "net/http"
  "strings"
)
​
func main() {
  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) //创建请求，并未发起
  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() //defer是函数结束之后从下往上执行，这里是手动关闭流防止内存泄漏
  bodyText, err := ioutil.ReadAll(resp.Body) //读流
  if err != nil {
    log.Fatal(err)
  }
  fmt.Printf("%s\n", bodyText) //输出一长串json
}

v2

为输入数据创建结构体，便于序列化

package main
​
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)
  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)
}

然后解决reponse解析问题

response:

image-20230115175048257

上oktools.net/json2go json转go结构体

image-20230115175337603

将结构体添加到代码中并解析response

V3

package main
​
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"`
}
​
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() {
  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)
  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) //流读取response的body
  if err != nil {
    log.Fatal(err)
  }
  var dictResponse DictResponse
  err = json.Unmarshal(bodyText, &dictResponse) //对流进行json解构(json->结构体,bodyText->dictResponse)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Printf("%#v\n", dictResponse)
}

添加更详细的解析，命令行参数，以及返回状态值判断

V4

package main
​
import (
  "bytes"
  "encoding/json"
  "fmt"
  "io/ioutil"
  "log"
  "net/http"
  "os"
)
​
type DictRequest struct {
  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 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 { //循环打印里面的item
    fmt.Println(item)
  }
}
​
func main() {
  if len(os.Args) != 2 { //参数是不是两个（第一个是go程序，第二个是要查的单词）
    fmt.Fprintf(os.Stderr, `usage: simpleDict WORD
example: simpleDict hello
    `)
    os.Exit(1)
  }
  word := os.Args[1]
  query(word)
}

3.3 socks5代理

socks5原理图

socks5代理工作流程和原理

第一次发送请求，代理服务器会返回通讯方式，而后正常建立安全连接

auth用于第一步验证，connect用于后续请求

对各个字段用流一步一步取并进行判断

package main
​
import (
  "bufio"
  "context"
  "encoding/binary"
  "errors"
  "fmt"
  "io"
  "log"
  "net"
)
​
const socks5Ver = 0x05
const cmdBind = 0x01
const atypIPV4 = 0x01
const atypeHOST = 0x03
const atypeIPV6 = 0x04
​
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)
  err := auth(reader, conn)
  if err != nil {
    log.Printf("client %v auth failed:%v", conn.RemoteAddr(), err)
    return
  }
  err = connect(reader, conn)
  if err != nil {
    log.Printf("client %v auth failed:%v", conn.RemoteAddr(), err)
    return
  }
}
​
func auth(reader *bufio.Reader, conn net.Conn) (err error) {
  // +----+----------+----------+
  // |VER | NMETHODS | METHODS  |
  // +----+----------+----------+
  // | 1  |    1     | 1 to 255 |
  // +----+----------+----------+
  // VER: 协议版本，socks5为0x05
  // NMETHODS: 支持认证的方法数量
  // METHODS: 对应NMETHODS，NMETHODS的值为多少，METHODS就有多少个字节。RFC预定义了一些值的含义，内容如下:
  // X’00’ NO AUTHENTICATION REQUIRED
  // X’02’ USERNAME/PASSWORD
  //读出字段
  ver, err := reader.ReadByte()
  if err != nil {
    return fmt.Errorf("read ver failed:%w", err)
  }
  if ver != socks5Ver {
    return fmt.Errorf("not supported ver:%v", ver)
  }
  methodSize, err := reader.ReadByte()
  if err != nil {
    return fmt.Errorf("read methodSize failed:%w", err)
  }
  method := make([]byte, methodSize)
  _, err = io.ReadFull(reader, method)
  if err != nil {
    return fmt.Errorf("read method failed:%w", err)
  }
​
  // +----+--------+
  // |VER | METHOD |
  // +----+--------+
  // | 1  |   1    |
  // +----+--------+
  //直接返回
  _, err = conn.Write([]byte{socks5Ver, 0x00})
  if err != nil {
    return fmt.Errorf("write failed:%w", err)
  }
  return nil
}
​
func connect(reader *bufio.Reader, conn net.Conn) (err error) {
  // +----+-----+-------+------+----------+----------+
  // |VER | CMD |  RSV  | ATYP | DST.ADDR | DST.PORT |
  // +----+-----+-------+------+----------+----------+
  // | 1  |  1  | X'00' |  1   | Variable |    2     |
  // +----+-----+-------+------+----------+----------+
  // VER 版本号，socks5的值为0x05
  // CMD 0x01表示CONNECT请求
  // RSV 保留字段，值为0x00
  // ATYP 目标地址类型，DST.ADDR的数据对应这个字段的类型。
  //   0x01表示IPv4地址，DST.ADDR为4个字节
  //   0x03表示域名，DST.ADDR是一个可变长度的域名
  // DST.ADDR 一个可变长度的值
  // DST.PORT 目标端口，固定2个字节
  //读出字段
  buf := make([]byte, 4)
  _, err = io.ReadFull(reader, buf)
  if err != nil {
    return fmt.Errorf("read header failed:%w", err)
  }
  ver, cmd, atyp := buf[0], buf[1], buf[3]
  if ver != socks5Ver {
    return fmt.Errorf("not supported ver:%v", ver)
  }
  if cmd != cmdBind {
    return fmt.Errorf("not supported cmd:%v", ver)
  }
  addr := ""
  switch atyp {
  case atypIPV4:
    _, err = io.ReadFull(reader, buf)
    if err != nil {
      return fmt.Errorf("read atyp failed:%w", err)
    }
    addr = fmt.Sprintf("%d.%d.%d.%d", buf[0], buf[1], buf[2], buf[3])
  case atypeHOST:
    hostSize, err := reader.ReadByte()
    if err != nil {
      return fmt.Errorf("read hostSize failed:%w", err)
    }
    host := make([]byte, hostSize)
    _, err = io.ReadFull(reader, host)
    if err != nil {
      return fmt.Errorf("read host failed:%w", err)
    }
    addr = string(host)
  case atypeIPV6:
    return errors.New("IPv6: no supported yet")
  default:
    return errors.New("invalid atyp")
  }
  _, err = io.ReadFull(reader, buf[:2])
  if err != nil {
    return fmt.Errorf("read port failed:%w", err)
  }
  port := binary.BigEndian.Uint16(buf[:2])
​
  dest, err := net.Dial("tcp", fmt.Sprintf("%v:%v", addr, port))//建立tcp连接
  if err != nil {
    return fmt.Errorf("dial dst failed:%w", err)
  }
  defer dest.Close()
  log.Println("dial", addr, port)
​
  // +----+-----+-------+------+----------+----------+
  // |VER | REP |  RSV  | ATYP | BND.ADDR | BND.PORT |
  // +----+-----+-------+------+----------+----------+
  // | 1  |  1  | X'00' |  1   | Variable |    2     |
  // +----+-----+-------+------+----------+----------+
  // VER socks版本，这里为0x05
  // REP Relay field,内容取值如下 X’00’ succeeded
  // RSV 保留字段
  // ATYPE 地址类型
  // BND.ADDR 服务绑定的地址
  // BND.PORT 服务绑定的端口DST.PORT
  _, err = conn.Write([]byte{0x05, 0x00, 0x00, 0x01, 0, 0, 0, 0, 0, 0})
  if err != nil {
    return fmt.Errorf("write failed: %w", err)
  }
  ctx, cancel := context.WithCancel(context.Background())  //dd
  defer cancel()
​
  go func() {
    _, _ = io.Copy(dest, reader) //reader->dest 代理服务器发给目标服务器
    cancel()
  }()
  go func() {
    _, _ = io.Copy(conn, dest) //dest->conn 代理服务器返回给用户浏览器
    cancel()
  }()
​
  <-ctx.Done()//等待dd处执行完成，实现有一个方向出错退出程序
  return nil
}

4.总结

go语言简洁的设计哲学非常诱人，期待后续在字节青训营学到更多go技术栈的知识。

avatar
文章
阅读
粉丝