https://go.dev/doc/go1.8

Go 1.8 值得關(guān)注的改動(dòng)：

1. 結(jié)構(gòu)體轉(zhuǎn)換忽略標(biāo)簽 (struct tags) ：Go 1.8 起，在顯式轉(zhuǎn)換兩個(gè)結(jié)構(gòu)體類型時(shí)，字段標(biāo)簽 (field tags) 會(huì)被忽略，只要底層字段類型和順序一致即可轉(zhuǎn)換。
2. yacc 工具移除 ：Go 1.8 移除了 go tool yacc，該工具已不再被 Go 編譯器使用，并已遷移至 golang.org/x/tools/cmd/goyacc。
3. 編譯器工具鏈更新 ：Go 1.8 將基于 靜態(tài)單賦值形式 (Static Single Assignment form, SSA) 的新編譯器后端推廣至所有支持的 CPU 架構(gòu)，帶來了更優(yōu)的代碼生成、更好的優(yōu)化基礎(chǔ)（如邊界檢查消除）以及顯著的性能提升（尤其在 32 位 ARM 上提升 20-30%）。同時(shí)引入了新的編譯器前端，并提升了編譯和鏈接速度（約 15%）。
4. 默認(rèn) GOPATH 與 go get 行為變更 ：如果 GOPATH 環(huán)境變量未設(shè)置，Go 1.8 會(huì)為其提供一個(gè)默認(rèn)值（Unix 上為 $HOME/go，Windows 上為 %USERPROFILE%/go）。go get 命令現(xiàn)在無論是否使用 -insecure 標(biāo)志，都會(huì)遵循 HTTP 代理相關(guān)的環(huán)境變量。
5. 實(shí)驗(yàn)性插件 (Plugins) 支持 ：Go 1.8 引入了對(duì)插件的初步支持，提供了新的 plugin 構(gòu)建模式和用于運(yùn)行時(shí)加載插件的 plugin 包（目前僅限 Linux）。
6. sort 包新增便捷函數(shù) ：sort 包添加了 Slice 函數(shù)，允許直接對(duì)切片使用自定義的比較函數(shù)進(jìn)行排序，簡(jiǎn)化了排序操作。同時(shí)新增了 SliceStable 和 SliceIsSorted。

下面是一些值得展開的討論：

結(jié)構(gòu)體轉(zhuǎn)換時(shí)忽略字段標(biāo)簽 (Struct Tags)

Go 1.8 引入了一個(gè)語言規(guī)范上的變化：在進(jìn)行顯式的結(jié)構(gòu)體類型轉(zhuǎn)換時(shí)，編譯器將不再考慮結(jié)構(gòu)體字段的標(biāo)簽 (tags)。這意味著，如果兩個(gè)結(jié)構(gòu)體類型僅僅是字段標(biāo)簽不同，而字段的名稱、類型和順序完全相同，那么它們之間可以進(jìn)行直接的類型轉(zhuǎn)換。

在此之前的 Go 版本中，如果兩個(gè)結(jié)構(gòu)體類型即使只有標(biāo)簽不同，也被認(rèn)為是不同的類型，無法直接轉(zhuǎn)換，需要手動(dòng)進(jìn)行逐個(gè)字段的賦值。

我們來看官方的例子：

package main

import "fmt"

func main() {
    type T1 struct {
        X int `json:"foo"`
    }
    type T2 struct {
        X int `json:"bar"`
    }

    var v2 T2 = T2{X: 10}
    // 在 Go 1.8 及以后版本，這行代碼是合法的
    var v1 T1 = T1(v2) 

    fmt.Println(v1) // 輸出: {10}
}

在這個(gè)例子中，T1 和 T2 結(jié)構(gòu)體都擁有一個(gè) int 類型的字段 X，它們唯一的區(qū)別在于 X 字段的 json 標(biāo)簽不同。在 Go 1.8 之前，T1(v2) 這樣的轉(zhuǎn)換會(huì)引發(fā)編譯錯(cuò)誤。但從 Go 1.8 開始，這個(gè)轉(zhuǎn)換是合法的，因?yàn)榫幾g器在檢查類型轉(zhuǎn)換的兼容性時(shí)忽略了標(biāo)簽。

這個(gè)特性有什么用呢？

