“闭包”和“lambda”有什么区别？

当大多数人想到函数时，他们会想到命名函数：

function foo() { return "This string is returned from the 'foo' function"; }

当然，这些都是按名称调用的：

foo(); //returns the string above

使用 lambda 表达式，您可以使用匿名函数：

 @foo = lambda() {return "This is returned from a function without a name";}

在上面的例子中，你可以通过分配给它的变量来调用 lambda：

foo();

然而，比将匿名函数分配给变量更有用的是，将它们传递给高阶函数或从高阶函数传递它们，即接受/返回其他函数的函数。在很多情况下，命名函数是不必要的：

function filter(list, predicate) 
 { @filteredList = [];
   for-each (@x in list) if (predicate(x)) filteredList.add(x);
   return filteredList;
 }

//filter for even numbers
filter([0,1,2,3,4,5,6], lambda(x) {return (x mod 2 == 0)}); 

闭包可以是命名函数或匿名函数，但是当它“关闭”定义函数的范围内的变量时，它就被称为闭包，即闭包仍将引用环境中使用的任何外部变量。关闭本身。这是一个命名的闭包：

@x = 0;

function incrementX() { x = x + 1;}

incrementX(); // x now equals 1

这看起来并不多，但如果这一切都在另一个函数中并且您将 incrementX 传递给外部函数怎么办？

function foo()
 { @x = 0;

   function incrementX() 
    { x = x + 1;
      return x;
    }

   return incrementX;
 }

@y = foo(); // y = closure of incrementX over foo.x
y(); //returns 1 (y.x == 0 + 1)
y(); //returns 2 (y.x == 1 + 1)

这就是在函数式编程中获得有状态对象的方式。由于不需要命名“incrementX”，因此您可以在这种情况下使用 lambda：

function foo()
 { @x = 0;

   return lambda() 
           { x = x + 1;
             return x;
           };
 }

---

并非所有闭包都是 lambda，也不是所有 lambda 都是闭包。两者都是函数，但不一定以我们习惯知道的方式。

lambda 本质上是一个内联定义的函数，而不是声明函数的标准方法。 Lambda 可以经常作为对象传递。

闭包是一个函数，它通过引用其主体外部的字段来封闭其周围的状态。封闭状态在闭包的调用中保持不变。

在面向对象的语言中，闭包通常是通过对象提供的。但是，一些 OO 语言（例如 C#）实现的特殊功能更接近于由纯粹的 functional languages（例如 lisp）提供的没有对象来包围状态的闭包的定义。

有趣的是，在 C# 中引入 Lambdas 和 Closures 使函数式编程更接近主流用法。

---

就这么简单： lambda 是一种语言结构，即匿名函数的简单语法；闭包是一种实现它的技术——或者任何一流的函数，就此而言，命名的或匿名的。

更准确地说，闭包是 first-class function 在运行时的表示方式，作为它的一对“代码”和一个“关闭”该代码中使用的所有非局部变量的环境。这样，即使它们起源的外部范围已经退出，这些变量仍然可以访问。

不幸的是，有许多语言不支持函数作为一等值，或者只支持残缺的形式。所以人们经常用“闭包”这个词来区分“真货”。

---

从编程语言的角度来看，它们是完全不同的两种东西。

基本上，对于图灵完备的语言，我们只需要非常有限的元素，例如抽象、应用和归约。抽象和应用程序提供了构建 lamdba 表达式的方法，而归约决定了 lambda 表达式的含义。

Lambda 提供了一种可以将计算过程抽象出来的方法。例如，要计算两个数的和，可以抽象出一个接受两个参数 x、y 并返回 x+y 的过程。在方案中，您可以将其写为

(lambda (x y) (+ x y))

您可以重命名参数，但它完成的任务不会改变。在几乎所有的编程语言中，您都可以为 lambda 表达式命名，即命名函数。但是没有太大区别，它们在概念上可以被认为只是语法糖。

