只能是粗浅的,毕竟js用法太灵活。
首先抛概念:闭包(closure)是函数对象与变量作用域链在某种形式上的关联,是一种对变量的获取机制。这样写鬼能看懂。
所以要大致搞清三个东西:函数对象(function object)、作用域链(scope chain)以及它们如何关联(combination)
首先要建立一个印象,在js中,几乎所有的东西可以看作对象,除了null和undefined。比如常用的数组对象、日期对象、正则对象等。
var num = 123; // Number var arr = [1,2,3]; // Array var str = "hello"; // String
数字原始值可以看作Number对象,字符串原始值可看做String对象,数组原始值可看作Array对象。有的原始值还可直接调方法,如数组、正则,有的不行
[1,2,3].toString(); // 可以 /\w+/.toString(); // 可以 123.toString(); // 报错
当用一个变量名呈接它时,又能够这样用
var num = 123; num.toString();
所以,函数也可以是一个对象,函数细说起来又要扯一大堆,毕竟是js精华,简单说这里有用的。函数的定义常见的是
function fun1(val){ } fun1(5); var f1 = function(val){ }; // 定义一个函数赋给变量 f1(6); var f2 = function fun2(){ }; // 或者取一个函数名 f2();
因为函数也是对象、变量,所以可以赋给一个变量(更准确说是赋给左值),在这个变量后面使用()调用运算符就可以调用这个函数了,如f1()。还有一种方式:定义即调用
var num = (function(val){ return val * val; }(5)); // num为25
在定义一个函数体后面加上()和参数(或者没有参数),就是对这个定义的函数进行了调用,直接传入参数5计算并赋值给num,因此num是一个数值变量而不是函数变量。
既然函数是对象,当然也有new关键字的表达式
var a = new Array(1,2,3); // 数组的对象创建表达式 var f = new Function("x", "y", "x = 2 *x; return x + y;"); // 函数对象创建表达式 var f1 = function(x, y){ // 函数f的函数体类似f1的定义 x = 2 * x; return x + y; };
函数对象的创建使用了Function关键字,前面的参数均被当做对象创建函数的形参,如这里的x、y,最后一个字符串是函数的函数体,多行函数体仍以;相隔。
很多时候特别是使用jQuery时经常看到函数调用时传递函数,大多数时候直接写匿名函数,也可可传递一个函数变量
func(index, function(val){ /* 匿名函数 */ }); var f = function(val){ /* 函数变量 */ }; func1(index, f);
既然函数函数是对象,可以赋给一个变量,自然也可以作为返回值了,而且在js中,函数可以嵌套定义。
function func(){ return function(x){ // 返回一个函数变量 return x * x; } } var f = func(); f(5); // 对这个函数进行调用 function func1(){ function nested1(){ } // 嵌套定义函数 function nested2(){ } }
对函数有个大致了解,说说变量作用域问题,有几个原则:
1. 全局变量拥有全局作用域.
2. 局部变量(一般指定义在函数内部)拥有局部作用域(包括其嵌套的函数).
3. 在局部变量若跟全局变量重名,优先使用局部变量.
val = ‘value‘; // 变量定义可以不用var关键字 document.write("val=>" + val + "<br/>"); // g是全局变量,在全局作用域中有效,所以在给g初始化之前就可以访问,只是值是undefined document.write("g=>" + g ); var g = ‘google‘;
全局变量的定义,相当于是全局对象的属性,一般我们用this指代这个全局对象,比如在浏览器中运行的时候,它指的是window对象,即当前窗体,在全局作用域中,以下三种访问形式等效
var g = ‘google‘; document.write("g=>" + g + "<br/>"); document.write("g=>" + this.g + "<br/>"); document.write("g=>" + window.g + "<br/>");
而在函数定义内部访问变量时,遵循同名优先,函数作用域内部总是优先访问,例如
var scope = "global"; function func1(){ var scope = "local"; console.log(scope); // local }; func1(); function func2(){ scope = ‘changed global‘; // 如不加var,改变的是全局变量的值 }; func2(); console.log(scope); // changed global
比较有意思的地方是,如果在一个函数内部给一个全局变量赋值时没有加var关键字,如func2,它改变的是全局作用域变量的值!而前面说的this,也有个有意思的地方
var scope = "global"; function func(){ var scope = "local" console.log(scope); // local console.log(this.scope); // global } func();
在局部作用域(这里均指函数内部),如果有同名变量,以this引用的话,结果是全局变量,即,在函数内部(注意不是方法,方法一般指对象的属性方法),this指代的是全局的对象。再看一个
var scope = "global"; function func(){ "use strict"; // 开启ECMAScript5严格模式 console.log(this); // undefined console.log(this.scope); // 报错:TypeError: scope undefined } func();
在严格模式中,对语法检查更加严格。在一个全局作用域定义的普通函数中,log打印this是undefined,所以this引用scope当然也不存在。
在ECMAScript(为js脚本制定的一个标准)中,强制规定全局作用域定义的变量,是全局对象(比如在浏览器客户端运行时为window,默认的全局中的this关键字也是指它,通常我们说的就是这个)的属性。一般我们把跟某个变量作用域相关的对象为上下文环境(context),比如全局对象this只要涉及环境这类偏底层的东西肯定就是编程语言层面自己规定的。
但这个全局对象this限于非严格模式的情况。js允许我们在局部变量的环境中(函数)以this引用全局对象,在严格模式下却没法这样干,也许是它把这个对象给隐藏了,至少目前这样写会报错。
正是js的函数有局部作用域的特殊功能---全局作用域无法访问函数中定义的变量,所以在js中,也用函数规定命名空间,相比其他有的语言使用的是namespace关键字,js目前好像是把namespace作为保留字,你的变量的命令不能跟它重名,但没投入使用。
(function(){ var name = "Jeff"; var age = 28; var pos = "development"; }()); // 在函数中定义一堆变量,外边无法访问
在一个函数中定义一堆变量,当然得调用它才能生效,这堆变量就限于在这个空间内使用了,好像用得也不多。
一个重要的点,一个函数中规定的变量,在这个函数内部所有地方都可访问,包括嵌套函数。所以可以出现下面这个现象
function func(){ console.log(num); // undefined,先于定义访问 var num = 123; console.log(num); // 123 } func();
这种特性有时被称为声明提前(hoisting),相当于这样
function func(){ var num; console.log(num); // undefined,先于定义访问 var num = 123; console.log(num); // 123 }
然后是嵌套函数,只要在函数内定义的,该函数内均能访问,看例子
function func(){ var str = "hello"; function nested1(){ // 第一次嵌套 str = "nested1"; function nested2(){ str = "nested2"; } // 第二次嵌套 nested2(); } nested1(); console.log(str); } func(); // 打印nested2
除了明确在函数内定义的变量,还有定义函数时的形参,它们在整个函数内也是可访问的。
现在我们大概了解函数也是对象,以及全局、局部作用域,在全局作用域定义的变量,是对应的全局对象的属性,也就是说有个全局对象关联它,就从这点进入作用域链(scope chain)吧,这是理解闭包的基础。
在一个局部作用域内,或者说定义的函数,想象它们关联着某个对象,这个对象是随着我们定义这个函数而自动生成的,函数内定义的变量以及函数的形参均是这个对象的属性,所以在这个对象内部总是可以顺利访问到它们,类似于全局变量是全局对象的属性。这种对象关联在定义时就已经决定了,而不是在调用时才形成(这很重要)。
但是我们定义的很多函数都是嵌套的,由外到内每个函数都会有一个对应的自定义对象跟它关联
var a = "a"; var name = "Michel"; function fun(b){ var c = "c"; var name = "Clark"; function nested(d){ var name = "Bruce"; var e = "e"; /* TODO */ } /* TODO */ }
在上面的嵌套函数nested生成一个自定义对象时,fun函数、全局作用域也会生成对象,因此它们可以形成一个对象的列表或者链表,简单的将函数名作为对象名,全局对象用global表示,并且从内嵌函数nested函数出发的话,大概是这样:
列表上的一组对象定义了这段代码作用域中定义过的变量:即它们的属性。第一个对象的属性是当前函数的形参与内定义变量,第二个对象是它的外部函数的形参与内定义变量,一直到最后是全局对象和它的属性---全局定义的变量,也就是说,当前函数永远在这个列表的最前面,这样才可以保证该函数范围内的变量总是具有最访问高优先级。每次访问变量时便会顺着这个列表查找,这被称为变量解析(variable resolution),如果一直找到列表末尾都找不到对象中的这个属性,会抛一个ReferenceError错误。
每个定义的函数对象都会有类似这样一个列表与之关联,它们之间通过这个作用域链相关联,而函数体内定义的变量均可保存在函数作用域内,这是在函数定义时及确定的,这种特性称之为闭包。 通常直接把函数称作闭包,而且理论上来说所有的js函数都是闭包,因为它们都是对象,闭包这种机制让js有能力来“捕捉”变量。第一个例子:
var scope = "global"; function func(){ var scope = "local"; function nested(){ return scope; } return nested(); // 调用并返回scope } console.log(func());
常规的定义和调用,嵌套函数的定义并调用在局部作用域中完成。它打印的是local。再看这个
var scope = "global"; function func(){ var scope = "local"; // 局部变量 function nested(){ return scope; } return nested; // 返回这个嵌套函数变量 } console.log(func()()); // 在全局作用域中调用局部的嵌套函数
前面说过,函数也是变量、对象,也可以作为函数返回值,func不直接返回变量,而返回一个内嵌函数,然后在全局作用域调用这个局部内嵌函数,它会返回什么呢?结果仍为local。由于闭包机制,nested函数在定义时就已经决定了,函数体内的scope变量值是local,这是一种绑定关系,不会随着调用环境的改变而改变,它去对象关联列表中查找按优先级分的话,总是func函数对应的scope值。
闭包的功能很强大,看这个例子(例A)
var integer = (function(){ var i = 0; return function(){ return i++; }; }()); console.log(integer()); // 0 console.log(integer()); // 1 console.log(integer()); // 2
如果有点C/C++基础的人,初看这个调用结果,很可能会说这个打印的是0,0,0,反正我是很小白的这样想,每次调用完,临时变量i就会被销毁。但是确实有打印0的情况,看下这个(例B)
function func(){ var i = 0; function nested(){ return i++; } return nested(); } console.log(func()); // 0 console.log(func()); // 0 console.log(func()); // 0
也就是说,这两个看起来差不多的函数还是有点差别的。
在C/C++中,如果不是全局变量或局部静态变量,只要在局部函数中定义的变量在调用一次完成后就马上被销毁,当然除使用malloc、realloc、new等函数开辟的动态空间除外,这种必须得手动释放,否则容易造成内存泄露。js中是垃圾自动回收机制,某些无用的东西会被自动销毁,在前两个例子中,例A显然没有被销毁,而例B中的变量被销毁了,因为每次调用都是新声明一个i变量。so why?
在C中,局部变量被临时保存在一个栈中,先调用的先入栈,后调用的后入栈,调用完从栈订弹出,变量内存被销毁,利用的是栈的后进先出特点。而js依靠的是作用域链,这是一个列表或者链表,并不是栈,没有所谓的压入(push)、弹出(pop)操作,如果说定义时就有一个列表的话,每次调用一个函数时,都会创建一个新的、跟它关联的对象,保存着局部变量,然后把这些对象添加至一个列表中形成作用域链,即便调用同一个函数两次,生成也是两个列表。
当一个函数执行完要返回的时候,便把对应对象从列表中删除,对象中的属性也会被销毁,意味着局部函数中的变量将不复存在,在例B中,return nested(),执行完返回一个值,nested函数再无任何作用,被从列表中删掉了。
如果一个局部函数定义了嵌套函数,并且有一个外部引用指向这个嵌套函数,就不会被当做垃圾回收。什么时候会有一个外部引用指向它(内嵌函数)?当它作为返回值(即返回一个函数变量),或者它作为某个对象属性的值存储起来时。不会被当成垃圾回收,它绑定的对象也不会从对象列表中删掉,这个绑定对象的属性和值自然也不会被销毁,自然可以进行复用了。所以再次调用其创建一个新的对象列表时,变量的值是在上一次调用的基础上改变的。
例A返回的是一个函数变量,意味着有一个外部引用指向着它:Hey!你可能会被调用哦,我不会删除你的。这样每次i是累加的。类似例A,如果将函数保存为一个对象的属性也不会被删除,例C
function counter(){ var n = 5; return { count: function(){ return n++; }, reset: function(){ n = 0; } }; } var countA = counter(); console.log(countA.count()); // 5 console.log(countA.count()); // 6 console.log(countA.count()); // 7
例C返回一个对象,对象的属性均是函数,也符合上边的情形,所以n值是累加的。这些情况下,通常我们会把类似定义的n称为这个外部函数的私有属性(成员),因为它们运行起来就像是函数的内嵌函数(闭包)共享的东西一样。前面说过,我们有时直接将函数称作闭包,尤其是同一个函数内部定义的函数
function func(){ var funArr = []; for(var i = 0; i <= 2; ++i) funArr[i] = function(){ return i; }; return funArr; } var farr = func(); console.log(farr[0]()); console.log(farr[1]()); console.log(farr[2]());
可以说:Here we create three closures, the are all defined in one function, so they share access to the variable i。那么它们输出神马?事实是,它们都打印3。它们共享变量,当func执行完时,i的值为3,所有的闭包均共享这个值。这个例子说明闭包的一个重要特点:所有闭包在与作用域链关联时是“活动的”,虽然函数一定义完成,作用域链就随着生成,但是所有闭包均不会单独对作用域内的私有成员(如上例中的i、例C中的n)进行复制一份,不会生成一个静态快照,而是共享,当这个成员的值改变时,它们返回的值也跟着变化。
战战兢兢写完,感觉还是要加深理解-_-