返回专栏
· 11 分钟阅读

匿名函数与 Lambda


一、什么是匿名函数

匿名函数(Anonymous Function)是指没有显式函数名称的函数。

与普通命名函数相比,匿名函数通常不通过名称直接调用,而是通过变量、参数、返回值或其他表达式使用。

1.1 命名函数

function add(a, b) {
    return a + b;
}

const result = add(10, 20);

命名函数具有明确的标识符 add,可以通过名称进行调用。

1.2 匿名函数

const add = function (a, b) {
    return a + b;
};

const result = add(10, 20);

这里的 function (a, b) 没有显式名称,因此是匿名函数。

函数被赋值给变量 add,后续可以通过变量调用。

需要注意:变量名称 add 并不会自动变成函数内部的显式名称。函数表达式本身仍然可以是匿名的,虽然 JavaScript 引擎在某些情况下会推断函数名称,用于调试和错误堆栈。

1.3 匿名函数的主要特点

  • 没有显式声明的函数名称。
  • 可以赋值给变量。
  • 可以作为函数参数传递。
  • 可以作为函数返回值。
  • 可以在需要函数值的表达式中直接定义。
  • 可以捕获外部词法环境,形成闭包。

匿名函数不是一种独立的执行机制,而是一种函数定义形式。

二、什么是 Lambda 表达式

Lambda 表达式(Lambda Expression)是一种使用简洁语法定义函数或可调用行为的表达形式。

不同语言对 Lambda 的具体定义并不完全一致:

  • 在 Java、C++ 等语言中,Lambda 通常用于创建匿名函数对象。
  • 在 Python 中,lambda 是用于定义单表达式匿名函数的语法。
  • 在 JavaScript 中,箭头函数是一种常见的 Lambda 风格表达形式。
  • 在 C# 中,Lambda 可以表示表达式体或语句体函数。

以 JavaScript 为例:

const add = (a, b) => a + b;

console.log(add(10, 20)); // 30

其中:

  • (a, b):参数列表。
  • =>:箭头符号。
  • a + b:表达式主体。
  • add:保存函数值的变量。

Lambda 的主要目标是减少定义函数所需的语法,使函数能够更加自然地嵌入表达式。

三、匿名函数与 Lambda 的关系

匿名函数和 Lambda 经常被一起讨论,但它们不是完全相同的概念。

对比维度 匿名函数 Lambda 表达式
核心含义 没有显式名称的函数 一种函数定义语法
关注点 是否有名称 如何表达函数
语法形式 取决于语言 取决于语言
是否一定匿名 是,按通常定义 不一定,取决于语言
是否可以赋值 可以 通常可以,受语言类型系统约束
是否可以作为参数 可以 通常可以

二者存在交集,但不能简单认为所有匿名函数都是 Lambda,也不能认为所有 Lambda 都必须匿名。

例如,JavaScript 中:

// 匿名函数表达式
const fn1 = function (x) {
    return x * 2;
};

// 箭头函数,也就是常见的 Lambda 风格写法
const fn2 = x => x * 2;

两者都可以作为函数值使用,但语法形式不同。

四、不同语言中的函数表达形式

4.1 JavaScript:函数表达式与箭头函数

JavaScript 主要有两种常见的匿名函数表达形式。

普通函数表达式:

const multiply = function (a, b) {
    return a * b;
};

箭头函数:

const multiply = (a, b) => a * b;

箭头函数具有更简洁的语法,但它并不是普通函数表达式的完全等价替代品。

主要区别:

特性 普通函数 箭头函数
this 根据调用方式动态确定 继承外层词法 this
arguments 通常拥有自己的 arguments 不拥有自己的 arguments
new 调用 普通函数可作为构造函数(存在限制) 不能作为构造函数
prototype 普通函数通常具有 prototype 属性 不具有自己的 prototype 属性
super 受函数类型和定义位置限制 使用外层词法环境中的 super
yield 普通函数不能直接使用,生成器函数可以 不能直接作为生成器函数

特别注意 this 的差异:

const user = {
    name: "Reverie",

    normal: function () {
        return this.name;
    },

    arrow: () => {
        return this.name;
    }
};

console.log(user.normal()); // Reverie
console.log(user.arrow());  // 通常不是 Reverie

普通函数的 this 由调用方式决定,箭头函数的 this 则来自定义时所在的词法环境。

因此,箭头函数通常适合回调和短小的数据处理逻辑,但不应无条件替代对象方法。

4.2 Python:lambda 表达式

Python 使用 lambda 关键字定义匿名函数。

add = lambda a, b: a + b

print(add(10, 20))  # 30

其基本语法:

lambda 参数列表: 表达式

Python Lambda 有一个重要限制:

Lambda 的主体只能是一个表达式,不能直接包含多条普通语句。

例如:

# 合法
square = lambda x: x * x

# 不适合使用 lambda 实现复杂多语句逻辑

复杂逻辑通常应使用 def:

def calculate(a, b):
    result = a + b
    return result * 2

Python Lambda 常见于:

users = [
    {"name": "Alice", "age": 30},
    {"name": "Bob", "age": 20},
    {"name": "Tom", "age": 25}
]

users.sort(key=lambda user: user["age"])

这里的 Lambda 为 sort 提供排序键函数。

4.3 Java:Lambda 与函数式接口

Java 从 Java 8 开始正式支持 Lambda 表达式。

Java 并不是直接将任意函数作为独立值传递,而是通过函数式接口(Functional Interface)承载 Lambda。

函数式接口是指只有一个抽象方法的接口,默认方法和静态方法不影响这一条件。

@FunctionalInterface
interface Calculator {
    int calculate(int a, int b);
}

