JS匿名函数

函数声明与函数表达式的区别：(2点)

前者会在代码执行以前被加载到作用域中，而后者则是代码被执行到那一行时才会有定义。

函数声明会给函数指定一个名字，而函数表达式则是创建一个匿名函数，然后将这个匿名函数赋给一个变量。

递归

arguments.callee是一个指向正在执行的函数的指针。

//经典的递归阶乘函数
function factorial(num) {
    if (num<=1) {
        return 1;
    }else {
        return num * arguments.callee(num-1);
    }
}
debug(factorial(4));

闭包

闭包的概念很简单：一个闭包是一个函数及定义它的环境的组合。

例如，在一个函数A内部定义其他函数B时，就创建了闭包。闭包有权访问包含函数(A)内部的所有变量。

//返回一个函数
function createComparison(propertyName) {
    return function(obj1, obj2) {
        var value1 = obj1[propertyName],
            value2 = obj2[propertyName];
        //return value1 - value2;
        if (value1 > value2) {
            return 1;
        }else if(value1 < value2) {
            return -1;
        }else {
            return 0;
        }
    }
}
var compareName = createComparison('name');
debug(compareName({name:'mack'},{name:'an'}));        //1
compareName = null;        //解除对匿名函数的引用，释放内存

 

由于闭包会携带包含它的函数的作用域，因此会比其他函数占用更多的内存。

1. 闭包与变量

a． 当某个函数第一次被调用时，会创建一个执行环境及相应的作用域链，并把作用域链赋给一个特殊的内部属性([[scope]])。

b． 然后使用this、arguments和其他命名参数的值来初始化函数的活动对象。在作用域链中外部函数的活动对象处于第二位……

c． 在函数执行过程中，为读取和写入变量的值，需要在作用域链中查找变量。

闭包只能取得包含函数中任何变量的最后一个值：
function createFunctions() {
    var result = new Array();
    for (var i=0; i<10; i++) {
        result[i] = function() {
            return i;
        }
    }
    return result;
}
//funcs 存储的是10个匿名函数
var funcs = createFunctions();
//debug(funcs);
//输出数组中的元素值(全部都是10)
for (var i=0; i < funcs.length; i++) {
    debug(funcs[i]());
};
更改写法：
function createFunctions() {
    var result = new Array();
    for (var i=0; i<10; i++) {
        //把i的当前值赋值给局部变量
        result[i] = function(num) {
            return function() {
                return num;
            }
        }(i);
    }
    return result;
}
//funcs 存储的是10个匿名函数
var funcs = createFunctions();
//输出数组中的元素值(0.1..9)
for (var i=0; i < funcs.length; i++) {
    debug(funcs[i]());
}

      2.关于this对象

关于this对象(arguments存在同样的问题)

this对象是在运行时基于函数的执行环境绑定的，但匿名函数的执行环境具有全局性，因此this对象指向window.

var name = 'The Window';
var obj = {
    name: 'mackxu',
    getName: function() {
        return function() {
            return this.name;
        }
    }
};
debug(obj.getName()());        //The Window
//把外部作用域的this对象保存在一个闭包能够访问到的变量中
var name = 'The Window';
var obj = {
    name: 'mackxu',
    getName: function() {
        var that = this;
        return function() {
            return that.name;
        }
    }
};
debug(obj.getName()());        //mackxu

 

 　  3.IE中的内存泄露

如果闭包作用域链中保存着一个HTML元素，那么就意味着该元素将无法被销毁

function assignHandler() {
        //无法减少对element 的引用数
var element = document.getElementById(‘#id’);
        element.onclick = function() {
    debug(element.id);
};
}
解决办法：
function assignHandler() {
var element = document.getElementById(‘#id’);
var id = element.id;
        element.onclick = function() {
    debug(id);
};
element = null;
}

模仿块级作用域

Js没有块级作用域的概念

Js没有块级作用域的概念
function output() {
    //在for中定义的变量i，可以在for外面访问
    for (var i=0; i<10; i++) {
        //...
    }
    debug(i);        //output:10
}
output();
私有作用域：用作块级作用域的匿名函数，函数被执行后，里面的变量会马上销毁
(function(){
    //这里是块级作用域
})();
改写上一个例子：
function output() {
    //匿名函数被执行后，i变量将被销毁
    (function(){
        for (var i=0; i<10; i++) {
            //...
        }
    })();
    debug(i);        //error
}

这种技术经常在全局作用域中被用在函数外面，限制向全局作用中添加过多的变量和函数。

私有变量

任何在函数中定义的变量，可认为是私有变量，因为不能在函数外部访问这些变量。

私有变量包括函数的参数、局部变量、在函数内定义的其他函数。

特权方法：有权访问私有变量和私有函数的公有方法。

function MyObject() {
    var private_var = 10;        //函数的私有变量
    //函数的私有方法
    function private_method() {
        return private_var;        //闭包能访问所在函数的所有属性
        //return 'private_method;
    }
    //特权方法[能访问私有变量、方法的公有方法]
    this.public_method = function() {
        private_var ++;
        return private_method();
    }
}

var obj = new MyObject();
debug(obj.public_method());

1. 静态私有变量[避免每个实例都要创建同一组新方法]

在私有作用域中定义私有变量或函数，同样也可以创建特权方法

(function() {
    //私有变量和函数
    //根据作用域链，private_var相对于特权方法(闭包)是外部函数的变量
    //其会变成一个静态的、由所有实例共享的属性[可以想象原型链继承父类的属性]
    var private_var = 10;
    function private_func() {
        return 'private function';
    }
    //没有被var声明，会自动添加到全局对象中
    MyObject = function() {};
    MyObject.prototype.public_method = function() {
        private_var ++;
        private_func();
        return 'OK';
    };
})();
//可以在私有作用域外，访问MyObject
var obj = new MyObject();
debug(obj.public_method());
送上一个实例说明：
(function() {
    var name = '';        //静态私有变量
    
    Person = function(value) {
        name = value;
    };
    Person.prototype.getName = function() {
        return name;
    };
    Person.prototype.setName = function(value) {
        name = value;
    };
})();

var p1 = new Person('mackxu');
debug(p1.getName());        //mackxu
var p2 = new Person('zhangsan');
debug(p2.getName());        //zhangsan
p2.setName('anan');
debug(p1.getName());        //anan

 

模块模式 

JavaScript是以对象字面量的方式来创建单例对象的。

//函数返回的是对象
var singleton = function() {
    //私有变量和方法
    var private_var = 10;
    function private_func() {
        return 'private function';
    }
    
    //返回公有方法和属性
    return {
        public_var: 22,
        public_method: function() {
            //访问私有变量和函数
            private_var ++;
            return private_func();
        }
    };
}();
debug(singleton.public_method());

这个模式在需要对单例进行某些初始化，同时又需要维护其私有变量时很有用。

增强的模块模式

单例必须是某种类型的实例

function CustomType() {
    //...
}
//函数返回的是对象
var singleton = function() {
    //私有变量和方法
    var private_var = 10;
    function private_func() {
        return 'private function';
    }
    
    //创建特定类型的对象，并返回
    var obj = new CustomType();
    //添加公有方法和属性
    obj.public_var = true;
    obj.public_method = function() {
        private_var++;
        return private_func();
    }
    return obj;
}();

debug(singleton.public_method());
debug(singleton instanceof CustomType);        //true