Go 程序員為什么更喜歡把函數值叫做閉包

夏群林 2025.9.17 原創

最近癡迷于 Go。

在編程語言的世界里，“函數作為值”的概念并不新鮮：C 有函數指針，C# 有 delegate（委托）和 lambda 表達式，Go 則有函數值（function value）。

有趣的是，Go 程序員更習慣把“函數值”直接稱為“閉包”（closures）。這并非命名上的隨意，而是源于程序員的洞察： Go 對“函數作為值”的設計，本質上與閉包的核心特性深度綁定，甚至可以說，Go 的函數值就是閉包的具象化實現。

要理解這一點，我們不妨從其他語言的類似概念入手，看看Go的設計究竟特殊在哪里。

一、C 的函數指針：只有代碼，沒有狀態

C語言是最早支持“函數作為值”的語言之一，其載體是“函數指針”。函數指針本質上是一個指向函數代碼入口地址的指針，它能讓函數像變量一樣被傳遞或賦值。例如：

#include <stdio.h>

// 定義一個函數
int add(int a, int b) {
    return a + b;
}

// 函數指針作為參數
void calculate(int (*func)(int, int), int a, int b) {
    printf("結果: %d\n", func(a, b));
}

int main() {
    // 函數指針指向add函數
    int (*func_ptr)(int, int) = add;
    calculate(func_ptr, 2, 3); // 輸出：結果: 5
    return 0;
}

C 的函數指針只包含函數的代碼地址，不攜帶任何狀態。“狀態”指函數執行時依賴的外部變量上下文。C 函數要訪問外部變量，只能通過全局變量（或參數傳遞），而函數指針本身無法記住這些變量的值。

例如，若想實現一個帶偏移量的加法器，C 的函數指針做不到記住偏移量：

// 嘗試實現帶偏移量的加法器（無法通過函數指針記住offset）
int makeAdder(int offset) {
    // 錯誤：C不允許嵌套函數，更無法捕獲外部變量
    int addWithOffset(int x) {
        return x + offset; 
    }
    return addWithOffset; // 編譯失敗
}

因此，C 的函數指針只是代碼的引用，與閉包毫無關系，因為沒有捕獲狀態的能力。

二、C# 的 delegate 與 lambda：閉包是可選特性

C# 的 delegate（委托）比 C 的函數指針更靈活：它可以封裝一個方法，還能通過 lambda 表達式創建匿名函數。更重要的是，C# 的lambda 可以捕獲外部變量，形成閉包。

例如，用 C# 實現“帶狀態的加法器”：

using System;

class Program {
    static Func<int, int> MakeAdder(int offset) {
        // lambda表達式捕獲外部變量offset
        return x => x + offset;
    }

    static void Main() {
        Func<int, int> adder = MakeAdder(10);
        Console.WriteLine(adder(5)); // 輸出：15（記住了offset=10）
    }
}

這里的 lambda 表達式x => x + offset就是一個閉包——它捕獲了外部變量offset，即使MakeAdder執行結束，offset仍能被adder訪問。

但 C# 中委托與閉包是包含關系而非等同關系：

• 委托是一種類型，它可以指向任何匹配簽名的方法（包括普通函數、實例方法、lambda）；
• 只有當 lambda（或匿名方法）捕獲了外部變量時，它才是閉包。如果 lambda 不捕獲變量（如x => x * 2），它本質上和普通函數指針差異不大。

也就是說，在 C# 中，閉包是委托的一種特殊情況，而非委托的全部。

三、Go 的函數值：天生就是閉包

Go 的函數值（function value）指的是“函數作為一種值”，可以被賦值給變量、作為參數傳遞、作為返回值返回。但與 C 的函數指針、C# 的委托不同，Go 的函數值從設計上就與閉包深度綁定：它不僅包含函數的代碼，還天然攜帶對外部變量的引用（如果有）。

1. 函數值必然捕獲狀態（如果需要）

在Go中，任何函數（包括匿名函數）只要引用了外部變量，就會自動形成閉包——編譯器會確保這些變量的生命周期與函數值綁定。例如：

package main

import "fmt"

// 返回一個函數值（閉包）
func makeAdder(offset int) func(int) int {
    // 匿名函數引用了外部變量offset
    return func(x int) {
        return x + offset // 捕獲offset
    }
}

func main() {
    adder := makeAdder(10)
    fmt.Println(adder(5)) // 輸出：15（記住了offset=10）
}

這個例子中，makeAdder返回的匿名函數是一個函數值，它同時也是閉包：它捕獲了offset變量，即使makeAdder執行完畢，offset仍能被adder訪問和修改。

更關鍵的是：即使函數值不引用外部變量，Go 的實現邏輯也與閉包一致。它的底層結構始終包含“代碼指針”和“環境指針”（即使環境為空），這與 C# 中非閉包 lambda 的實現不同。

2. 函數值是引用類型，狀態可共享

Go 的函數值是引用類型：當你將函數值賦值給另一個變量時，復制的是對“代碼+狀態”的引用，而非狀態本身。這意味著多個函數值變量可以共享同一份被捕獲的狀態：

func main() {
    f1 := makeAdder(10)
    f2 := f1 // f2與f1引用同一個閉包
    
    fmt.Println(f1(5)) // 15
    fmt.Println(f2(3)) // 13（共享offset=10）
}

這種特性完全符合閉包“代碼與狀態綁定”的核心定義，而 C 的函數指針（無狀態）、C#的非閉包委托（狀態獨立）都不具備這種天然的狀態共享能力。

3. 不可比較性：閉包狀態的必然結果

Go明確規定：函數值不能比較（除了與nil比較）。這正是因為函數值是閉包——它的唯一性不僅取決于代碼，還取決于被捕獲的狀態。即使兩個函數值由同一函數生成，只要捕獲的狀態不同，它們就不應該被視為相等：

func main() {
    f1 := makeAdder(10)
    f2 := makeAdder(10)
    // if f1 == f2 { ... } // 編譯錯誤：函數值不能比較
}

f1和f2雖然代碼相同，且初始offset都是10，但它們捕獲的是兩個獨立的offset變量（狀態不同），因此比較毫無意義。這種設計進一步印證了：Go 的函數值本質是閉包，狀態是其不可分割的一部分。

為什么 Go 程序員更愛說“閉包”？

從上面的對比可以看出：

• C 的函數指針：只有代碼，無狀態，與閉包無關；
• C# 的委托：閉包是可選特性，多數時候只是函數的容器；
• Go 的函數值：從實現到特性，完全符合閉包“代碼+狀態”的定義，閉包是其本質，而非附加特性。

對 Go 程序員來說，“函數值”這個術語描述的是“函數作為值的形態”，而“閉包”描述的是其“代碼與狀態綁定的本質”。當他們說“閉包”時，不僅指“函數可以作為值”，更強調其捕獲狀態、共享環境的核心能力。這正是 Go 函數值最強大、最常用的特性。

這種命名習慣，本質上是對 Go 設計簡潔性的呼應：既然函數值的實現和行為都與閉包完全一致，何必兩個術語？直接叫閉包，既精準又直觀。

結語

Go 的“函數值”與“閉包”的等同稱呼，大概不是語言設計者的刻意為之，而是其設計邏輯的自然結果。當函數作為值時，必然要攜帶它所依賴的狀態，否則失去靈活性。Go 使用閉包（closures）技術實現函數值，代碼與狀態共生，也讓閉包成為描述 Go 函數值最貼切的詞匯。

這也正是 Go 的魅力所在：用最簡單的設計，實現最本質的功能。