Go

Go Style Decisions - Pass values

Go Style Decisions - Pass values Do not pass pointers as function arguments just to save a few bytes. If a function reads its argument x only as *x throughout, then the argument shouldn’t be a pointer. Common instances of this include passing a pointer to a string (*string) or a pointer to an interface value (*io.Reader). In both cases, the value itself is a fixed size and can be passed directly.

Saturday, April 13, 2024 Read

GO Generic 入門筆記

GO Generic 入門筆記自定義約束 // Addable只允許int 或 float64類型 type Addable interface { int | float64 } func Add[T Addable](a, b T) T { return a + b } ~ 符號的作用 ~ 符號用于表示與指定类型有相同底層類型的所有類型。當你在類型參數的约束中使用 ~ 符號時，你指定了一個類型集合，這個集合包含所有底層類型與约束中指定的類型相同的類型。 type MyInt int type YourInt int func PrintInt[T ~int](t T) { fmt.Println(t) } func main() { var a int = 5 var b MyInt = 10 var c YourInt = 15 PrintInt(a) PrintInt(b) PrintInt(c) }

Wednesday, February 7, 2024 Read

Golang tips

GO 编程模式：切片，接口，时间和性能 Go 语言是一个高性能的语言，但并不是说这样我们就不用关心性能了，我们还是需要关心的。下面是一个在编程方面和性能相关的提示。如果需要把数字转字符串，使用 strconv.Itoa() 会比 fmt.Sprintf() 要快一倍左右尽可能地避免把 String 转成[]Byte 。这个转换会导致性能下降。如果在 for-loop 里对某个 slice 使用 append()请先把 slice 的容量很扩充到位，这样可以避免内存重新分享以及系统自动按 2 的 N 次方幂进行扩展但又用不到，从而浪费内存。使用 StringBuffer 或是 StringBuild 来拼接字符串，会比使用 + 或 += 性能高三到四个数量级。尽可能的使用并发的 go routine，然后使用 sync.WaitGroup 来同步分片操作避免在热代码中进行内存分配，这样会导致 gc 很忙。尽可能的使用 sync.Pool 来重用对象。使用 lock-free 的操作，避免使用 mutex，尽可能使用 sync/Atomic 包。（关于无锁编程的相关话题，可参看《无锁队列实现》或《无锁 Hashmap 实现》）使用 I/O 缓冲，I/O 是个非常非常慢的操作，使用 bufio.NewWrite() 和 bufio.NewReader() 可以带来更高的性能。对于在 for-loop 里的固定的正则表达式，一定要使用 regexp.Compile() 编译正则表达式。性能会得升两个数量级。如果你需要更高性能的协议，你要考虑使用 protobuf 或 msgp 而不是 JSON，因为 JSON 的序列化和反序列化里使用了反射。你在使用 map 的时候，使用整型的 key 会比字符串的要快，因为整型比较比字符串比较要快。

Tuesday, September 26, 2023 Read

Go Patterns

Go Patterns go-design-pattern

Saturday, September 16, 2023 Read

channel 的 15 条规则和底层实现

channel 的 15 条规则和底层实现操作规则操作 nil 已关闭的 channel 未关闭有缓冲区的 channel 未关闭无缓冲区的 channel 关闭 panic panic 成功关闭，然后可以读取缓冲区的值，读取完之后，继续读取到的是 channel 类型的默认值成功关闭，之后读取到的是 channel 类型的默认值接收阻塞不阻塞，读取到的是 channel 类型的默认值不阻塞，正常读取值阻塞发送阻塞 panic 不阻塞，正常写入值阻塞编译规则操作 channel 類型結果接收只写 channel 编译错误发送只读 channel 编译错误关闭只读 channel 编译错误

Thursday, June 22, 2023 Read

使用Go语言解析二进制数据踩坑总结

使用 Go 语言解析二进制数据踩坑总结 for { buf := make([]byte, bufSize) n, err := r.Read(buf) if err == io.EOF { return } else if err != nil { aerr.Store(err) return } ch <- buf[:n] } 当 err 的值为 io.EOF 时直接返回了。这是最可能出问题的地方。仔细阅读函数文档发现： Callers should always process the n > 0 bytes returned before considering the error err. Doing so correctly handles I/O errors that happen after reading some bytes and also both of the allowed EOF behaviors. 所以程序必须先处理 n > 0 的情况，然后再处理 err != nil 的情况！这跟我之前的印象不相符。因为一般来说，当 err 非空时，前面的返回数据一般都是空值。但 io.Reader 并不是这样。

Friday, January 20, 2023 Read

Go 使用 selenium 截图