好的，现在想象一下如何实现。每当我们将 lambda 表达式应用于某些表达式时，例如

((lambda (x y) (+ x y)) 2 3)

我们可以简单地将参数替换为要评估的表达式。这个模型已经很强大了。但是这个模型不能让我们改变符号的值，例如我们不能模仿状态的变化。因此我们需要一个更复杂的模型。简而言之，每当我们想要计算 lambda 表达式的含义时，我们都会将这对符号和对应的值放入一个环境（或表）中。然后通过查找表中的相应符号来评估其余的 (+ xy)。现在，如果我们提供一些原语来直接对环境进行操作，我们就可以对状态的变化进行建模！

在此背景下，检查此功能：

(lambda (x y) (+ x y z))

我们知道，当我们计算 lambda 表达式时，xy 将被绑定到一个新表中。但是我们如何以及在哪里查找 z 呢？实际上 z 被称为自由变量。必须有一个包含 z 的外部环境。否则仅通过绑定 x 和 y 无法确定表达式的含义。为了清楚起见，您可以在方案中编写如下内容：

((lambda (z) (lambda (x y) (+ x y z))) 1)

所以 z 将在外部表中绑定到 1。我们仍然得到一个接受两个参数的函数，但它的真正含义还取决于外部环境。换句话说，外部环境关闭了自由变量。在 set! 的帮助下，我们可以使函数有状态，即它不是数学意义上的函数。它返回的内容不仅取决于输入，还取决于 z。

这一点你已经很清楚了，对象的方法几乎总是依赖于对象的状态。这就是为什么有人说“闭包是穷人的对象”。但我们也可以将对象视为穷人的闭包，因为我们真的很喜欢一流的函数。

我使用方案来说明这些想法，因为该方案是最早具有真正闭包的语言之一。这里的所有材料都在 SICP 第 3 章中有更好的介绍。

总而言之，lambda 和闭包是完全不同的概念。 lambda 是一个函数。闭包是一对 lambda 和关闭 lambda 的相应环境。

---

概念与上面描述的相同，但如果您是 PHP 背景的，这将使用 PHP 代码进一步解释。

$input = array(1, 2, 3, 4, 5);
$output = array_filter($input, function ($v) { return $v > 2; });

函数 ($v) { 返回 $v > 2; } 是 lambda 函数定义。我们甚至可以将它存储在一个变量中，这样它就可以被重用：

$max = function ($v) { return $v > 2; };

$input = array(1, 2, 3, 4, 5);
$output = array_filter($input, $max);

现在，如果您想更改过滤数组中允许的最大数量怎么办？您必须编写另一个 lambda 函数或创建一个闭包（PHP 5.3）：

$max_comp = function ($max) {
  return function ($v) use ($max) { return $v > $max; };
};

$input = array(1, 2, 3, 4, 5);
$output = array_filter($input, $max_comp(2));

闭包是在自己的环境中评估的函数，它具有一个或多个绑定变量，在调用函数时可以访问这些变量。它们来自函数式编程世界，其中有许多概念在起作用。闭包类似于 lambda 函数，但更智能的是它们能够与定义闭包的外部环境中的变量进行交互。

这是一个更简单的 PHP 闭包示例：

$string = "Hello World!";
$closure = function() use ($string) { echo $string; };

$closure();

Nicely explained in this article.

---

这个问题很老，得到了很多答案。现在有了作为非官方闭包项目的 Java 8 和 Official Lambda，它重新提出了这个问题。

Java 上下文中的答案（通过 Lambdas and closures — what’s the difference?）：

“闭包是与环境配对的 lambda 表达式，该环境将其每个自由变量绑定到一个值。在 Java 中，lambda 表达式将通过闭包实现，因此这两个术语在社区中可以互换使用。”

---

简单来说，闭包是一个关于作用域的技巧，lambda 是一个匿名函数。我们可以更优雅地用 lambda 实现闭包，并且 lambda 通常用作传递给更高层函数的参数

---

