從 defer 到泛型：掌握這十個 Go 技巧，寫出更專業的代碼
10 個提高生產力的 Go 編程技巧
在 Go 語言的日常開發中，我們常常會發現一些模式和技巧可以顯著提升代碼的質量和開發效率。這些技巧不僅能讓代碼更簡潔，還能幫助我們避免一些常見陷阱。
本文總結了 10 個實用的 Go 小技巧，涵蓋了性能優化、代碼組織、錯誤處理等多個方面，希望能對你的 Go 編程之旅有所幫助。
1. 利用 defer 優雅地處理計時和資源釋放
defer 語句是 Go 語言的強大特性，它可以在函數返回前執行指定的代碼，非常適合用于清理工作。通過巧妙地利用 defer，我們可以用一行代碼實現計時或資源的“準備-清理”模式。
1.1. 單行代碼實現函數計時
通過一個簡單的 TrackTime 函數，我們可以輕松地測量任何函數的執行時間。
package main
import(
"fmt"
"time"
)
// TrackTime 接收一個時間，計算并打印流逝的時間
funcTrackTime(pre time.Time){
elapsed := time.Since(pre)
fmt.Printf("函數執行耗時: %v\n", elapsed)
}
funcmain(){
// 只需要在函數開頭 `defer` 調用，就可以在函數結束時自動計時
deferTrackTime(time.Now())
// 模擬耗時操作
time.Sleep(500* time.Millisecond)
}
// 輸出: 函數執行耗時: 501.011ms1.2. “兩階段” defer 模式
這種模式利用了 defer 語句的惰性求值特性，讓你可以在一行代碼中同時完成準備（setup）和清理（teardown）工作。
package main
import"fmt"
// setupTeardown 返回一個清理函數
funcsetupTeardown()func(){
fmt.Println("運行初始化...")
returnfunc(){
fmt.Println("運行清理...")
}
}
funcmain(){
// 在一行代碼中完成初始化和清理的綁定
defersetupTeardown()()
fmt.Println("主函數執行中...")
}
// 輸出:
// 運行初始化...
// 主函數執行中...
// 運行清理...這種模式可以優雅地用于打開和關閉數據庫連接、獲取和釋放分布式鎖、設置和拆除測試環境等場景。
2. 預先分配切片容量
在創建切片時，如果我們能預先知道其大致容量，使用 make([]T, 0, capacity) 預分配內存可以顯著提升性能，避免后續 append 操作中頻繁的內存重新分配和拷貝。
// 推薦做法：預先分配容量
// 相比于 a := make([]int, 10)， b 擁有 10 的容量但長度為 0
b :=make([]int,0,10)
b =append(b,1)
// 錯誤做法：直接聲明長度并賦值，可能導致意外結果或性能問題
// a := make([]int, 10)
// a[0] = 1 // 這樣是正確的，但如果你想append，就不是最佳實踐了3. 鏈式調用（Fluent Interface）
通過讓方法的指針接收者返回自身，我們可以將多個方法調用鏈式地連接在一起，使得代碼更加流暢和可讀。
package main
import"fmt"
type Person struct{
Name string
Age int
}
// AddAge 方法返回修改后的 Person 指針
func(p *Person)AddAge()*Person {
p.Age++
return p
}
// Rename 方法返回修改后的 Person 指針
func(p *Person)Rename(name string)*Person {
p.Name = name
return p
}
funcmain(){
p :=&Person{Name:"Aiden", Age:35}
// 通過返回自身，可以進行鏈式調用
p.AddAge().Rename("煎魚")
fmt.Printf("更新后的 Person: %+v\n", p)
}
// 輸出: 更新后的 Person: &{Name:煎魚 Age:36}4. 編譯時檢查接口實現
在 Go 中，我們可以在編譯時利用一個小技巧來強制檢查一個類型是否正確地實現了某個接口。這可以防止因為拼寫錯誤或方法簽名不匹配導致的運行時錯誤。
package main
type Buffer interface{
Write(p []byte)(n int, err error)
}
type StringBuffer struct{}
// 注意：這里的 Writeee 方法名是錯誤的
func(s *StringBuffer)Writeee(p []byte)(n int, err error){
return0,nil
}
funcmain(){
// 這行代碼會在編譯時檢查 *StringBuffer 是否實現了 Buffer 接口
// 如果沒有，編譯器會立即報錯
var_ Buffer =(*StringBuffer)(nil)
}
// 輸出:
// # command-line-arguments
// ./main.go:12:8: cannot use (*StringBuffer)(nil) (value of type *StringBuffer) as Buffer value in variable declaration: *StringBuffer does not implement Buffer (missing method Write)5. Go 1.20+ 輕松將切片轉換為數組
在 Go 1.20 之后，將切片轉換為固定大小的數組變得非常簡單，無需使用復雜的指針轉換，使代碼更加清晰。
package main
import"fmt"
funcmain(){
a :=[]int{0,1,2,3,4,5}
b :=[3]int(a[0:3])// 使用字面值轉換
fmt.Println(b)
}
// 輸出: [0 1 2]6. 使用 _ 導入包進行初始化
在 Go 中，使用下劃線 _ 導入一個包，意味著你只希望執行該包的 init() 函數，而不會在代碼中使用該包的任何導出標識符。這對于在程序啟動時進行一些注冊或配置任務非常有用。
package main
import(
"fmt"
_"your_project/some_init_package"http:// _ 導入，只執行其 init 函數
)
funcmain(){
fmt.Println("主函數開始執行")
}
// your_project/some_init_package/some_init_package.go
package some_init_package
import"fmt"
funcinit(){
fmt.Println("這是一個只用于初始化的包...")
}
// 輸出:
// 這是一個只用于初始化的包...
// 主函數開始執行7. 使用 . 導入包名
點 . 操作符可以用于導入一個包，并將其所有導出的標識符直接暴露在當前包的命名空間中，無需使用包名作為前綴。雖然這可能會導致命名沖突，但在處理冗長包名或特定場景下非常便捷。
package main
import(
"fmt"
."math"http:// 使用 . 導入 math 包
)
funcmain(){
fmt.Println(Pi)// 無需寫 math.Pi
fmt.Println(Sin(Pi/2))// 無需寫 math.Sin
}
// 輸出:
// 3.141592653589793
// 18. Go 1.20+ 包裝多個錯誤
Go 1.20 引入的 errors.Join 函數讓處理多個并發或順序任務中的錯誤變得異常簡單。它能夠將多個錯誤包裝成一個錯誤鏈，并且可以用 errors.Is 和 errors.As 方便地檢查鏈中的每一個錯誤。
package main
import(
"errors"
"fmt"
)
var(
err1 = errors.New("第一個錯誤")
err2 = errors.New("第二個錯誤")
)
funcmain(){
// 將多個錯誤連接成一個錯誤鏈
err := errors.Join(err1, err2)
fmt.Println(err)// 打印: 第一個錯誤 第二個錯誤
fmt.Println(errors.Is(err, err1))// true
fmt.Println(errors.Is(err, err2))// true
}9. 泛型實現“三元運算符”
Go 語言沒有內置的三元運算符，但自從 Go 1.18 引入泛型后，我們可以輕松地自己實現一個。這使得一些簡單的條件賦值可以在一行代碼中完成，讓代碼更緊湊。
package main
import"fmt"
// Ter 是一個泛型三元運算符函數
func Ter[T any](cond bool, a, b T) T {
if cond {
return a
}
return b
}
funcmain(){
min :=Ter(1<2,1,2)
fmt.Println("較小的值是:", min)
}
// 輸出: 較小的值是: 110. 檢查接口是否為 nil 的正確姿勢
在 Go 語言中，一個接口的動態值和動態類型都為 nil 時，接口才真正為 nil。如果一個接口的值為 nil 但其動態類型不為 nil，它將不等于 nil。使用 reflect.ValueOf(x).IsNil() 是檢查一個接口值是否真正為 nil 的安全方法。
package main
import(
"fmt"
"reflect"
)
// IsNil 檢查接口是否真的為 nil
funcIsNil(x interface{})bool{
if x ==nil{
returntrue
}
v := reflect.ValueOf(x)
return v.Kind()== reflect.Ptr && v.IsNil()
}
funcmain(){
var x interface{}
var y *int=nil
x = y // 此時 x 的動態類型為 *int，動態值為 nil
// 錯誤的檢查方式，會輸出 "x != nil"
if x !=nil{
fmt.Println("x != nil")
}else{
fmt.Println("x == nil")
}
// 正確的檢查方式，會輸出 "x 是 nil"
ifIsNil(x){
fmt.Println("x 是 nil")
}else{
fmt.Println("x 不是 nil")
}
}
// 輸出:
// x != nil
// x 是 nil
