你可以在任何对象上执行一个对象的方法，不管它是否有这个方法。当然，它可能并不总是有效(如果方法假设对象具有它没有的东西)，但它可能非常有用。例如:

function(){
    arguments.push('foo') // This errors, arguments is not a proper array and has no push method
    Array.prototype.push.apply(arguments, ['foo']) // Works!
}

闭包的禅意

其他人也提到了关闭。但令人惊讶的是，有那么多人知道闭包，使用闭包编写代码，但仍然对闭包的真正含义有错误的认识。有些人混淆了一级函数和闭包。但也有人认为它是一种静态变量。

对我来说，闭包是一种“私有”全局变量。这是一种变量，一些函数将其视为全局变量，而其他函数则看不到。现在，我知道这是在快速和松散地描述底层机制，但这就是它的感觉和行为。说明:

// Say you want three functions to share a single variable:

// Use a self-calling function to create scope:
(function(){

    var counter = 0; // this is the variable we want to share;

    // Declare global functions using function expressions:
    increment = function(){
        return ++counter;
    }
    decrement = function(){
        return --counter;
    }
    value = function(){
        return counter;
    }
})()

现在，增量、减量和值这三个函数共用一个变量counter，而不是一个实际的全局变量counter。这是闭包的真正本质:

increment();
increment();
decrement();
alert(value()); // will output 1

以上并不是闭包的真正有用的用法。事实上，我认为这样使用它是一种反模式。但是它对于理解闭包的性质是有用的。例如，大多数人在尝试做以下事情时会被发现:

for (var i=1;i<=10;i++) {
    document.getElementById('span'+i).onclick = function () {
        alert('this is span number '+i);
    }
}
// ALL spans will generate alert: this span is span number 10

这是因为他们不理解闭包的本质。他们认为他们把i的值传递给了函数，而实际上这些函数共享一个变量i，就像我之前说的，一个特殊的全局变量。

为了解决这个问题，你需要分离*闭包:

function makeClickHandler (j) {
    return function () {alert('this is span number '+j)};
}

for (var i=1;i<=10;i++) {
    document.getElementById('span'+i).onclick = makeClickHandler(i);
}
// this works because i is passed by reference 
// (or value in this case, since it is a number)
// instead of being captured by a closure

*注:我不知道这里的正确术语。

要将浮点数转换为整数，您可以使用以下神秘的技巧之一(请不要这样做):

3.14 >> 0(通过2.9999999999999999 >> .5?) 3.14 | 0(通过JavaScript中将浮点数转换为整数的最佳方法是什么?) 3.14 & -1 3.14 ^ 0 ~ ~ 3.14

基本上，对浮点数应用任何二进制操作都不会改变最终值(即恒等函数)，最终会将浮点数转换为整数。

你永远不需要使用eval()来组装全局变量名。

也就是说，如果你有几个名为spec_grapes, spec_apples的全局变量(无论出于什么原因)，你不需要用eval("spec_" + var)访问它们。

所有全局变量都是window[]的成员，所以你可以执行window["spec_" + var]。

知道一个函数需要多少个参数

function add_nums(num1, num2, num3 ){
    return num1 + num2 + num3;
}
add_nums.length // 3 is the number of parameters expected.

知道函数接收了多少参数

function add_many_nums(){
    return arguments.length;
}    
add_many_nums(2,1,122,12,21,89); //returns 6

除了公共成员外，还可以使用闭包创建具有私有(在“类”定义之外不可访问)静态成员和非静态成员的“类”。

注意，下面的代码中有两种类型的公共成员。特定于实例的(在构造函数中定义)，可以访问私有实例成员，共享成员(在原型对象中定义)只能访问私有静态成员。

var MyClass = (function () {
    // private static
    var nextId = 1;

    // constructor
    var cls = function () {
        // private
        var id = nextId++;
        var name = 'Unknown';

        // public (this instance only)
        this.get_id = function () { return id; };

        this.get_name = function () { return name; };
        this.set_name = function (value) {
            if (typeof value != 'string')
                throw 'Name must be a string';
            if (value.length < 2 || value.length > 20)
                throw 'Name must be 2-20 characters long.';
            name = value;
        };
    };

    // public static
    cls.get_nextId = function () {
        return nextId;
    };

    // public (shared across instances)
    cls.prototype = {
        announce: function () {
            alert('Hi there! My id is ' + this.get_id() + ' and my name is "' + this.get_name() + '"!\r\n' +
                  'The next fellow\'s id will be ' + MyClass.get_nextId() + '!');
        }
    };

    return cls;
})();

测试这段代码:

var mc1 = new MyClass();
mc1.set_name('Bob');

var mc2 = new MyClass();
mc2.set_name('Anne');

mc1.announce();
mc2.announce();

如果您有Firebug，您会发现除了在定义私有成员的闭包中设置断点之外，没有其他方法可以访问私有成员。

当定义需要严格验证值和完全控制状态更改的类时，这种模式非常有用。

要扩展这个类，你可以把MyClass.call(this);在扩展类的构造函数的顶部。您还需要复制MyClass。prototype对象(不要重用它，因为你也会改变MyClass的成员。

如果要替换announce方法，则需要调用MyClass。MyClass.prototype.announce.call(this);