Lambda 表达式只是一个匿名函数。例如，在普通的 java 中，你可以这样写：

Function<Person, Job> mapPersonToJob = new Function<Person, Job>() {
    public Job apply(Person person) {
        Job job = new Job(person.getPersonId(), person.getJobDescription());
        return job;
    }
};

其中类 Function 只是用 java 代码构建的。现在您可以在某处调用 mapPersonToJob.apply(person) 来使用它。这只是一个例子。那是一个 lambda，在它没有语法之前。 Lambdas 是一个捷径。

关闭：

当 Lambda 可以访问此范围之外的变量时，它就变成了一个闭包。我想你可以说它的魔力，它可以神奇地环绕它创建的环境并使用其范围之外的变量（外部范围。所以要清楚，闭包意味着 lambda 可以访问它的外部范围。

在 Kotlin 中，lambda 始终可以访问其闭包（位于其外部范围内的变量）

---

Lambda 与闭包

Lambda 是 匿名 函数（方法）

Closure 是从其封闭范围关闭（捕获）变量（例如非局部变量）的函数

爪哇

interface Runnable {
    void run();
}

class MyClass {
    void foo(Runnable r) {

    }

    //Lambda
    void lambdaExample() {
        foo(() -> {});
    }

    //Closure
    String s = "hello";
    void closureExample() {
        foo(() -> { s = "world";});
    }
}

斯威夫特^[Closure]

class MyClass {
    func foo(r:() -> Void) {}
    
    func lambdaExample() {
        foo(r: {})
    }
    
    var s = "hello"
    func closureExample() {
        foo(r: {s = "world"})
    }
}

---

在这个问题的各种现有答案中，有很多技术上模糊或“甚至没有错”的人造珍珠的噪音，所以我最后要添加一个新的......

术语说明

最好知道，术语“闭包”和“lambda”都可以表示不同的事物，具体取决于上下文。

这是一个正式的问题，因为正在讨论的 PL（编程语言）的规范可能会明确定义这些术语。

例如，通过 ISO C++（自 C++11 起）：

lambda 表达式的类型（也是闭包对象的类型）是唯一的、未命名的非联合类类型，称为闭包类型，其属性如下所述。

由于类 C 语言的用户每天都对指向“指针值”或“指针对象”（类型的居民）的“指针”（类型）感到困惑，因此这里也存在混淆的风险：大多数 C++ 用户实际上是在谈论使用术语“闭包”来“闭包对象”。小心歧义。

注意 为了使事情更清晰、更准确，我很少故意使用一些与语言无关的术语（通常特定于 PL theory 而不是语言定义的术语。例如，type inhabitant上面使用的涵盖了语言特定的“(r)values”和更广泛意义上的“lvalues”。（由于 C++ 的 value category 定义的句法本质是无关紧要的，避免使用“(l/r)values” " 可能会减少混淆）。（免责声明：在许多其他情况下，左值和右值 common 就足够了。）在不同的 PL 中未正式定义的术语可能会用引号引起来。来自参考材料的逐字复制也可以用引号引起来，但拼写错误没有改变。

这与“lambda”更为相关。 （小写）字母 lambda (λ) 是希腊字母表的一个元素。与“lambda”和“closure”相比，当然不是在谈论字母本身，而是在使用“lambda”派生概念的语法背后的东西。

现代 PL 中的相关结构通常称为“lambda 表达式”。它源自下面讨论的“lambda 抽象”。

在详细讨论之前，我建议阅读问题本身的一些评论。我觉得它们比这里问题的大多数答案更安全，更有帮助，因为混淆的风险更小。 （可悲的是，这是我决定在这里提供答案的最重要原因......）

Lambdas：简史

PL 中名为“lambda”的构造，无论是“lambda 表达式”还是其他东西，都是语法结构。换句话说，语言的用户可以找到用于构建其他东西的源语言结构。粗略地说，“其他”在实践中只是“匿名函数”。

此类构造源自 lambda 抽象，它是 A. Church 开发的 (untyped) lambda calculus 的三个语法类别（“表达式种类”）之一。

