这个问题已经12年了，我们仍然把它作为谷歌中“闭包vs lambda”的第一个链接。 所以我不得不说，因为没有人明确地说过。

Lambda表达式是一个匿名函数(声明)。

一个闭包，引用Scott的《编程语言语用学》解释为:

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

也就是说，它就像我们所说的“函数+投降上下文”的捆绑。

关于lambda和闭包有很多困惑，甚至在这个StackOverflow问题的答案中也是如此。与其询问那些从某些编程语言的实践中学习闭包的随机程序员或其他一无所知的程序员，不如去寻找源头(一切开始的地方)。因为Lambda和闭包来自于Lambda微积分，由Alonzo Church在30年代发明，那时第一台电子计算机还不存在，这就是我说的来源。

Lambda Calculus是世界上最简单的编程语言。你唯一能做的事情是:►

APPLICATION: Applying one expression to another, denoted f x.(Think of it as a function call, where f is the function and x is its only parameter) ABSTRACTION: Binds a symbol occurring in an expression to mark that this symbol is just a "slot", a blank box waiting to be filled with value, a "variable" as it were. It is done by prepending a Greek letter λ (lambda), then the symbolic name (e.g. x), then a dot . before the expression. This then converts the expression into a function expecting one parameter.For example: λx.x+2 takes the expression x+2 and tells that the symbol x in this expression is a bound variable – it can be substituted with a value you supply as a parameter. Note that the function defined this way is anonymous – it doesn't have a name, so you can't refer to it yet, but you can immediately call it (remember application?) by supplying it the parameter it is waiting for, like this: (λx.x+2) 7. Then the expression (in this case a literal value) 7 is substituted as x in the subexpression x+2 of the applied lambda, so you get 7+2, which then reduces to 9 by common arithmetics rules.

所以我们解开了其中一个谜团: 是上面例子中的匿名函数，λx.x+2。 在不同的编程语言中，函数抽象(lambda)的语法可能不同。例如，在JavaScript中是这样的:

function(x) { return x+2; }

你可以马上把它应用到这样的参数上:

(function(x) { return x+2; })(7)

或者你可以将这个匿名函数(lambda)存储到某个变量中:

var f = function(x) { return x+2; }

这实际上给了它一个名字f，允许你引用它，并在以后多次调用它，例如:

alert(  f(7) + f(10)  );   // should print 21 in the message box

但你不需要说出它的名字。你可以立即调用它:

alert(  function(x) { return x+2; } (7)  );  // should print 9 in the message box

在LISP中，lambda是这样的:

(lambda (x) (+ x 2))

你可以通过将它立即应用到一个参数来调用这样的lambda:

(  (lambda (x) (+ x 2))  7  )

好了，现在是时候解决另一个谜团了:什么是闭包。 为了做到这一点，让我们讨论一下lambda表达式中的符号(变量)。

As I said, what the lambda abstraction does is binding a symbol in its subexpression, so that it becomes a substitutible parameter. Such a symbol is called bound. But what if there are other symbols in the expression? For example: λx.x/y+2. In this expression, the symbol x is bound by the lambda abstraction λx. preceding it. But the other symbol, y, is not bound – it is free. We don't know what it is and where it comes from, so we don't know what it means and what value it represents, and therefore we cannot evaluate that expression until we figure out what y means.

事实上，另外两个符号2和+也是如此。只是我们对这两个符号太熟悉了，以至于我们经常忘记计算机不认识它们，我们需要通过在某个地方定义它们来告诉它它们的意思，例如在图书馆或语言本身。

你可以认为自由符号是在表达式之外的其他地方定义的，在它的“周围上下文”中，这被称为它的环境。环境可能是一个更大的表达式，这个表达式是其中的一部分(就像奎冈·金说的:“总有更大的鱼”;))，或者在一些库中，或者在语言本身中(作为原始语言)。

这让我们将lambda表达式分为两类:

CLOSED表达式:出现在这些表达式中的每个符号都被一些lambda抽象绑定。换句话说，它们是独立的;它们不需要任何周围的上下文来计算。它们也被称为组合子。 OPEN表达式:这些表达式中的一些符号是不绑定的——也就是说，其中出现的一些符号是自由的，它们需要一些外部信息，因此在您提供这些符号的定义之前，它们不能被求值。

你可以通过提供环境来关闭一个开放lambda表达式，环境通过将这些自由符号绑定到一些值(可能是数字、字符串、匿名函数或lambdas等等)来定义所有这些自由符号。

下面是结尾部分: lambda表达式的闭包是在外部上下文(环境)中定义的一组特定的符号，这些符号为表达式中的自由符号赋值，使它们不再是自由的。它将一个仍然包含一些“未定义的”自由符号的开放lambda表达式转换为一个不再包含任何自由符号的封闭lambda表达式。

例如，如果你有这样的λ表达式:λx。X /y+2，符号X是有界的，而符号y是自由的，因此表达式是开放的，除非你说出y的意思，否则无法计算(+和2也是一样，它们也是自由的)。但假设你也有一个这样的环境:

{  y: 3,
+: [built-in addition],
2: [built-in number],
q: 42,
w: 5  }

