这是我参与「第五届青训营 」笔记创作活动的第1天。
刚注意到这个赚青豆的活动，把之前上课记的笔记贴上来。
Go语言基础语法学习
变量定义
- f := float32(3.44)
- var a int = 5
- var s = "str"
- const c = 1000
for 循环
for i := 0; i <= 5; i++ {
fmt.Println(i)
}
for {
fmt.Println("loop")
break
}
//i := 0; i <= 5; i++ 任意一个可省略
switch语句
与C不同，Go的switch语句不加break也不会顺序执行，且case表达式不受限，功能很强大
t := time.Now()
fmt.Println(t)
switch {
case t.Hour() < 12:
fmt.Println("上午")
case t.Hour() > 12:
fmt.Println("下午")
}
switch a{
case 1:
fmt.Println("1")
case 2:
fmt.Println("2")
default:
fmt.Println("other")
}
数组
var a[5]int
a[3] = 3
fmt.Println(a[3], len(a))
b := [4]int{1,2,3,4}
fmt.Println(b)
var twod [2][3]int
与C++定义方法有略微差别。由于数组长度固定，实际开发中更多使用切片
切片
用 s := make([]string, 3) 来创建切片
用 s = append(s, "d") 来对切片扩容，注意此表达式的返回值才是扩容后的切片(类似Python)
len(s)是扩容后的数值，可以用copy()来拷贝切片，例如：
s := make([]string, 3)
s[0] = "a"
s[1] = "b"
s[2] = "c"
s = append(s, "d")
s = append(s, "e")
c := make([]string, 3)
copy(c, s)
拷贝后c为"abc"，注意拷贝时两切片的长度。为确保不出错，应尽量使用以下语句拷贝：
c := make([]string, len(s))
copy(c, s)
有许多类似Python的切片操作
fmt.Println(s[2:5])
fmt.Println(s[:5])
fmt.Println(s[2:])
输出分别为
[c d e]
[a b c d e]
[c d e]
注意不支持负数索引
map
构造方法：m := make(map[string]int) m2 := map[string]int{"one": 1, "two": 2} var m3 = map[string]int{"one": 1, "two": 2}
string是此key-value对中key的类型，int是value的类型
m["one"] = 1来设置k-v对
map的索引返回值有两个，一个是value，一个是bool类型的是否有value
例如：
m := make(map[string]int)
m["one"] = 1
m["two"] = 2
fmt.Println(m)
fmt.Println(len(m))
fmt.Println(m["ccc"])
v, ok := m["ccc"]
fmt.Println(v, ok)
输出：0, false
delete(m, "one")用于删除键值对
注意map完全无序
range
可以用于遍历数组、切片及字典等，示例如下：
nums := []int{1, 2, 3, 4}
sum := 0
for i, num := range nums {
sum += num
fmt.Println(i, sum)
}
//不需要数组的索引，用下划线忽略
for _, num := range nums {
sum += num
}
m := map[string]int{"a": 1, "b": 2}
for k, v := range m {
fmt.Println(k, v)
}
//只需要key
for k := range m {
fmt.Println("key", k)
}
函数
Golang的变量类型都是后置的，且函数原生支持返回多个值，实际业务逻辑代码中几乎所有的函数都返回多个值，一个是真正的结果，一个是错误信息。例子如下：
func add(a int, b int) int {
return a+b
}
func add1(a, b int) int {
return a + b
}
func exists(m map[string]int, k string) (v int, ok bool) {
v, ok = m[k]
return v, ok
}
指针
go也支持指针，但相较于C、C++，指针的操作很有限，主要用途是对传入参数进行修改，例子如下：
func add3(n *int) {
*n += 2
}
func main() {
n := 5
add3(&n)
fmt.Println(n)
}
注意调用的时候为了类型匹配要加&
结构体
结构体的构造
结构体是带类型的字段的集合
type user struct {
name string
pwd string
}
func main() {
a := user{
name: "yang",
pwd: "9550",
}
b := user{"ma", "6990"}
c := user{name: "wang"}
c.pwd = "1024"
var d user
d.name = "wang"
d.pwd = "1024"
fmt.Println(a, b, c, d)
fmt.Println(checkPassword(&a, "1111"))
changePwd(&a, "1111")
fmt.Println(a)
}
func checkPassword(u *user, pwd string) bool {
return u.pwd == pwd
}
func changePwd(u *user, pwd string) {
u.pwd = pwd
}
用结构体指针做函数参数与C++用引用做函数参数作用一致，即可以实现对结构体的修改且避免一些大结构体的拷贝开销
结构体方法
类似于其他语言的类成员函数，这里将普通函数的第一个参数(结构体或结构体指针类型)加上括号写到函数名前，就可以通过a.checkPassword("xx")来调用。带指针可以直接在函数中对结构体进行修改，不带就相当于拷贝操作，无法修改。
示例如下：
type user struct {
name string
pwd string
}
func main() {
a := user{
name: "yang",
pwd: "9550",
}
b := user{"ma", "6990"}
c := user{name: "wang"}
c.pwd = "1024"
var d user
d.name = "wang"
d.pwd = "1024"
fmt.Println(a, b, c, d)
fmt.Println(a.checkPassword("1111"))
a.changePwd("1111")
fmt.Println(a)
}
func (u *user) checkPassword(pwd string) bool {
return u.pwd == pwd
}
func (u *user) changePwd(pwd string) {
u.pwd = pwd
}
错误处理
go函数可以返回多个值，前文中也提到了实际开发中多返回两个值，其中一个为错误信息。这样可以很清晰的知道哪个函数返回了错误，并且可以使用简单的if-else进行处理。
在函数的返回值类型里面，要接收错误信息的参数后加一个error就代表这个函数可能会返回错误。
写返回值时可以自定义错误信息 errors.New("not found")。
示例代码如下：
func findUsers(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 := findUsers([]user{{"yang", "9550"}}, "yang")
if err != nil {
fmt.Println(err)
return
}
fmt.Println(u.name)//yang
if u, err := findUsers([]user{{"yang", "9550"}}, "ma"); err != nil {
fmt.Println(err)//not found
return
} else {
fmt.Println(u.name)
}
}
字符串
常用字符串操作
使用常用的字符串操作需要导入包 strings ，示例代码如下：
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
字符串格式化
可以使用类似C语言的printf函数，但是格式化简单，可以使用%v来打印任意类型的变量，可以使用%+v打印详细结果，%#v更详细。示例代码如下：
s := "hello"
n := 123
p := point{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}
JSON处理
需要使用encoding/json包将结构体字段的第一个字母大写，这个结构体就可以使用JSON.marshaler序列化，变成JSON字符串，序列化之后的字符串可以使用JSON.unmarshaler反序列化到一个空变量中。示例代码如下：
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))
/*
{
"Name": "wang",
"age": 18,
"Hobby": [
"Golang",
"TypeScript"
]
}
*/
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"}}
}
时间处理
需要使用time包。time.Now()获取当前时间；time.Date()构造一个带时区的时间；time.Sub()得到时间差；time.Unix()得到系统时间戳。示例代码如下：
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
2006-01-02 15:04:05表示时间格式，等同于其他语言中的yyyy-mm-dd...这个时间是写在官方文档中的。
数字解析
字符串与数字类型之间的转换全都在strconv包中。若输入不合法，相关函数均会返回error
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
进程信息
需要os包与os/exec包。可以使用os.argv得到程序执行时的命令行参数(所在目录等信息)。os.Getenv来获取环境变量，os.Setenv来设置环境变量。示例代码如下：
// 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
实战
猜数游戏
读取用户输入
需要bufio包，输入方法与Java类似，示例代码如下：
//设置输入流
reader := bufio.NewReader(os.Stdin)
//读取用户输入
input, err := reader.ReadString('\n')
//输入异常处理
if err != nil {
fmt.Println("输入错误", err)
return
}
项目总体代码：
import (
"bufio"
"fmt"
"math/rand"
"os"
"strconv"
"strings"
"time"
)
func main() {
maxNum := 100
//用程序启动时的时间戳初始化随机数种子
rand.Seed(time.Now().UnixNano())
//Intn设置最大值
sNum := rand.Intn(maxNum)
fmt.Println(sNum)
//设置输入流
reader := bufio.NewReader(os.Stdin)
for {
//读取用户输入
input, err := reader.ReadString('\n')
//输入异常处理
if err != nil {
fmt.Println("输入错误", err)
//输入错误就再来一次循环，因此continue
continue
}
//去除\r\n(我的会自动加一个\r??)
input = strings.TrimSuffix(input, "\r\n")
//字符串转数字
guess, err := strconv.Atoi(input)
//异常处理
if err != nil {
fmt.Println("输入非整数！请输入整数")
continue
}
//猜数与实际数对比
if guess > sNum {
fmt.Println("猜大了")
} else if guess < sNum {
fmt.Println("猜小了")
} else {
fmt.Println("恭喜你猜对了！")
break
}
}
}
在线词典
用了两个网站：
package main
import (
"bytes"
"encoding/json"
"fmt"
"io"
"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{}
//reader := bufio.NewReader(os.Stdin)
//word, err := reader.ReadString('\n')
//if err != nil {
// log.Fatal(err)
//}
//word = strings.TrimSuffix(word, "\r\n")
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("authority", "api.interpreter.caiyunai.com")
req.Header.Set("accept", "application/json, text/plain, */*")
req.Header.Set("accept-language", "zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6")
req.Header.Set("app-name", "xy")
req.Header.Set("cache-control", "no-cache")
req.Header.Set("content-type", "application/json;charset=UTF-8")
req.Header.Set("device-id", "")
req.Header.Set("origin", "https://fanyi.caiyunapp.com")
req.Header.Set("os-type", "web")
req.Header.Set("os-version", "")
req.Header.Set("pragma", "no-cache")
req.Header.Set("referer", "https://fanyi.caiyunapp.com/")
req.Header.Set("sec-ch-ua", `"Not_A Brand";v="99", "Microsoft Edge";v="109", "Chromium";v="109"`)
req.Header.Set("sec-ch-ua-mobile", "?0")
req.Header.Set("sec-ch-ua-platform", `"Windows"`)
req.Header.Set("sec-fetch-dest", "empty")
req.Header.Set("sec-fetch-mode", "cors")
req.Header.Set("sec-fetch-site", "cross-site")
//发起请求
resp, err := client.Do(req)
if err != nil {
log.Fatal(err)
}
//defer 关闭流，防止内存泄露
defer resp.Body.Close()
//将流读到内存中
bodyText, err := io.ReadAll(resp.Body)
if err != nil {
log.Fatal(err)
}
//校验状态码
if resp.StatusCode != 200 {
log.Fatal("bad StatusCode:", resp.StatusCode, "body", string(bodyText))
}
//fmt.Printf("%s\n", bodyText)
var dictResponse DictResponse
err = json.Unmarshal(bodyText, &dictResponse)
if err != nil {
log.Fatal(err)
}
//fmt.Printf("%#v\n", dictResponse)
fmt.Println(word,
"UK:", dictResponse.Dictionary.Prons.En,
"US:", dictResponse.Dictionary.Prons.EnUs)
fmt.Println("释义：")
for _, item := range dictResponse.Dictionary.Explanations {
fmt.Println(item)
}
fmt.Println("用法：")
for _, uses := range dictResponse.Dictionary.WqxExample {
fmt.Println(uses)
}
}
func main() {
if len(os.Args) != 2 {
fmt.Fprintf(os.Stderr, `usage: simpleDict WORD`)
os.Exit(1)
}
word := os.Args[1]
query(word)
}
SOCKS5代理
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
}