Lambda 演算是一个推导系统（更准确地说，是一个 TRS (term rewrite system)），用于对计算进行普遍建模。减少 lambda 项的 a 就像评估普通 PL 中的表达式一样。使用内置的归约规则，定义各种计算方式就足够了。 （您可能知道，it is Turing-complete。）因此，它可以用作 PL。

注：评估 PL 中的表达式通常不能与减少 TRS 中的项互换。然而，lambda 演算是一种语言，所有归约结果都可以在源语言中表达（即作为 lambda 项），因此它们具有相同的含义。几乎所有实践中的 PL 都不具备此属性；描述其语义的演算可能包含不是源语言表达式的术语，并且归约可能比评估具有更详细的效果。

lambda 演算（lambda 项）中的每个项（“表达式”）都是变量、抽象或应用程序。这里的“变量”是符号的语法（只是变量的名称），它可以引用之前介绍的现有“变量”（语义上，可以简化为其他 lambda 项的实体）。引入变量的能力由抽象语法提供，它有一个前导字母 λ，后跟一个绑定变量、一个点和一个 lambda 项。在许多语言中，绑定变量在语法和语义上都类似于形参名称，而 lambda 抽象中的后面的 lambda 术语就像函数体一样。应用程序语法将 lambda 术语（“实际参数”）与某种抽象结合起来，例如许多 PL 中的函数调用表达式。

注意 lambda 抽象只能引入一个参数。要克服微积分内部的限制，请参见Currying。

引入变量的能力使 lambda 演算成为一种典型的高级语言（尽管很简单）。另一方面，通过从 lambda 演算中移除变量和抽象特征，可以将 combinatory logics 视为 PL。组合逻辑在这个意义上是低级的：它们就像普通的汇编语言，不允许引入用户命名的变量（尽管宏需要额外的预处理）。 （......如果不是更底层......通常汇编语言至少可以引入用户命名的标签。）

注意 lambda 抽象可以在任何其他 lambda 术语中就地构建，而无需指定名称来表示抽象。因此，整个 lambda 抽象形成了匿名函数（可能是嵌套的）。这是一个相当高级的特性（与不允许匿名或嵌套函数的 ISO C 相比）。

无类型 lambda 演算的继承者包括各种类型的 lambda 演算（如 lambda cube）。这些更像是静态类型语言，需要对函数的形式参数进行类型注释。尽管如此，lambda 抽象在这里仍然具有相同的作用。

尽管 lambda 演算不打算直接用作在计算机中实现的 PL，但它们在实践中确实影响了 PL。值得注意的是，J. McCarthy 在 LISP 中引入了 LAMBDA 运算符，以提供完全遵循 Church 的无类型 lambda 演算思想的函数。显然，名称 LAMBDA 来自字母 λ。 LISP（后来）具有不同的语法（S-expression），但 LAMBDA 表达式中的所有可编程元素都可以通过简单的语法转换直接映射到无类型 lambda 演算中的 lambda 抽象。

另一方面，许多其他 PL 通过其他方式表达类似的功能。引入可重用计算的一种稍微不同的方法是命名函数（或更准确地说，命名子例程），早期的 PL （如 FORTRAN）和派生自 ALGOL 的语言都支持这些方法。它们是由同时指定命名实体作为函数的语法引入的。这在某种意义上比 LISP 方言更简单（尤其是在实现方面），而且它似乎比 LISP 方言更流行了几十年。命名函数也可能允许匿名函数不共享的扩展，如函数重载。

尽管如此，越来越多的工业程序员最终发现 first-class functions 的用处，并且对能够就地引入函数定义（在任意上下文中的表达式中，例如，作为某个其他函数的参数）的需求正在增加。避免命名不需要的事物是自然且合法的，并且根据定义，任何命名函数在此都会失败。 （您可能知道，naming things correctly is one of the well-known hard problems in the computer science。）为了解决这个问题，匿名函数被引入到传统上只提供命名函数（或类似函数的构造，如“方法”）的语言中，如 C++ 和 Java。他们中的许多人将该功能命名为“lambda 表达式”或类似的 lambda 事物，因为它们基本上反映了 lambda 演算中基本相同的想法。 文艺复兴。

