GO语言实践
猜数字
代码思路：
- 使用随机函数产生需要猜测的数字；
- 获取用户的输入；
- 撰写判断逻辑，将用户输入与目标数字进行比较。
产生随机数
使用随机函数rand
问题：每次输出的数字一样
原因：没有设置随机种子
使用时间为随机种子，产生随机数
package main
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)
}
获取用户的输入，判断输入与目标值的大小关系
使用bufio获取用户的输入， bufio是带缓存的I/O读写操作，将文件读入缓存，再从缓存中获取输入。
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("Invaild 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!")
}
}
使用循环完成多轮的猜数
使用for循环，当猜测的数与目标值一致时，跳出循环。
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)
return
}
input = strings.Trim(input, "\r\n")
guess, err := strconv.Atoi(input)
if err != nil {
fmt.Println("Invaild 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!")
break
}
}
}
词典
使用给第三方的API发送请求，并使用命令行调用程序实现查词。
代码思路：
- 通过浏览器获得请求的curl数据，并将其转换为go lang；
- 将返回的json格式数据转换为go lang；
- 将固定的word部分转为可与用户交互的变量，实现字典查询。
抓包
将请求转为curl：curlconverter.com/go/
curl "<https://api.interpreter.caiyunai.com/v1/dict>" --compressed -X POST -H "User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/115.0" -H "Accept: application/json, text/plain, */*" -H "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" -H "Accept-Encoding: gzip, deflate, br" -H "Content-Type: application/json;charset=utf-8" -H "X-Authorization: token:qgemv4jr1y38jyq6vhvi" -H "app-name: xy" -H "version: 1.8.0" -H "os-type: web" -H "os-version: " -H "device-id: eb794d55b097e1d775613256dffeeb39" -H "Origin: <https://fanyi.caiyunapp.com>" -H "Connection: keep-alive" -H "Referer: <https://fanyi.caiyunapp.com/>" -H "Sec-Fetch-Dest: empty" -H "Sec-Fetch-Mode: cors" -H "Sec-Fetch-Site: cross-site" -H "TE: trailers" --data-raw "{""trans\_type"":""en2zh"",""source"":""good""}"
转化后的go：
package main
import (
"fmt"
"io"
"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("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/115.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("device-id", "eb794d55b097e1d775613256dffeeb39")
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 := io.ReadAll(resp.Body)
if err != nil {
log.Fatal(err)
}
fmt.Printf("%s\n", bodyText)
}
代码分析：
- http.NewRequest：产生http请求
- defer resp.Body.Close()：获取返回，手动关闭牛，防止泄露。函数结束后，调用close。
- bodyText, err := io.ReadAll(resp.Body)：将相应读入内存
对响应的json进行转换
进入网站 oktools.net/json2go，将网页中的相应转为json格式
定义结构体，将json格式的数据输入结构体中
通过fmt输出仅想要得到的内容
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)
}
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
//反序列化response
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 main() {
if len(os.Args) != 2 {
fmt.Fprintf(os.Stderr, \`usage: simpleDict WORD example: simpleDict hello\`)
os.Exit(1)
}
word := os.Args\[1]
query(word)
}
Marshal：将json转化为一个数组
代理socks5
代理的工作流程：
逻辑分析：
- 协商阶段：用户向代理服务器发送报文，包括协议版本号认证的种类；
- 认证流程：通信过程是否加密；
- 请求阶段：用户向发送代理请求，请求代理服务器与服务器建立连接；代理和服务器建立真正的连接；
- rely阶段：代理收到请求或响应，并进行转发。
代码思路：
- TCP echo server：
- 监听端口
- 接受连接
- 使用process函数处理连接
- auth：浏览器向代理服务器发送报文
- 读报文
- 判断版本号
- 返回浏览器选择的建立方式
- connection：浏览器发送报文，请求代理服务器与服务器建立连接
- 获取需要连接服务器的地址和端口号
- 与真正的服务器建立连接：
- dial：使用tcp，通过端口和域名建立连接
- copy函数实现单向数据转发
- 通过两个函数调用copy函数，将数据拷贝到浏览器和服务器
技巧：对报文固定长度的段进行切片处理，可以减少网络带宽和存储的消耗。
package main
import (
"bufio"
"context"
"encoding/binary"
"errors"
"fmt"
"io"
"log"
"net"
)
const socks5Ver = 0x05
const cmdBind = 0x01
const atypeIPV4 = 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个字节
//创建长度为4的缓冲区，直接读取前面4个字段
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", cmd)
}
addr := "
switch atyp {
case atypeIPV4:
\_, 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))
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())
defer cancel()
go func() {
\_, \_ = io.Copy(dest, reader)
cancel()
}()
go func() {
\_, \_ = io.Copy(conn, dest)
cancel()
}()
<-ctx.Done()
return nil
}