它在處理不同數(shù)據(jù)表示層（例如數(shù)據(jù)庫模型、API 請(qǐng)求/響應(yīng)體、內(nèi)部業(yè)務(wù)邏輯結(jié)構(gòu)）之間的轉(zhuǎn)換時(shí)非常有用。這些不同的結(jié)構(gòu)體可能共享相同的核心數(shù)據(jù)字段，但需要不同的標(biāo)簽來服務(wù)于各自的目的（如 db 標(biāo)簽用于 ORM，json 標(biāo)簽用于序列化）。

考慮以下場(chǎng)景：我們有一個(gè)從數(shù)據(jù)庫讀取的用戶模型和一個(gè)用于 API 輸出的用戶模型。

package main

import "fmt"

// 數(shù)據(jù)庫模型
type UserDB struct {
    ID   int    `db:"user_id,omitempty"`
    Name string `db:"user_name"`
    Age  int    `db:"user_age"`
}

// API 輸出模型
type UserAPI struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
    Age  int    `json:"age,omitempty"`
}

func main() {
    // 假設(shè)這是從數(shù)據(jù)庫查詢得到的數(shù)據(jù)
    dbUser := UserDB{ID: 1, Name: "Alice", Age: 30}

    // 在 Go 1.8+ 中，可以直接轉(zhuǎn)換
    apiUser := UserAPI(dbUser)

    fmt.Printf("DB User: %+v\n", dbUser)
    fmt.Printf("API User: %+v\n", apiUser) 

    // 反向轉(zhuǎn)換同樣合法
    dbUserConvertedBack := UserDB(apiUser)
    fmt.Printf("DB User Converted Back: %+v\n", dbUserConvertedBack)
}

在 Go 1.8 之前，你需要手動(dòng)編寫類似這樣的轉(zhuǎn)換代碼：

// Go 1.7 及更早版本的做法
func convertDBToAPI(dbUser UserDB) UserAPI {
    return UserAPI{
        ID:   dbUser.ID,
        Name: dbUser.Name,
        Age:  dbUser.Age,
    }
}
apiUser := convertDBToAPI(dbUser)

Go 1.8 的這項(xiàng)改動(dòng)使得這種僅標(biāo)簽不同的結(jié)構(gòu)體之間的轉(zhuǎn)換更加簡(jiǎn)潔和直接，減少了樣板代碼。當(dāng)然，需要強(qiáng)調(diào)的是，字段的名稱、類型和順序 必須 完全一致，才能進(jìn)行這種轉(zhuǎn)換。

實(shí)驗(yàn)性的插件 (Plugin) 支持

Go 1.8 引入了一個(gè)備受期待但標(biāo)記為實(shí)驗(yàn)性的功能：**插件 (Plugins)**。這個(gè)功能允許 Go 程序在運(yùn)行時(shí)動(dòng)態(tài)加載使用 Go 語言編寫的共享庫（.so 文件），并調(diào)用其中的函數(shù)或訪問其變量。

核心概念：

1. **構(gòu)建模式 plugin**：通過 go build -buildmode=plugin 命令，可以將一個(gè) main 包（或者未來可能支持其他包）編譯成一個(gè)共享對(duì)象文件（通常是 .so 文件）。這個(gè)文件包含了編譯后的 Go 代碼和運(yùn)行時(shí)信息。
2. plugin 包：Go 標(biāo)準(zhǔn)庫新增了 plugin 包，提供了加載和使用插件的功能。

• plugin.Open(path string) (*Plugin, error)：根據(jù)路徑加載一個(gè)插件文件。它會(huì)執(zhí)行插件代碼中的 init 函數(shù)。
• (*Plugin).Lookup(symName string) (Symbol, error)：在已加載的插件中查找導(dǎo)出的（大寫字母開頭的）變量或函數(shù)名。Symbol 是一個(gè)空接口類型 (interface{})。

基本用法示例：

假設(shè)我們有一個(gè)簡(jiǎn)單的插件，提供一個(gè)打招呼的功能。

1. 創(chuàng)建插件代碼 (greeter/greeter.go)

package main // 插件必須是 main 包

import "fmt"

// 導(dǎo)出的函數(shù)，首字母必須大寫
func Greet() {
    fmt.Println("Hello from the plugin!")
}

// 也可以導(dǎo)出變量
var PluginVersion = "1.0" 

// 插件不需要 main 函數(shù)，但可以有 init 函數(shù)
func init() {
    fmt.Println("Greeter plugin initialized!")
}

// 為了讓編譯器不報(bào)錯(cuò)，需要一個(gè) main 函數(shù)，但它在插件模式下不會(huì)被執(zhí)行
func main() {}

• 編譯插件

