你的位置:首页 > Java教程

[Java教程]对js闭包的粗浅理解


  只能是粗浅的,毕竟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)进行复制一份,不会生成一个静态快照,而是共享,当这个成员的值改变时,它们返回的值也跟着变化。

  战战兢兢写完,感觉还是要加深理解-_-