有点歧义：在 lambda 演算中，所有术语（变量、抽象和应用程序）都是 PL 中的有效表达式；从这个意义上说，它们都是“lambda 表达式”。但是，为了丰富其特性而添加 lambda 抽象的 PL 可能会专门将抽象的语法命名为“lambda 表达式”，以与现有的其他类型的表达式区分开来。

闭包：历史

Closures in mathematics 与 it in PLs 不同。

在后一种情况下，术语 is coined by P. J. Landin in 1964，在“以 Church 的 λ-notation 为模型”评估 PL 的实现中提供一流函数的支持。

特定于 Landin（SECD machine）、a closure is comprising the λ-expression and the environment relative to which it was evaluated 或更准确地说：

一个环境部分，它是一个列表，其两项是 (1) 环境 (2) 标识符列表的标识符

和一个控制部分，它由一个列表组成，其唯一的项目是一个 AE

NOTE AE在论文中是applicative expression的缩写。这是在 lambda 演算中暴露或多或少相同的应用程序功能的语法。不过，还有一些额外的细节，如 "applicative"，在 lambda 演算中并不那么有趣（因为它纯粹是函数式的）。 SECD 与这些微小差异的原始 lambda 演算不一致。例如，无论子项（“body”）是否具有范式，SECD 都会在任意单个 lambda 抽象上停止，因为它不会在没有应用抽象（“called”）的情况下减少子项（“evaluate the body”）。然而，这种行为可能更像今天的 PL，而不是 lambda 演算。 SECD 也不是唯一可以评估 lambda 项的抽象机器；尽管用于类似目的的大多数其他抽象机器也可能有环境。与 lambda 演算（纯粹的）相比，这些抽象机器可以在一定程度上支持变异。

因此，在这个特定的上下文中，闭包是一种内部数据结构，用于使用 AE 实现对 PL 的特定评估。

访问闭包中的变量的规则反映了 lexical scoping，它在 1960 年代初期由命令式语言 ALGOL 60 首次使用。ALGOL 60 确实支持嵌套过程和将过程传递给参数，但不支持将过程作为结果返回。对于完全支持可由函数返回的一等函数的语言，ALGOL 60 样式实现中的静态链不起作用，因为被返回函数使用的自由变量可能不再存在于调用堆栈上。这是upwards funarg problem。闭包通过捕获环境部分中的自由变量并避免在堆栈上分配它们来解决问题。

另一方面，早期的 LISP 实现都使用动态范围。这使得引用的变量绑定在全局存储中都可以访问，并且名称隐藏（如果有）是作为每个变量的基础实现的：一旦使用现有名称创建变量，旧的变量将由 LIFO 结构支持；换句话说，每个变量的名称都可以访问相应的全局堆栈。这有效地消除了对每个函数环境的需求，因为函数中没有捕获任何自由变量（它们已经被堆栈“捕获”）。

尽管一开始模仿了 lambda 表示法，但 LISP 与这里的 lambda 演算非常不同。 lambda 演算是静态作用域的。也就是说，每个变量都表示由 lambda 抽象的最接近的相同命名形式参数限定的实例，该 lambda 抽象包含在其归约之前的变量。在 lambda 演算的语义中，减少应用程序将术语（“参数”）替换为抽象中的绑定变量（“形式参数”）。由于在 lambda 演算中所有值都可以表示为 lambda 项，因此这可以通过在归约的每个步骤中替换特定子项来直接重写来完成。

注意 因此，环境对于减少 lambda 项并不是必不可少的。然而，扩展 lambda 演算的演算可以在文法中显式地引入环境，即使它只对纯计算（没有变异）进行建模。通过显式添加环境，可以对环境有专门的约束规则来强制执行环境归一化，从而加强微积分的方程理论。 （见 [Shu10] §9.1。）