在你的項(xiàng)目目錄下執(zhí)行（假設(shè) greeter 目錄在當(dāng)前路徑下）：

go build -buildmode=plugin -o greeter.so greeter/greeter.go

這會(huì)生成一個(gè) greeter.so 文件。

• 創(chuàng)建主程序 (main.go)

package main

import (
    "fmt"
    "log"
    "plugin"
)

func main() {
    // 1. 加載插件
    // 注意：路徑根據(jù)實(shí)際情況調(diào)整
    p, err := plugin.Open("./greeter.so") 
    if err != nil {
        log.Fatalf("Failed to open plugin: %v", err)
    }
    fmt.Println("Plugin loaded successfully.")

    // 2. 查找導(dǎo)出的 'Greet' 函數(shù)
    greetSymbol, err := p.Lookup("Greet")
    if err != nil {
        log.Fatalf("Failed to lookup Greet symbol: %v", err)
    }

    // 3. 類型斷言：將 Symbol 轉(zhuǎn)換為期望的函數(shù)類型
    greetFunc, ok := greetSymbol.(func()) // 注意類型是 func()
    if !ok {
        log.Fatalf("Symbol Greet is not of type func()")
    }

    // 4. 調(diào)用插件函數(shù)
    fmt.Println("Calling Greet function from plugin...")
    greetFunc()

    // 5. 查找導(dǎo)出的 'PluginVersion' 變量
    versionSymbol, err := p.Lookup("PluginVersion")
    if err != nil {
        log.Fatalf("Failed to lookup PluginVersion symbol: %v", err)
    }
    
    // 6. 類型斷言：將 Symbol 轉(zhuǎn)換為期望的變量類型指針
    // 注意：查找變量得到的是指向該變量的指針
    versionPtr, ok := versionSymbol.(*string) 
    if !ok {
        log.Fatalf("Symbol PluginVersion is not of type *string")
    }
    
    // 7. 使用插件變量（需要解引用）
    fmt.Printf("Plugin version: %s\n", *versionPtr) 
}

• 運(yùn)行主程序

go run main.go

你將會(huì)看到類似如下的輸出：

Greeter plugin initialized!
Plugin loaded successfully.
Calling Greet function from plugin...
Hello from the plugin!
Plugin version: 1.0

Go 1.8 插件的限制和注意事項(xiàng)：

• 實(shí)驗(yàn)性：API 和行為在未來版本可能發(fā)生變化。
• 僅 Linux：在 Go 1.8 中，插件支持僅限于 Linux 平臺(tái)。
• 依賴匹配：主程序和插件必須使用完全相同的 Go 版本編譯，并且所有共享的依賴庫（包括標(biāo)準(zhǔn)庫和第三方庫）的版本和路徑都必須精確匹配。任何不匹配都可能導(dǎo)致加載失敗或運(yùn)行時(shí)崩潰。這在實(shí)踐中是一個(gè)相當(dāng)大的挑戰(zhàn)。
• 包路徑：插件和主程序?qū)τ诠蚕硪蕾嚨?nbsp;import 路徑必須一致。
• main 包：插件源文件必須屬于 package main，即使它不包含 main 函數(shù)的實(shí)際執(zhí)行邏輯。

潛在應(yīng)用場(chǎng)景：

盡管有諸多限制，插件機(jī)制為構(gòu)建可擴(kuò)展的應(yīng)用程序提供了可能，例如：

• 允許用戶或第三方開發(fā)者擴(kuò)展核心應(yīng)用功能。
• 實(shí)現(xiàn)某些類型的熱更新（盡管依賴匹配問題使得這很復(fù)雜）。
• 開發(fā)可定制化的工具或系統(tǒng)。

總的來說，Go 1.8 的插件是向動(dòng)態(tài)加載 Go 代碼邁出的第一步，雖然在當(dāng)時(shí)還很初步且有平臺(tái)限制，但為 Go 生態(tài)的發(fā)展開辟了新的方向。

sort 包：更便捷的切片排序方式

Go 1.8 之前的版本中，要對(duì)一個(gè)自定義類型的切片進(jìn)行排序，通常需要實(shí)現(xiàn) sort.Interface 接口，該接口包含三個(gè)方法：Len()、Less(i, j int) bool 和 Swap(i, j int)。這需要為每種需要排序的切片類型定義一個(gè)新的類型（通常是該切片類型的別名），并實(shí)現(xiàn)這三個(gè)方法。雖然不復(fù)雜，但略顯繁瑣，尤其是對(duì)于只需要一次性排序的場(chǎng)景。