public class Main {
    public static void main(String[] args) {
        Calculator add = (a, b) -> a + b;

        System.out.println(add.calculate(10, 20));
    }
}

Java 还提供了常见的内置函数式接口:

接口 主要作用 抽象方法
Function<T, R> 输入并返回结果 apply
Consumer<T> 接收参数,无返回值 accept
Supplier<T> 无参数,提供结果 get
Predicate<T> 条件判断 test
BiFunction<T, U, R> 接收两个参数并返回结果 apply

示例:

import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        Function<Integer, Integer> square =
            x -> x * x;

        System.out.println(square.apply(5)); // 25
    }
}

4.4 C++:Lambda 表达式

C++11 开始支持 Lambda 表达式。

基本语法:

[capture](parameters) -> return_type {
    // 函数体
};

其中:

  • capture:捕获外部变量。
  • parameters:参数列表。
  • return_type:返回类型,可以由编译器推导。
  • 函数体:具体执行逻辑。

示例:

#include <iostream>

int main() {
    int factor = 10;

    auto multiply = [factor](int value) {
        return value * factor;
    };

    std::cout << multiply(5) << std::endl;

    return 0;
}

输出:

50

C++ Lambda 的一个重要特点是可以通过捕获列表控制外部变量的访问方式。

常见捕获形式:

写法 含义
[] 不捕获外部变量
[x] 按值捕获 x
[&x] 按引用捕获 x
[=] 默认按值捕获需要使用的外部局部变量
[&] 默认按引用捕获需要使用的外部局部变量
[this] 捕获当前对象的 this 指针
[*this] 按值捕获当前对象副本(C++17 起)

C++ Lambda 本质上会形成一个闭包对象,其具体类型由编译器生成。

4.5 Go:匿名函数与闭包

Go 支持匿名函数,可以直接定义并调用,也可以赋值给变量。

package main

import "fmt"

func main() {
    add := func(a, b int) int {
        return a + b
    }

    fmt.Println(add(10, 20))
}

Go 的匿名函数也可以捕获外部变量:

package main

import "fmt"

func main() {
    count := 0

    increment := func() int {
        count++
        return count
    }

    fmt.Println(increment()) // 1
    fmt.Println(increment()) // 2
}

Go 没有独立的 lambda 关键字,但匿名函数和闭包能够实现类似的功能。

4.6 Rust:闭包表达式

Rust 使用闭包表达式定义匿名函数行为。

fn main() {
    let add = |a: i32, b: i32| -> i32 {
        a + b
    };

    println!("{}", add(10, 20));
}

Rust 闭包可以捕获外部环境:

fn main() {
    let factor = 10;

    let multiply = |value| value * factor;

    println!("{}", multiply(5));
}

Rust 的闭包捕获与所有权系统密切相关,主要通过以下 Trait 描述调用行为:

  • Fn:通过不可变借用捕获环境。
  • FnMut:通过可变借用捕获环境。
  • FnOnce:允许消耗捕获的环境。

需要注意,闭包不一定都实现三个 Trait。具体实现取决于闭包对捕获变量的使用方式。

五、Lambda 与闭包(Closure)

Lambda 和闭包经常一起出现,但两者的概念层次不同。

  • Lambda:描述函数如何定义。
  • 闭包:描述函数如何与外部词法环境建立联系。

一个 Lambda 可以不捕获任何外部变量,也可以捕获外部变量形成闭包。

5.1 不捕获外部变量

const square = x => x * x;

这个箭头函数不依赖外部变量。

5.2 捕获外部变量

function createMultiplier(factor) {
    return value => value * factor;
}

const double = createMultiplier(2);

console.log(double(10)); // 20

这里的箭头函数引用了外部变量 factor。

即使 createMultiplier 执行结束,返回的函数仍然能够访问 factor。

5.3 闭包的形成过程

flowchart TD
    A["定义外层函数"] --> B["创建外层词法环境"]
    B --> C["定义内部 Lambda"]
    C --> D["引用外部变量"]
    D --> E["形成闭包关系"]
    E --> F["返回内部函数"]
    F --> G["外层函数执行结束"]
    G --> H["后续调用内部函数"]
    H --> I["访问捕获的变量"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style G fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style H fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style I fill:#FFF5DE,stroke:#E8D29A,color:#334155

    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

5.4 不同语言的捕获机制

语言 捕获机制 主要特点
JavaScript 词法作用域 访问定义位置的外部变量
Python 闭包单元与词法作用域 可使用 nonlocal 修改外层绑定
Java 捕获局部变量 局部变量必须是 final 或 effectively final
C++ 显式捕获列表 可控制值捕获、引用捕获
Go 词法闭包 可以引用外部变量
Rust 所有权与借用 捕获方式受到闭包 Trait 约束

尤其需要注意 C++ 和 Rust:

  • C++ 按引用捕获时,如果闭包的生命周期超过被引用对象,可能产生悬空引用。
  • Rust 会通过借用检查和生命周期约束,限制不安全的引用逃逸。

六、Lambda 的类型与执行机制

Lambda 不只是语法简写。不同语言会将 Lambda 转换为不同的函数值、对象或中间表示。

6.1 函数类型

Lambda 通常需要具有明确的输入和输出类型。

例如:

f: A \rightarrow B

表示函数 f 接收类型为 A 的输入,并返回类型为 B 的结果。

多参数函数可以表示为:

f: A \times B \rightarrow C

例如:

const add = (a, b) => a + b;

可以理解为接收两个输入并返回一个结果的函数。

不同语言的类型系统可能使用函数类型、函数式接口、闭包类型或模板类型表达这种关系。