关于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

ES6类支持静态函数，其行为与其他面向对象语言中的静态函数非常相似：

class MyClass {
  static myFunction() {
    return 42;
  }
}

typeof MyClass.myFunction; // 'function'
MyClass.myFunction(); // 42

通用静态财产仍然是第三阶段的建议，这意味着您需要巴贝尔的第三阶段预设才能使用它们。但有了Babel，你可以做到这一点：

class MyClass {
  static answer = 42;
}

MyClass.answer; // 42

Javascript中没有静态变量。这种语言是基于原型的面向对象的，因此没有类，而是对象“复制”自己的原型。

您可以使用全局变量或原型（向原型添加属性）来模拟它们：

function circle(){
}
circle.prototype.pi=3.14159

您可以使用static关键字在JavaScript中定义静态函数：

class MyClass {
  static myStaticFunction() {
    return 42;
  }
}

MyClass.myStaticFunction(); // 42

在撰写本文时，您仍然无法在类中定义静态财产（函数除外）。静态财产仍然是第三阶段的建议，这意味着它们还不是JavaScript的一部分。然而，没有什么可以阻止您像分配给任何其他对象一样简单地分配给类：

class MyClass {}

MyClass.myStaticProperty = 42;

MyClass.myStaticProperty; // 42

最后一点：小心使用带有继承的静态对象-所有继承的类共享对象的相同副本。

您可以利用JS函数也是对象这一事实，这意味着它们可以具有财产。

例如，引用Javascript中静态变量一文（现已消失）中给出的示例：

function countMyself() {
    // Check to see if the counter has been initialized
    if ( typeof countMyself.counter == 'undefined' ) {
        // It has not... perform the initialization
        countMyself.counter = 0;
    }

    // Do something stupid to indicate the value
    alert(++countMyself.counter);
}

如果多次调用该函数，您将看到计数器正在递增。

这可能是一个比用全局变量替换全局命名空间更好的解决方案。

下面是基于闭包的另一种可能的解决方案：在javascript中使用静态变量的技巧：

var uniqueID = (function() {
   var id = 0; // This is the private persistent value
   // The outer function returns a nested function that has access
   // to the persistent value.  It is this nested function we're storing
   // in the variable uniqueID above.
   return function() { return id++; };  // Return and increment
})(); // Invoke the outer function after defining it.

这会得到相同的结果——只是这次返回的是递增的值，而不是显示。

在JavaScript中，没有静态的术语或关键字，但我们可以将这些数据直接放到函数对象中（就像在任何其他对象中一样）。

function f() {
    f.count = ++f.count || 1 // f.count is undefined at first
    alert("Call No " + f.count)
}

f(); // Call No 1

f(); // Call No 2