Go 使用 selenium 截图 package main import ( "fmt" log "github.com/sirupsen/logrus" "github.com/tebeka/selenium" "io/ioutil" ) const ( chromeDriverPath = "/usr/local/bin/chromedriver" port = 9515 ) func main() { var opts []selenium.ServiceOption selenium.SetDebug(false) service, err := selenium.NewChromeDriverService(chromeDriverPath, port, opts...) if err != nil { panic(err) // panic is used only as an example and is not otherwise recommended. } defer service.Stop() caps := selenium.Capabilities{"browserName": "chrome"} // 整页截屏 // 获取到网页的宽高，然后把浏览器的窗口设置成这么大，然后再截图就好了！需要注意的是只有 headless 模式可以任意设置窗口大小，否则最大高度不能超过你的显示器分辨率 // chromeCaps := chrome.Capabilities{ // Path: "", // Args: []string{ // "--headless", // }, // } // caps.AddChrome(chromeCaps) wd, err := selenium.NewRemote(caps, fmt.Sprintf("http://localhost:%d/wd/hub", port)) if err != nil { panic(err) } defer wd.Quit() // 在 selenium 中使用ExecuteScript就可以执行 JavaScript 代码，需要注意返回值是 interface，所以要类型断言成 float，然后再转成 int // height, _ := wd.ExecuteScript("return document.body.parentNode.scrollHeight", nil) // var realHeight = int(height.(float64)) // 然后我们需要设置窗口大小 // wd.ResizeWindow("", 1920, realHeight) if err := wd.Get("https://github.com/tgbot-collection/archiver"); err != nil { panic(err) } screenshot, err := wd.Screenshot() if err != nil { log.Errorln(err) } ioutil.WriteFile("screenshot.png", screenshot, 0644) } 整页截屏获取到网页的宽高，然后把浏览器的窗口设置成这么大，然后再截图就好了！需要注意的是只有 headless 模式可以任意设置窗口大小，否则最大高度不能超过你的显示器分辨率

Friday, December 2, 2022 Read

善用 Go Fuzzing，幫助你寫出更完整的單元測試

善用 Go Fuzzing，幫助你寫出更完整的單元測試 func Pow(base uint, exponent uint) uint { if exponent == 0 { return 1 } return base * Pow(base, exponent-1) } func FuzzPow(f *testing.F) { f.Fuzz(func(t *testing.T, x, y uint) { assert := assert.New(t) assert.Equal(Pow(x, 0), uint(1)) assert.Equal(Pow(x, 1), x) assert.Equal(Pow(x, 2), x*x) if x > 0 && y > 0 { assert.Equal(Pow(x, y)/x, Pow(x, y-1)) } }) } go test -fuzz=Fuzz -fuzztime 20s 在做 Fuzzing Test 的時候如果跑一跑 FAIL 了，Go 會幫忙把那組 input 記在 testcase/ 裡面看了之後會發現在 x=6、y=30 時 assert 會失敗，也就是說 pow(6, 30)/6 不會等於 pow(6, 29)。但這也太奇怪了吧？仔細實驗之後才發現是因為在計算 pow(6, 30) 的時候會發生 overflow。因為 Go 定義的 max.MaxUint 大約是 18 * 10¹⁸，但 6²⁹ 大概是 7 * 10¹⁸。如果把 6²⁹ 再乘上 6，就會發生 overflow 得到 8 * 10¹⁸，很像繞了操場兩圈結果在跟原本差不多的位置。 var ErrOverflow = fmt.Errorf("overflow") func Pow(base uint, exponent uint) (uint, error) { if exponent == 0 { return 1 } prevResult, err := Pow(base, exponent-1) if math.MaxUint/base < prevResult { return 0, ErrOverflow } return base * prevResult, nil } func FuzzPow(f *testing.F) { f.Fuzz(func(t *testing.T, x, y uint) { assert := assert.New(t) if result, err := Pow(x, 1); err != ErrOverflow { assert.Equal(result, x) } if result, err := Pow(x, y); x > 0 && y > 0 && err != ErrOverflow { resultDivX, _ := Pow(x, y-1) assert.Equal(result/x, resultDivX) } }) }

Thursday, November 3, 2022 Read

Go string format

Go string format Go 语言 fmt.Printf 使用指南 The verb at the end defines the type and the interpretation of its corresponding argument. d - decimal integer o - octal integer O - octal integer with 0o prefix b - binary integer x - hexadecimal integer lowercase X - hexadecimal integer uppercase f - decimal floating point, lowercase F - decimal floating point, uppercase e - scientific notation (mantissa/exponent), lowercase E - scientific notation (mantissa/exponent), uppercase g - the shortest representation of %e or %f G - the shortest representation of %E or %F c - a character represented by the corresponding Unicode code point q - a quoted character U - Unicode escape sequence t - the word true or false s - a string v - default format #v - Go-syntax representation of the value T - a Go-syntax representation of the type of the value p - pointer address % - a double %% prints a single % Go string format indexing package main import ( "fmt" ) func main() { n1 := 2 n2 := 3 n3 := 4 res := fmt.Sprintf("There are %d oranges %d apples %d plums", n1, n2, n3) fmt.Println(res) // There are 2 oranges 3 apples 4 plums res2 := fmt.Sprintf("There are %[2]d oranges %d apples %[1]d plums", n1, n2, n3) fmt.Println(res2) // There are 3 oranges 4 apples 2 plums } Go string format precision package main import ( "fmt" ) func main() { fmt.Printf("%0.f\n", 16.540) // 17 fmt.Printf("%0.2f\n", 16.540) // 16.54 fmt.Printf("%0.3f\n", 16.540) // 16.540 fmt.Printf("%0.5f\n", 16.540) // 16.54000 } Go string format flags package main import ( "fmt" ) func main() { fmt.Printf("%+d\n", 1691) // +1691 fmt.Printf("%#x\n", 1691) // 0x69b fmt.Printf("%#X\n", 1691) // 0X69B fmt.Printf("%#b\n", 1691) // 0b11010011011 fmt.Printf("%10d\n", 1691) // 1691 fmt.Printf("%-10d\n", 1691) // 1691 fmt.Printf("%010d\n", 1691) // 0000001691 } Go string format width package main import ( "fmt" ) func main() { w := "falcon" n := 122 h := 455.67 fmt.Printf("%s\n", w) // falcon fmt.Printf("%10s\n", w) // falcon fmt.Printf("%d\n", n). // 122 fmt.Printf("%7d\n", n) // 122 fmt.Printf("%07d\n", n) // 0000122 fmt.Printf("%10f\n", h) // 455.670000 fmt.Printf("%11f\n", h) // 455.670000 fmt.Printf("%12f\n", h) // 455.670000 }

Thursday, September 8, 2022 Read

為你的Go應用建立輕量級Docker映象？ | IT人

為你的 Go 應用建立輕量級 Docker 映象？ | IT 人 go build # default $ go build -o test1 main.go $ du -sh test1 14M test1 # 在程式編譯的時候可以加上 `-ldflags "-s -w"` 引數來優化編譯，原理是通過去除部分連結和除錯等資訊來減小編譯生成的可執行程式體積，具體引數如下： # -a：強制編譯所有依賴包 # -s：去掉符號表資訊，不過 panic 的時候 stack trace 就沒有任何檔名/行號資訊了 # -w：去掉 DWARF 除錯資訊，不過得到的程式就不能使用 gdb 進行除錯了 # 若對符號表無需求，-ldflags 直接新增 "-s" 即可 # 注：不建議-w和-s同時使用 $ go build -ldflags "-s -w" -o test2 main.go $ du -sh test2 11M test2 upx(brew/yum install upx) $ upx test2 Ultimate Packer for eXecutables Copyright (C) 1996 - 2020 UPX 3.96 Markus Oberhumer, Laszlo Molnar & John Reiser Jan 23rd 2020 File size Ratio Format Name -------------------- ------ ----------- ----------- 11490768 -> 4063248 35.36% macho/amd64 test2 Packed 1 file. $ upx --brute test2 $ du -sh test2 4.6M test2 upx 的壓縮選項

Monday, July 25, 2022 Read

[Golang] 利用build tags達到不同的build config

[Golang] 利用 build tags 達到不同的 build config Go build -ldflags package main import ( "fmt" ) var flagString string func main() { fmt.Println("This build with ldflag:", flagString) } $ go build -ldflags '-X main.flagString "test"' $ ./main This build with ldflag: test Go build -tags debug_config.go //+build debug package main var TestString string = "test debug" var TestString2 string = " and it will run every module with debug tag." func GetConfigString() string { return "it is debug....." } //+build debug 前後需要一個空行(除非你在第一行) release_config.go //+build !debug package main var TestString string = "test release" var TestString2 string = " and it will run every module as no debug tag." func GetConfigString() string { return "it is release....." } main package main import ( "fmt" ) func main() { fmt.Println("This build is ", TestString, TestString2, GetConfigString()) } $ go build -tags debug . $ ./main This build is test debug and it will run every module with debug tag. it is debug..... $ go build . $ ./main This build is test release and it will run every module as no debug tag. it is release.....

Monday, July 18, 2022 Read

Go embed 简明教程

Go embed 简明教程嵌入对于单个的文件，支持嵌入为string和 []byre 对于多个文件和文件夹，支持嵌入为新的文件系统 FS 比如导入 “embed” 包，即使无显式的使用 go:embed 指令用来嵌入，必须紧跟着嵌入后的变量名只支持嵌入为 string, []byte 和 embed.FS 三种类型，这三种类型的别名(alias)和命名类型(如 type S string)都不可以使用的是相对路径 string/[]byte package main import ( _ "embed" "fmt" ) //go:embed hello.txt var s string //go:embed hello.txt var b []byte func main() { fmt.Println(s) fmt.Println(b) } embed.FS package main import ( "embed" "fmt" ) //go:embed hello.txt hello2.txt //go:embed "p/he llo.txt" //go:embed `p/hello-2.txt` //go:embed dir var f embed.FS func main() { data, _ := f.ReadFile("hello.txt") fmt.Println(string(data)) data, _ = f.ReadFile("hello2.txt") fmt.Println(string(data)) data, _ := f.ReadFile("p/he llo.txt") fmt.Println(string(data)) data, _ = f.ReadFile("p/hello-2.txt") fmt.Println(string(data)) } 匹配模式 go:embed 指令中可以只写文件夹名，此文件夹中除了.和_开头的文件和文件夹都会被嵌入，并且子文件夹也会被递归的嵌入，形成一个此文件夹的文件系统。

Tuesday, July 12, 2022 Read