对以上示例的一部分理解:

对以上示例的一部分理解:

var add = function () 

{

    var counter = 0;

    alert("父方法"); // 只有在 add 赋值时执行一次

    var add_child = function(id) {

        var counter_res = 0;

        if(id === 1)

        {

            counter_res = counter + 1;

        }

        else if(id === 2)

        {

            counter++;

            counter_res += counter;

        }

        else

        {

          counter_res = 0;

        }

        alert("子方法");  // 每次执行 add() 都会执行

        return counter_res;

    };

    return add_child;

    // counter 作用域在父函数中, 自然在其子函数中也能使用,但因为

    // 子函数还需要使用count, 所以 count 不随着父函数一起释放。

    // 利用在 function(){}() 的形式自动执行一遍父匿名函数, 赋给 add 子方法。

}();

/*

add = function(){}，是一个函数的普通定义方式，

但是 add = function(){}()，会在add定义时即执行一次function(){}，

这样做的目的是为了给function(){}中的变量赋初始值，并将add_child=function(){}这个函数返回给add这个变量。

当以后执行add()这个函数时，其实执行的是add_child=function(){}。

这样做，闭包的目的就在于，你通过add这个对象访问不到counter这个变量，无形中创造了一个私有变量。

*/

add(1);

add(2);

add(2);

尝试一下 »

var add = function () 

{

    var counter = 0;

    alert("父方法"); // 只有在 add 赋值时执行一次

    var add_child = function(id) {

        var counter_res = 0;

        if(id === 1)

        {

            counter_res = counter + 1;

        }

        else if(id === 2)

        {

            counter++;

            counter_res += counter;

        }

        else

        {

          counter_res = 0;

        }

        alert("子方法");  // 每次执行 add() 都会执行

        return counter_res;

    };

    return add_child;

// counter 作用域在父函数中, 自然在其子函数中也能使用,但因为

// 子函数还需要使用count, 所以 count 不随着父函数一起释放。

// 利用在 function(){}() 的形式自动执行一遍父匿名函数, 赋给 add 子方法。

}();

/*

add = function(){}，是一个函数的普通定义方式，

但是 add = function(){}()，会在add定义时即执行一次function(){}，

这样做的目的是为了给function(){}中的变量赋初始值，并将add_child=function(){}这个函数返回给add这个变量。

当以后执行add()这个函数时，其实执行的是add_child=function(){}。

这样做，闭包的目的就在于，你通过add这个对象访问不到counter这个变量，无形中创造了一个私有变量。

*/

add(1);

add(2);

add(2);

执行结果：

父方法

子方法 1

子方法 1

子方法 2