LISP 完全不同，因为它的基本语义规则既不是基于 lambda 演算，也不是基于术语重写。因此，LISP 需要一些不同的机制来维护范围规则。它采用了基于环境数据结构保存变量到值映射（即变量绑定）的机制。在 LISP 的新变体中的环境中可能存在更复杂的结构（例如，词法范围的 Lisp 允许突变），但最简单的结构在概念上等同于 Landin 论文定义的环境，如下所述。

LISP 实现在早期确实支持一流的函数，但是对于纯动态范围，没有真正的函数参数问题：它们可以避免堆栈上的分配并让全局所有者（GC、垃圾收集器）来管理引用变量的环境（和激活记录）中的资源。那时不需要闭包。这是闭包发明之前的早期实现。

近似于静态（词法）绑定的深度绑定是在 1962 年左右通过 FUNARG 设备在 LISP 1.5 中引入的。这最终使这个问题以“Funarg 问题”的名义广为人知。

注意 AIM-199指出这主要是关于环境的。

Scheme 默认为 the first Lisp 方言 supporting lexical scoping（动态范围可以通过现代版本的 Scheme 中的 make-parameter/parameterize 形式模拟）。在后来的十年中进行了一些辩论，但最终大多数 Lisp 方言采用了默认词法作用域的想法，就像许多其他语言一样。从那时起，闭包作为一种实现技术在不同风格的 PL 中得到了更广泛的传播和流行。

闭包：演变

Landin 的原始论文首先将环境定义为将名称（“常量”）映射到命名对象（“原始”）的数学函数。然后，它将环境指定为“由名称/值对组成的列表结构”。后者也在早期的 Lisp 实现中作为 alists（关联列表）实现，但现代语言实现不一定遵循这样的细节。特别是，可以链接环境以支持嵌套闭包，这不太可能被 SECD 等抽象机器直接支持。

除了环境之外，Landin 论文中“环境部分”的另一个组件用于保存 lambda 抽象的绑定变量的名称（函数的形式参数）。当不需要反映源信息时，这对于现代实现来说也是可选的（并且可能缺少），其中参数的名称可以被静态优化掉（精神上由 lambda 演算的 alpha 重命名规则授予）。

类似地，现代实现可能不会将句法结构（AE 或 lambda 项）直接保存为控制部分。相反，它们可能使用一些内部 IR（中间表示）或“编译”形式（例如，某些 Lisp 方言实现使用的 FASL）。这样的 IR 甚至不能保证是从 lambda 形式生成的（例如，它可以来自一些命名函数的主体）。

此外，环境部分可以保存其他信息，而不是用于 lambda 演算的评估。例如，it can keep an extra identifier to provide additional binding naming the environment at the call site。这可以实现基于 lambda 演算扩展的语言。

重新审视特定于 PL 的术语

此外，一些语言可以在它们的规范中定义“闭包”相关的术语来命名实体可以由闭包实现。这是不幸的，因为它会导致许多误解，例如“闭包是一个函数”。但幸运的是，大多数语言似乎都避免将其直接命名为语言中的句法结构。

尽管如此，这仍然比语言规范任意重载更完善的通用概念要好。仅举几例：

“对象”被重定向到“类的实例”（在 Java/CLR/“OOP”语言中）而不是传统的“类型化存储”（在 C 和 C++ 中）或只是“值”（在许多 Lisps 中）；

“变量”被重定向到传统的称为“对象”（在 Golang 中）以及可变状态（在许多新语言中），因此它不再与数学和纯函数式语言兼容；

“多态性”仅限于包含多态性（在 C++/“OOP”语言中），即使这些语言确实具有其他类型的多态性（参数多态性和临时多态性）。

关于资源管理

尽管在现代实现中省略了组件，但 Landin 论文中的定义相当灵活。它不限制如何将环境等组件存储在 SECD 机器的上下文之外。