这个环境为lambda表达式(y， +， 2)中的所有“未定义”(自由)符号和几个额外的符号(q, w)提供定义。我们需要定义的符号是环境的这个子集:

{  y: 3,
+: [built-in addition],
2: [built-in number]  }

这正是lambda表达式的闭包:>

换句话说，它关闭了一个开lambda表达式。这就是名称闭包最初的来源，这也是为什么在这个帖子中有那么多人的答案不太正确的原因:P 那么，他们为什么错了呢?为什么这么多人说闭包是内存中的一些数据结构，或者他们使用的语言的一些特性，或者为什么他们把闭包和lambdas混淆?: P

Well, the corporate marketoids of Sun/Oracle, Microsoft, Google etc. are to blame, because that's what they called these constructs in their languages (Java, C#, Go etc.). They often call "closures" what are supposed to be just lambdas. Or they call "closures" a particular technique they used to implement lexical scoping, that is, the fact that a function can access the variables that were defined in its outer scope at the time of its definition. They often say that the function "encloses" these variables, that is, captures them into some data structure to save them from being destroyed after the outer function finishes executing. But this is just made-up post factum "folklore etymology" and marketing, which only makes things more confusing, because every language vendor uses its own terminology.

更糟糕的是，他们说的话总有一点是真的，这让你不能轻易地把它当作错误来看待。

If you want to implement a language that uses lambdas as first-class citizens, you need to allow them to use symbols defined in their surrounding context (that is, to use free variables in your lambdas). And these symbols must be there even when the surrounding function returns. The problem is that these symbols are bound to some local storage of the function (usually on the call stack), which won't be there anymore when the function returns. Therefore, in order for a lambda to work the way you expect, you need to somehow "capture" all these free variables from its outer context and save them for later, even when the outer context will be gone. That is, you need to find the closure of your lambda (all these external variables it uses) and store it somewhere else (either by making a copy, or by preparing space for them upfront, somewhere else than on the stack). The actual method you use to achieve this goal is an "implementation detail" of your language. What's important here is the closure, which is the set of free variables from the environment of your lambda that need to be saved somewhere.

没过多久，人们就开始将他们在语言实现中使用的实际数据结构称为“闭包”本身。结构通常是这样的:

Closure {
   [pointer to the lambda function's machine code],
   [pointer to the lambda function's environment]
}

这些数据结构作为参数传递给其他函数，从函数返回，并存储在变量中，以表示lambdas，并允许它们访问其封闭环境以及在该上下文中运行的机器代码。但这只是实现闭包的一种方法(众多方法之一)，而不是闭包本身。

如上所述，lambda表达式的闭包是其环境中定义的子集，这些定义将值赋给该lambda表达式中包含的自由变量，从而有效地关闭表达式(将目前还不能求值的开放lambda表达式转换为随后可以求值的封闭lambda表达式，因为现在已经定义了其中包含的所有符号)。

其他任何东西都只是程序员和语言供应商的“货物崇拜”和“巫毒魔法”，他们不知道这些概念的真正根源。

我希望这能回答你的问题。但如果你有任何后续问题，请在评论中提出，我会试着更好地解释。

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

外部变量——定义在函数作用域之外的变量。

Lambda表达式是无状态的，因为它依赖于参数、内部变量或常量来执行操作。 函数<Integer,Integer> lambda = t -> { Int n = 2 返回t * n ｝ 闭包保持状态，因为它使用外部变量(即函数体范围之外定义的变量)以及参数和常量来执行操作。 Int n = 2 函数<Integer,Integer>闭包= t -> { 返回t * n ｝

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

Lambda vs闭包

是匿名函数(方法)

闭包是封闭(捕获)其封闭范围内的变量的函数。非本地变量)

Java

interface Runnable {
    void run();
}

class MyClass {
    void foo(Runnable r) {

    }

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

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

斯威夫特(结束)

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

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

Lambda是一个匿名函数定义，它(不一定)绑定到标识符。

“匿名函数起源于阿朗佐·丘奇(Alonzo Church)发明的lambda微积分，其中所有函数都是匿名的”——维基百科

闭包是lambda函数的实现。

Peter J. Landin在1964年将闭包定义为拥有一个环境部分和一个控制部分，由他的SECD机器用于计算表达式

Lambda和闭包的一般解释在其他响应中涵盖。

对于c++背景的人来说，Lambda表达式是在c++ 11中引入的。可以把Lambdas看作是一种创建匿名函数和函数对象的方便方法。

"The distinction between a lambda and the corresponding closure is precisely equivalent to the distinction between a class and an instance of the class. A class exists only in source code; it doesn’t exist at runtime. What exists at runtime are objects of the class type. Closures are to lambdas as objects are to classes. This should not be a surprise, because each lambda expression causes a unique class to be generated (during compilation) and also causes an object of that class type, a closure to be created (at runtime)." - Scott Myers

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])中引入了来自周围环境的自由变量，就必须生成一个Closure。

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

由于这不再是一个普通的函数，而是一个闭包，因此会产生编译错误。 不存在从"lambda []void (int val)->void"到"void (*)(int val)"的合适转换函数

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

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

有关c++示例的详细解释，请参阅Lambda和闭包。