Go 1.8 在 sort 包中引入了 Slice 函數(shù)，極大地簡(jiǎn)化了對(duì)任意類型切片的排序：

func Slice(slice interface{}, less func(i, j int) bool)

sort.Slice 函數(shù)接受兩個(gè)參數(shù)：

1. slice: 需要排序的切片，類型為 interface{}。
2. less: 一個(gè)比較函數(shù)，簽名必須是 func(i, j int) bool。這個(gè)函數(shù)定義了排序的規(guī)則：當(dāng)索引 i 處的元素應(yīng)該排在索引 j 處的元素之前時(shí)，返回 true。

這個(gè)函數(shù)利用反射 (reflection) 來操作傳入的切片，并使用用戶提供的 less 函數(shù)進(jìn)行元素的比較和交換，從而避免了開發(fā)者手動(dòng)實(shí)現(xiàn) sort.Interface 的三個(gè)方法。

示例對(duì)比：

假設(shè)我們有一個(gè) Person 結(jié)構(gòu)體切片，需要按年齡升序排序。

package main

import (
    "fmt"
    "sort"
)

type Person struct {
    Name string
    Age  int
}

// 用于打印切片
func printPeople(people []Person) {
    for _, p := range people {
        fmt.Printf("  %+v\n", p)
    }
}

// --- Go 1.7 及更早版本的做法 ---
// 1. 定義一個(gè)新類型
type ByAge []Person
// 2. 實(shí)現(xiàn) sort.Interface
func (a ByAge) Len() int           { return len(a) }
func (a ByAge) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
func (a ByAge) Less(i, j int) bool { return a[i].Age < a[j].Age }


func main() {
    people := []Person{
        {"Bob", 31},
        {"Alice", 25},
        {"Charlie", 31}, // 與 Bob 同齡
        {"David", 22},
    }

    fmt.Println("Original slice:")
    printPeople(people)

    peopleCopy1 := make([]Person, len(people))
    copy(peopleCopy1, people) // 復(fù)制一份用于演示舊方法

    sort.Sort(ByAge(peopleCopy1))
    fmt.Println("\nSorted using sort.Sort (Go 1.7 style):")
    printPeople(peopleCopy1)


    // --- Go 1.8 的新做法 ---
    peopleCopy2 := make([]Person, len(people))
    copy(peopleCopy2, people) // 復(fù)制一份用于演示新方法

    sort.Slice(peopleCopy2, func(i, j int) bool {
        // 直接在閉包中定義比較邏輯
        return peopleCopy2[i].Age < peopleCopy2[j].Age 
    })

    fmt.Println("\nSorted using sort.Slice (Go 1.8 style):")
    printPeople(peopleCopy2)
}

輸出：

Original slice:
  {Name:Bob Age:31}
  {Name:Alice Age:25}
  {Name:Charlie Age:31}
  {Name:David Age:22}

Sorted using sort.Sort (Go 1.7 style):
  {Name:David Age:22}
  {Name:Alice Age:25}
  {Name:Bob Age:31}
  {Name:Charlie Age:31}

Sorted using sort.Slice (Go 1.8 style):
  {Name:David Age:22}
  {Name:Alice Age:25}
  {Name:Bob Age:31}
  {Name:Charlie Age:31}

可以看到，使用 sort.Slice 顯著減少了為排序而編寫的樣板代碼。我們不再需要定義 ByAge 類型及其三個(gè)方法，只需提供一個(gè)簡(jiǎn)單的比較閉包即可。

新增的其他函數(shù)：

• sort.SliceStable(slice interface{}, less func(i, j int) bool)：與 sort.Slice 類似，但它執(zhí)行穩(wěn)定排序。穩(wěn)定排序保證了相等元素（根據(jù) less 函數(shù)判斷為不小于也不大于彼此的元素）在排序后的相對(duì)順序與排序前保持一致。在上面的例子中，如果使用 SliceStable，Bob 會(huì)始終排在 Charlie 前面，因?yàn)樗麄冊(cè)谠记衅械捻樞蚓褪侨绱恕?/li>
• sort.SliceIsSorted(slice interface{}, less func(i, j int) bool) bool：檢查切片是否已經(jīng)根據(jù) less 函數(shù)定義的順序排好序。

sort.Slice 及其相關(guān)函數(shù)的引入，使得在 Go 中對(duì)切片進(jìn)行自定義排序變得更加方便和直觀。