在实践中，使用了各种策略。最常见和最传统的方法是让所有资源都归一个全局所有者所有，该所有者可以收集不再使用的资源，即（全局）GC，首先在 LISP 中使用。

其他方式可能不需要全局所有者并且对闭包具有更好的局部性，例如：

在 C++ 中，允许用户显式管理闭包中捕获的实体资源，方法是指定如何捕获 lambda 表达式的捕获列表中的每个变量（通过值副本、通过引用，甚至通过显式初始化程序）和确切的类型每个变量（智能指针或其他类型）。这可能是不安全的，但如果使用得当，它会获得更大的灵活性。

在 Rust 中，资源是通过不同的捕获模式（通过不可变借用、借用、移动）依次尝试（由实现）捕获的，用户可以指定显式移动。这比 C++ 更保守，但在某种意义上更安全（因为与 C++ 中未经检查的引用捕获相比，借用是静态检查的）。

上述所有策略都可以支持闭包（C++ 和 Rust 确实有“闭包类型”概念的特定语言定义）。管理闭包使用的资源的规程与闭包的资格无关。

所以，（虽然这里没有看到）the claim of the necessity of graph tracing for closures by Thomas Lord at LtU 在技术上也是不正确的。闭包可以解决 funarg 问题，因为它可以防止对激活记录（堆栈）的无效访问，但事实并不能神奇地断言对包含闭包的资源的每个操作将都是有效的。这种机制依赖于外部执行环境。应该清楚，即使在传统的实现中，隐式所有者（GC）也不是闭包中的一个组件，而所有者的存在是 SECD 机器的实现细节（因此它是给用户的“高阶”细节）。这样的细节是否支持图追踪对闭包的限定没有影响。此外，AFAIK，the language constructs let combined with rec is first introduced (again by P. Landin) in ISWIM in 1966，它无法强制执行比它自己更早发明的闭包的原始含义。

关系

因此，总结起来，闭包可以（非正式地）定义为：

(1) PL 实现特定的数据结构，包括作为功能类实体的环境部分和控制部分，其中：

(1.1) 控制部分源自一些源语言结构，指定了类函数实体的求值结构；

(1.2) 环境部分由环境和可选的其他实现定义的数据组成；

(1.3) (1.2) 中的环境由类函数实体的潜在上下文相关源语言构造确定，用于保存捕获的自由变量，出现在创建类函数实体的源语言构造的评估构造中.

(2) 或者，使用 (1) 中名为“闭包”的实体的实现技术的总称。

Lambda 表达式（抽象）只是源语言中用于引入（创建）未命名的类函数实体的句法结构之一。 PL 可以提供它作为引入类函数实体的唯一方式。

一般来说，源程序中的 lambda 表达式与程序执行过程中是否存在闭包之间没有明确的对应关系。由于实现细节对程序的可观察行为没有影响，PL 实现通常允许在可能的情况下合并为闭包分配的资源，或者在对程序语义无关紧要时完全省略创建它们：

该实现可以检查lambda表达式中要捕获的自由变量的集合，当集合为空时，可以避免引入环境部分，因此类函数实体不需要维护闭包。这种策略通常在静态语言的规则中强制执行。

否则，实现可能会或可能不会总是为通过评估 lambda 表达式是否有要捕获的变量而产生的类函数实体创建闭包。

Lambda 表达式可以计算为类似函数的实体。一些 PL 的用户可能将这种类似函数的实体称为“闭包”。在这种情况下，“匿名函数”应该是这种“闭包”的更中性名称。

附录：函数：凌乱的历史

这与问题没有直接关系，但值得注意的是“函数”可以在不同的上下文中命名不同的实体。

它已经是 a mess in mathematics。

目前我懒得在 PL 的上下文中总结它们，但作为警告：密切关注上下文以确保不同 PL 中“功能”的各种定义不会使你的推理偏离主题。

至于一般使用“匿名函数”（在实践中由 PL 共享），我相信它不会在这个主题上引入重大的混淆和误解。

