关于ECMAScript 2015引入的类。其他答案并不完全清楚。

下面是一个示例，演示如何使用ClassName.var synthax创建静态var-staticVar：

class MyClass {
    constructor(val) {
        this.instanceVar = val;
        MyClass.staticVar = 10;
    }
}

var class1 = new MyClass(1);
console.log(class1.instanceVar);      // 1
console.log(class1.constructor.staticVar); // 10

// New instance of MyClass with another value
var class2 = new MyClass(3);
console.log(class1.instanceVar);      // 1
console.log(class2.instanceVar);      // 3

为了访问静态变量，我们使用.constructor属性，该属性返回对创建类的对象构造函数的引用。我们可以在两个创建的实例上调用它：

MyClass.staticVar = 11;
console.log(class1.constructor.staticVar); // 11
console.log(class2.constructor.staticVar); // 11 <-- yes it's static! :)

MyClass.staticVar = 12;
console.log(class1.constructor.staticVar); // 12
console.log(class2.constructor.staticVar); // 12

所以我从其他答案中看到的是，它们没有解决面向对象编程中静态属性的基本架构要求。

面向对象编程实际上有两种不同的风格，一种是基于类的（C++、C#、Java等），另一种是原型的（Javascript）。在基于类的语言中，“静态属性”应该与类关联，而不是与实例化对象关联。这个概念实际上在Javascript这样的原型语言中更为直观，因为您只需将属性指定为父原型的值即可。

function MyObject() {};
MyObject.prototype.staticAttribute = "some value";

并从从该构造函数实例化的每个对象访问它，就像这样。。。

var childObject1 = new MyObject(); // Instantiate a child object
var childObject2 = new MyObject(); // Instantiate another child object
console.log(childObject.staticAttribute); // Access the static Attribute from child 1
console.log(childObject.staticAttribute); // Access the static Attribute from child 2

现在，如果您继续更改MyObject.prototype.staticAttribute，则更改将级联到立即继承它的子对象。

然而，有一些“陷阱”可能会严重破坏此属性的“静态”特性，或者只留下安全漏洞。。。

首先，确保通过将构造函数封装在另一个函数（如jQuery ready方法）中，从全局命名空间中隐藏构造函数

 $(document).ready(function () {
    function MyObject() {
        // some constructor instructions
    };
    MyObject.prototype.staticAttribute = "some value";
    var childObject = new MyObject(); // instantiate child object
    console.log(childObject.staticAttribute); // test attribute
});

第二，也是最后一点，即使您这样做，该属性仍然可以从您自己的脚本的任何其他部分进行编辑，因此可能是代码中的错误覆盖了某个子对象的属性，并将其从父原型分离，因此如果您更改父属性，它将不再级联并更改子对象的静态属性。看看这个jsfiddle。在不同的场景中，我们可以使用Object.freeze（obj）来停止对子对象的任何更改，也可以在构造函数中设置setter和getter方法并访问闭包，这两者都具有相关的复杂性。

在我看来，“静态属性”的基于类的思想和这个Javascript实现之间似乎没有完美的相似之处。因此，我认为从长远来看，使用一种对Javascript更友好的不同代码模式可能会更好。比如一个中央数据存储或缓存，甚至一个专用的帮助对象来保存所有必要的静态变量。

可以在声明静态变量后重新分配函数

function IHaveBeenCalled() {
  console.log("YOU SHOULD ONLY SEE THIS ONCE");
  return "Hello World: "
}
function testableFunction(...args) {
  testableFunction=inner //reassign the function
  const prepend=IHaveBeenCalled()
  return inner(...args) //pass all arguments the 1st time
  function inner(num) {
    console.log(prepend + num);
  }
}
testableFunction(2) // Hello World: 2
testableFunction(5) // Hello World: 5

这使用。。。args比较慢，有没有办法第一次使用父函数的作用域而不是传递所有参数？

我的用例：

function copyToClipboard(...args) {
  copyToClipboard = inner //reassign the function
  const child_process = require('child_process')
  return inner(...args) //pass all arguments the 1st time
  function inner(content_for_the_clipboard) {
    child_process.spawn('clip').stdin.end(content_for_the_clipboard)
  }
}

如果要在作用域之外使用child_process，可以将其分配给copyToCclipboard的属性

function copyToClipboard(...args) {
  copyToClipboard = inner //reassign the function
  copyToClipboard.child_process = require('child_process')
  return inner(...args) //pass all arguments the 1st time
  function inner(content_for_the_clipboard) {
    copyToClipboard.child_process.spawn('clip').stdin.end(content_for_the_clipboard)
  }
}

您可以使用arguments.callee存储“静态”变量（这在匿名函数中也很有用）：

function () {
  arguments.callee.myStaticVar = arguments.callee.myStaticVar || 1;
  arguments.callee.myStaticVar++;
  alert(arguments.callee.myStaticVar);
}

当我看到这个时，我记得JavaScript闭包。。我是这样做的。。

        function Increment() {
            var num = 0; // Here num is a private static variable
            return function () {
                return ++num;
            }
        }

        var inc = new Increment();
        console.log(inc());//Prints 1
        console.log(inc());//Prints 2
        console.log(inc());//Prints 3

在JavaScript中，任何东西都是原始类型或对象。函数是对象-（键值对）。

创建函数时，将创建两个对象。一个对象表示函数本身，另一个对象代表函数的原型。

从这个意义上讲，函数基本上是一个具有财产的对象：

function name, 
arguments length 
and the functional prototype.

因此，在何处设置静态属性：两个位置，要么在函数对象内部，要么在功能原型对象内部。

这里有一个代码片段，它使用新的JavaScript关键字创建了两个实例。

函数C（）{//函数var privateProperty=“42”；this.publicProperty=“39”；this.privateMethod=函数（）｛console.log（privateProperty）；};}C.prototype.publicMethod=函数（）｛console.log（this.publicProperty）；};C.prototype.staticPrototypeProperty=“4”；C.staticProperty=“3”；var i1=新C（）；//实例1var i2=新C（）；//实例2i1.privateMethod（）；i1.publicMethod（）；console.log（i1.__proto__.staticPrototypeProperty）；i1.__proto__.staticPrototypeProperty=“2”；console.log（i2.__proto__.staticPrototypeProperty）；console.log（i1.__proto__constructor.staticProperty）；i1.__proto__constructor.staticProperty=“9”；console.log（i2.__proto__constructor.staticProperty）；

主要思想是实例i1和i2使用相同的静态财产。