在Groovy中有一个简单的例子供您参考:

def outer() {
    def x = 1
    return { -> println(x)} // inner
}
def innerObj = outer()
innerObj() // prints 1

闭包是一个可以引用另一个函数中的状态的函数。例如，在Python中，它使用闭包"inner":

def outer (a):
    b = "variable in outer()"
    def inner (c):
        print a, b, c
    return inner

# Now the return value from outer() can be saved for later
func = outer ("test")
func (1) # prints "test variable in outer() 1

这里有一个现实世界的例子，为什么闭包这么厉害…这是我的Javascript代码。让我举例说明。

Function.prototype.delay = function(ms /*[, arg...]*/) {
  var fn = this,
      args = Array.prototype.slice.call(arguments, 1);

  return window.setTimeout(function() {
      return fn.apply(fn, args);
  }, ms);
};

下面是你如何使用它:

var startPlayback = function(track) {
  Player.play(track);  
};
startPlayback(someTrack);

现在，假设您希望回放延迟开始，例如在此代码段运行后5秒。这对于延迟来说是很容易的，它是封闭的:

startPlayback.delay(5000, someTrack);
// Keep going, do other things

当你调用delay为5000ms时，第一个代码段运行，并将传入的参数存储在它的闭包中。然后5秒后，当setTimeout回调发生时，闭包仍然维护这些变量，因此它可以使用原始参数调用原始函数。 这是一种咖喱，或功能装饰。

如果没有闭包，您将不得不以某种方式在函数外部维护这些变量的状态，从而将函数外部的代码丢弃在逻辑上属于函数内部的代码中。使用闭包可以极大地提高代码的质量和可读性。

从Lua.org:

当一个函数被封装在另一个函数中编写时，它可以完全访问封装函数中的局部变量;这个特性称为词法作用域。尽管这听起来很明显，但事实并非如此。词法作用域加上第一类函数是编程语言中一个强大的概念，但很少有语言支持这个概念。

变量作用域

声明局部变量时，该变量具有作用域。一般来说，局部变量只存在于声明它们的块或函数中。

function() {
  var a = 1;
  console.log(a); // works
}    
console.log(a); // fails

如果我试图访问一个局部变量，大多数语言都会在当前作用域中查找它，然后向上遍历父作用域，直到到达根作用域。

var a = 1;
function() {
  console.log(a); // works
}    
console.log(a); // works

当一个块或函数被处理完，它的局部变量就不再需要了，通常会耗尽内存。

这就是我们通常期望的事情的运作方式。

闭包是一个持久的局部变量作用域

闭包是一个持久作用域，即使在代码执行已经移出该块之后，它仍然保留局部变量。支持闭包的语言(如JavaScript、Swift和Ruby)将允许您保留对作用域(包括其父作用域)的引用，即使在声明这些变量的块已经完成执行之后，只要您在某处保留对该块或函数的引用。

作用域对象及其所有局部变量都绑定到函数，只要函数存在，它们就会存在。

这给了我们函数可移植性。我们可以预期，在函数第一次定义时在作用域中的任何变量，在稍后调用该函数时仍然在作用域中，即使我们在完全不同的上下文中调用该函数。

例如

下面是一个非常简单的JavaScript示例，可以说明这一点:

outer = function() {
  var a = 1;
  var inner = function() {
    console.log(a);
  }
  return inner; // this returns a function
}

var fnc = outer(); // execute outer to get inner 
fnc();

这里我定义了一个函数中的函数。内部函数可以访问外部函数的所有局部变量，包括a。变量a在内部函数的作用域内。

正常情况下，当一个函数退出时，它的所有局部变量都会消失。但是，如果我们返回inner函数并将其赋值给变量fnc，以便在outer退出后它仍然存在，那么定义inner时在作用域内的所有变量也将仍然存在。变量a已经被关闭了——它在一个闭包中。

注意变量a对于fnc是完全私有的。这是在函数式编程语言(如JavaScript)中创建私有变量的一种方式。

正如你可能猜到的那样，当我调用fnc()时，它会打印a的值，即“1”。

在没有闭包的语言中，当函数outer退出时，变量a将被垃圾收集并丢弃。调用fnc将抛出一个错误，因为a不再存在。

在JavaScript中，变量a持续存在，因为变量作用域是在函数第一次声明时创建的，并且只要函数继续存在，变量a就会持续存在。

A属于outer的范围。inner的作用域有一个父指针指向outer的作用域。FNC是一个指向内的变量。只要FNC存在，A就存在。A在闭包内。

进一步阅读(观看)

我制作了一个YouTube视频，介绍了这段代码的一些实际使用示例。

curry:它允许你通过只传入函数参数的子集来部分求值。考虑一下:

function multiply (x, y) {
  return x * y;
}

const double = multiply.bind(null, 2);

const eight = double(4);

eight == 8;

闭包:闭包只不过是访问函数作用域之外的变量。重要的是要记住，函数中的函数或嵌套函数不是闭包。当需要访问函数作用域外的变量时，总是使用闭包。

function apple(x){
   function google(y,z) {
    console.log(x*y);
   }
   google(7,2);
}

apple(3);

// the answer here will be 21