命名函数可能会有更多的问题。函数可以表示名称本身的实体（“符号”），以及这些名称的评估值。鉴于大多数 PL 没有未评估的上下文来区分函数与其他一些带有有趣含义的实体（例如，C++ 中的 sizeof(a_plain_cxx_function) 格式错误），用户可能不会观察到未评估操作数和评估值。对于某些具有 QUOTE 的 Lisp 方言，这将是一个问题。 Even experienced PL specialists can easily miss something important;这也是我强调区分句法结构与其他实体的原因。

---

这取决于函数是否使用外部变量来执行操作。

外部变量 - 定义在函数范围之外的变量。

Lambda 表达式是无状态的，因为它依赖于参数、内部变量或常量来执行操作。函数<整数,整数> lambda = t -> { int n = 2 return t * n }

闭包保持状态是因为它使用外部变量（即定义在函数体范围之外的变量）以及参数和常量来执行操作。 int n = 2 Function 闭包 = t -> { return t * n }

当 Java 创建闭包时，它会将变量 n 保存在函数中，以便在传递给其他函数或在任何地方使用时都可以引用它。

---

这个问题已经有 12 年历史了，我们仍然将它作为 Google 中“closures vs lambda”的第一个链接。所以我不得不说，因为没有人明确表示。

Lambda 表达式是一个匿名函数（声明）。

引用 Scott 的 Programming Language Pragmatics 的闭包解释为：

...创建引用环境的显式表示（通常是当前调用子例程将在其中执行的环境）并将其与对子例程的引用捆绑在一起...称为闭包。

也就是我们所说的“函数+放弃上下文”的捆绑。

---

Lambda 是一个匿名函数定义，未（必然）绑定到标识符。

“匿名函数起源于 Alonzo Church 在他发明的 lambda 演算中的工作，其中所有函数都是匿名的” - 维基百科

闭包是 lambda 函数的实现。

“Peter J. Landin 在 1964 年将术语闭包定义为具有环境部分和控制部分，供他的 SECD 机器用于评估表达式” - 维基百科

Lambda 和 Closure 的一般解释在其他响应中进行了介绍。

对于那些具有 C++ 背景的人，Lambda 表达式是在 C++11 中引入的。将 Lambda 视为创建匿名函数和函数对象的便捷方式。

“一个 lambda 和对应的闭包之间的区别恰恰等同于一个类和一个类的一个实例之间的区别。一个类只存在于源代码中；它在运行时不存在。运行时存在的是类类型。闭包之于 lambda 就像对象之于类一样。这不足为奇，因为每个 lambda 表达式都会导致生成一个唯一的类（在编译期间），并且还会导致该类类型的对象，即创建闭包（在运行时）。” - 斯科特迈尔斯

C++ 允许我们检查 Lambda 和 Closure 的细微差别，因为您必须明确指定要捕获的自由变量。

在下面的示例中，Lambda 表达式没有自由变量，一个空的捕获列表 ([])。它本质上是一个普通函数，在最严格的意义上不需要闭包。所以它甚至可以作为函数指针参数传递。

void register_func(void(*f)(int val))   // Works only with an EMPTY capture list
{
    int val = 3;
    f(val);
}
 
int main() 
{
    int env = 5;
    register_func( [](int val){ /* lambda body can access only val variable*/ } );
}

一旦在捕获列表 ([env]) 中引入来自周围环境的自由变量，就必须生成一个闭包。

    register_func( [env](int val){ /* lambda body can access val and env variables*/ } );

由于这不再是一个普通的函数，而是一个闭包，所以它会产生编译错误。
no suitable conversion function from "lambda []void (int val)->void" to "void (*)(int val)" exists

可以使用函数包装器 std::function 修复该错误，该函数包装器接受任何可调用目标，包括生成的闭包。

void register_func(std::function<void(int val)> f)

有关 C++ 示例的详细说明，请参阅 Lambda and Closure。

---