Closures 闭包

        在编程语言中，闭包（词法闭包or函数闭包）是一种在支持first-class functions语言中，实现词法作用域的名字绑定的技术。操作实现上，闭包指将函数与其环境一起保存起来的记录：当闭包被创建时，映射关联每个函数的非局部（本地）变量 到 它的值或者名字已被限制的存储位置。闭包不同于普通的函数，允许函数访问这些通过闭包引用而捕获的变量，甚至在变量作用域之外调用函数。 

        例子： 以下程序片断定义了高阶函数 startAt ，它包括x参数和一个嵌套的函数incrementBy。嵌套的函数访问了x，因为incrementBy在x的词义作用域中，即使x不在incrementBy本地。函数 startAt返回了容纳了函数incrementBy的闭包，incrementBy将y的值与x的值相加，也从startAt的这次调用返回了x变量的引用，于是incrementBy一旦被调用就知道去哪里找到x：

function startAt(x)
   function incrementBy(y)
       return x + y
   return incrementBy

variable closure1 = startAt(1)
variable closure2 = startAt(5)

       注意，因为startAt返回的是函数，变量closure1和 closure2是函数类型的。closure1(3)调用将返回4，而closure2(3)将返回8。因为closure1和closure2引用同一个函数incrementBy，关联的环境不同。所以在两次调用中，调用的闭包绑定名字x到值不同的不同变量。最终函数得到不同的结果。

In programming languages, closures (also lexical closures or function closures) are a technique for implementing lexically scoped name binding in languages with first-class functions. Operationally, a closure is a record storing a function together with an environment: a mapping associating each free variable of the function (variables that are used locally, but defined in an enclosing scope) with the value or storage location to which the name was bound when the closure was created. A closure—unlike a plain function—allows the function to access those captured variables through the closure's reference to them, even when the function is invoked outside their scope.

Example. The following program fragment defines a higher-order function startAt with a parameter x and a nested function incrementBy. The nested function incrementBy has access to x, because incrementBy is in the lexical scope of x, even though x is not local to incrementBy. The function startAt returns a closure containing the function incrementBy, which adds the y value to the x value, and a reference to the variable x from this invocation of startAt, so incrementBy will know where to find it once invoked:

function startAt(x)
   function incrementBy(y)
       return x + y
   return incrementBy

variable closure1 = startAt(1)
variable closure2 = startAt(5)

Note that, as startAt returns a function, the variables closure₁ and closure₂ are of function type. Invoking closure₁(3) will return 4, while invoking closure₂(3) will return 8. While closure₁ and closure₂ refer to the same function incrementBy, the associated environments differ, and invoking the closures will bind the name x to two distinct variables with different values in the two invocations, thus evaluating the function to different results.

原文链接： https://en.wikipedia.org/wiki/Closure_(computer_programming)

以下内容解释了：first-class functions和higher-order function

 1.     In computer science, a programming language is said to have first-class functions if it treats functions as first-class citizens. Specifically, this means the language supports passing functions as arguments to other functions, returning them as the values from other functions, and assigning them to variables or storing them in data structures. Some programming language theorists require support for anonymous functions (function literals) as well. In languages with first-class functions, thenames of functions do not have any special status; they are treated like ordinary variables with a function type. The term was coined by Christopher Strachey in the context of "functions as first-class citizens" in the mid-1960s.

2.  A function type depends on the type of the parameters and the result type of the function。

In mathematics and computer science, a higher-order function (also functional, functional form or functor) is a function that does at least one of the following:

• takes one or more functions as arguments 
• returns a function as its result.