具有公共接口的私有变量

它使用了一个简洁的小技巧，即自调用函数定义。 返回的对象中的所有内容在公共接口中都是可用的，而其他所有内容都是私有的。

var test = function () {
    //private members
    var x = 1;
    var y = function () {
        return x * 2;
    };
    //public interface
    return {
        setx : function (newx) {
            x = newx;
        },
        gety : function () {
            return y();
        }
    }
}();

assert(undefined == test.x);
assert(undefined == test.y);
assert(2 == test.gety());
test.setx(5);
assert(10 == test.gety());

正如Marius已经指出的，可以在函数中使用公共静态变量。

我通常使用它们来创建只执行一次的函数，或者缓存一些复杂的计算结果。

下面是我以前的“单例”方法的例子:

var singleton = function(){ 

  if (typeof arguments.callee.__instance__ == 'undefined') { 

    arguments.callee.__instance__ = new function(){

      //this creates a random private variable.
      //this could be a complicated calculation or DOM traversing that takes long
      //or anything that needs to be "cached"
      var rnd = Math.random();

      //just a "public" function showing the private variable value
      this.smth = function(){ alert('it is an object with a rand num=' + rnd); };

   };

  }

  return arguments.callee.__instance__;

};


var a = new singleton;
var b = new singleton;

a.smth(); 
b.smth();

如您所见，在这两种情况下构造函数都只运行一次。

For example, I used this approach back in 2004 when I had to create a modal dialog box with a gray background that covered the whole page (something like Lightbox). Internet Explorer 5.5 and 6 have the highest stacking context for <select> or <iframe> elements due to their "windowed" nature; so if the page contained select elements, the only way to cover them was to create an iframe and position it "on top" of the page. So the whole script was quite complex and a little bit slow (it used filter: expressions to set opacity for the covering iframe). The "shim" script had only one ".show()" method, which created the shim only once and cached it in the static variable :)

名称空间

在较大的JavaScript应用程序或框架中，在名称空间中组织代码可能很有用。JavaScript没有内置模块或名称空间概念，但使用JavaScript对象很容易模拟。这将创建一个名为n的命名空间，并将函数foo附加到它上面。

if (!window.ns) {
  window.ns = {};
}

window.ns.foo = function() {};

通常在整个项目中使用相同的全局名称空间前缀，并为每个JavaScript文件使用子名称空间。子名称空间的名称通常与文件名匹配。

一个叫做ns/button的文件头。应该是这样的:

if (!window.ns) {
  window.ns = {};
}
if (!window.ns.button) {
  window.ns.button = {};
}

// attach methods to the ns.button namespace
window.ns.button.create = function() {};

在这个帖子中有几个答案告诉你如何去做 通过Array对象的原型扩展Array对象。这很糟糕 IDEA，因为它破坏了语句中的for (i)。

如果你不使用for (i in a) 代码中的任何地方?除非你自己的代码是 只有您正在运行的代码，这是不太可能的 在浏览器内部。我担心如果人们开始扩张 他们的数组对象像这样，堆栈溢出将启动 充斥着一堆神秘的JavaScript错误。

点击这里查看有用的细节。

JavaScript使用Date()的方式让我很兴奋!

function isLeapYear(year) {
    return (new Date(year, 1, 29, 0, 0).getMonth() != 2);
}

这是真正的“隐藏特性”。

编辑:删除了评论中建议的“?”条件。 是:……new Date(year, 1,29,0,0).getMonth() != 2 ?真:假…… 详情请看评论。

闭包的禅意

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

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

// 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

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