这是我参与「第三届青训营 -后端场」笔记创作活动的的第1篇笔记
Go语言基础
Go语言特性
- 高性能、高并发
- 语法简单
- 标准库丰富
- 完善的工具链
- 静态链接
- 快速编译
- 跨平台
- 垃圾回收
Go基础语法
输入输出
package main
import (
"fmt"
)
func main() {
fmt.Println("hello world")
}
// 使用命令行编译
// 第一种方式
// go run main.go
// 第二种方式
// go build main.go
// ./main
变量
//变量的定义类型后置
var a, b int = 1,2
//自动推导变量类型
var a="abc"
//常量自动推导类型
const a=50
const b= a/2
const a="abc"
//:=包括变量定义和初始化赋值，=只是赋值
c:= a+b
var c= a+b
条件语句
if num <0{
...
}else if num>10{
...
}else{
...
}
循环语句
for i := 0; i < 10; i++ {
fmt.Println(i)
}
切片（数组，类似python的list）
切片数据结构保存了数组的大小和一个执行数组的指针，当向切片添加元素的时候如果大小超过，就会对切片扩容之后再重新赋值
//第一种初始化赋值方式
a := make([]string, 3)
a[0] = "ab"
a[1] = "b"
a[2] = "c"
fmt.Println(a, len(a))
//第二种切片初始化赋值，切片变量传递的是引用
//传值，c=a，a保存的是对象的指针，赋值将a所指向的对象赋值并且把赋值额对象的地址传递给c
// 从而a和c指向的对象是不一样的，但是他们的数值是一样的对象
//传引用，c=a，a保存的是对象的指针，赋值将a所指向的指针赋值给c，从而c和a指向相同的对象
//传指针，int* c=&a, a保存对象的指针，c保存a变量的地址指针，从而形成c保存a变量地址
// 而a保存a所指向的对象的地址指针
c := make([]string, len(a))
copy(c, a)
fmt.Println(c, a)
d := a
d[0] = "a"
fmt.Println(a, d)
//第三种切片
f := []string{"abc", "e", "f"}
fmt.Println(f)
KV对（类似Python字典）
//第一种map创建方式，类似Java的hashmap，类似Python的dict，类似C++的unordered_map
mp1 := map[int]int{1: 1, 2: 2, 3: 3}
fmt.Println(mp1[1])
delete(mp1, 1)
fmt.Println(mp1)
//第二种创建map方式
mp2 := make(map[int]int)
mp2[1] = 1
mp2[2] = 2
fmt.Println(mp2)
//循环数组（切片）会返回下标和数值
nums := []int{1, 2, 3}
for i, num := range nums {
fmt.Println(i, num)
}
//循环map（字典）会返回key:value
for k, v := range mp2 {
fmt.Println(k, v)
}
函数
package main
import "fmt"
func add(a int, b int) (c int) {
return a + b
}
func get(a map[int]int, k int) (v int) {
return a[k]
}
func main() {
fmt.Println(add(1, 2))
fmt.Println(get(map[int]int{1: 1, 2: 2}, 1))
}
结构体
package main
import "fmt"
type user struct {
name string
pass string
}
//结构体方法，类似成员函数
func (u *user) check() bool {
return u.name == "abc"
}
func main() {
a := user{"abc", "123"}
b := user{}
b.name = "abc"
b.pass = "123"
fmt.Println(a, b)
fmt.Println(a.check())
}
错误处理
package main
import (
"errors"
"fmt"
)
type user struct {
name string
pass string
}
//结构体方法，类似成员函数
func checknil(users []user, name string) (*user, error) {
for _, u := range users {
if u.name == name {
return &u, nil
}
}
return nil, errors.New("not found")
}
func main() {
a := make([]user, 3)
a[0] = user{"abc", "123"}
a[1] = user{"cde", "123"}
a[2] = user{"fgh", "123"}
if _, err := checknil(a, "abe"); err != nil {
fmt.Println(err)
return
}
}
字符串操作
strings.Contain(a,"ll")
strings.Count(a, "l"）
strings.Index(a, "l")
strings.ToLower(a)
strings.ToUpper(a)
strings.Join([]string{"abc","bcd"}, "-")
strings.split(a,"-")
字符串格式化
结构体转Json和Json转结构体
package main
import (
"encoding/json"
"fmt"
)
type user struct {
Name string
Pass string
}
func main() {
a := make([]user, 3)
a[0] = user{"abc", "123"}
a[1] = user{"cde", "123"}
a[2] = user{"fgh", "123"}
buf, err := json.Marshal(a)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(buf))
buf, err = json.MarshalIndent(a, "", "\t")
fmt.Println(string(buf))
var b []user
err = json.Unmarshal(buf, &b)
fmt.Println(b)
}
时间处理
字符串转数字
f, _ := strconv.ParseFloat("123.123", 64)
fmt.Println(f)
n, _ := strconv.ParseInt("123", 10, 64)
fmt.Println(n)
Go项目
猜数字游戏
package main
import (
"bufio"
"fmt"
"math/rand"
"os"
"strconv"
"strings"
"time"
)
//猜数字游戏
func main() {
maxnum := 10
rand.Seed(time.Now().UnixNano())
secretNum := rand.Intn(maxnum)
fmt.Println(secretNum)
reader := bufio.NewReader(os.Stdin)
for {
//fmt.Println("input an integer")
row, _ := reader.ReadString('\n')
//fmt.Println(row)
input := strings.TrimSuffix(row, "\r\n")
//fmt.Println(input)
num, err := strconv.Atoi(string(input))
//fmt.Println(err)
//fmt.Println(num)
if num > secretNum {
fmt.Println("num>secretNum")
continue
} else if num < secretNum {
fmt.Println("num<secretNum")
continue
} else {
fmt.Println("correct ")
return
}
}
}
在线字典
package main
import (
"encoding/json"
"fmt"
"io/ioutil"
"log"
"net/http"
"os"
"strings"
)
type Info struct {
TransType string `json:"trans_type"`
Source string `json:"source"`
}
type JsonResponse 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() {
if len(os.Args) != 2 {
fmt.Fprintf(os.Stderr, "one parameter required")
os.Exit(1)
}
client := &http.Client{}
word := os.Args[1]
mydata := Info{"en2zh", word}
buf, _ := json.Marshal(mydata)
var data = strings.NewReader(string(buf))
req, err := http.NewRequest("POST", "https://api.interpreter.caiyunai.com/v1/dict", data)
if err != nil {
log.Fatal(err)
}
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("Connection", "keep-alive")
req.Header.Set("Content-Type", "application/json;charset=UTF-8")
req.Header.Set("Origin", "https://fanyi.caiyunapp.com")
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("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.54 Safari/537.36")
req.Header.Set("X-Authorization", "token:qgemv4jr1y38jyq6vhvi")
req.Header.Set("app-name", "xy")
req.Header.Set("os-type", "web")
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", "?0")
req.Header.Set("sec-ch-ua-platform", `"Windows"`)
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(resp.StatusCode)
}
var response JsonResponse
err = json.Unmarshal(bodyText, &response)
if err != nil {
log.Fatal(err)
}
//fmt.Printf("%s\n", bodyText)
//fmt.Printf("%#v\n", response)
fmt.Println(word, "UK:", response.Dictionary.Prons.En, "US:", response.Dictionary.Prons.EnUs)
for _, item := range response.Dictionary.Explanations {
fmt.Println(item)
}
}
Socket5代理服务器
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))
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
}
