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

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

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

要在这里浓缩所有的类概念，请测试：

var Test = function() {
  // "super private" variable, accessible only here in constructor. There are no real private variables
  //if as 'private' we intend variables accessible only by the class that defines the member and NOT by child classes
  var test_var = "super private";

  //the only way to access the "super private" test_var is from here
  this.privileged = function(){
    console.log(test_var);
  }();

  Test.test_var = 'protected';//protected variable: accessible only form inherited methods (prototype) AND child/inherited classes

  this.init();
};//end constructor

Test.test_var = "static";//static variable: accessible everywhere (I mean, even out of prototype, see domready below)

Test.prototype = {

 init:function(){
   console.log('in',Test.test_var);
 }

};//end prototype/class


//for example:
$(document).ready(function() {

 console.log('out',Test.test_var);

 var Jake = function(){}

 Jake.prototype = new Test();

 Jake.prototype.test = function(){
   console.log('jake', Test.test_var);
 }

 var jake = new Jake();

 jake.test();//output: "protected"

});//end domready

好吧，另一种了解这些方面最佳实践的方法是看看咖啡脚本是如何翻译这些概念的。

#this is coffeescript
class Test
 #static
 @prop = "static"

 #instance
 constructor:(prop) ->
   @prop = prop
   console.log(@prop)

 t = new Test('inst_prop');

 console.log(Test.prop);


//this is how the above is translated in plain js by the CS compiler
  Test = (function() {
    Test.prop = "static";

    function Test(prop) {
     this.prop = prop;
     console.log(this.prop);
    }

    return Test;

  })();

  t = new Test('inst_prop');

  console.log(Test.prop);

function Person(){
  if(Person.count == undefined){
    Person.count = 1;
  }
  else{
    Person.count ++;
  }
  console.log(Person.count);
}

var p1 = new Person();
var p2 = new Person();
var p3 = new Person();

摘要：

在ES6/ES 2015中，class关键字与附带的静态关键字一起引入。请记住，这是javavscript所体现的原型继承模型的语法糖。static关键字对方法的工作方式如下：

类狗{静态树皮（）{console.log（'wof'）；}//类是隐藏的函数对象//树皮方法位于Dog函数对象上makeSound（）｛console.log（'bark'）；｝//makeSound位于Dog.prototype对象上}//要创建静态变量，只需在类的原型上创建一个属性Dog.prototype.breed=“Pitbull”；//因此，要定义静态属性，我们不需要“static”关键字。const蓬松=新狗（）；const vicky=新狗（）；控制台.日志（绒毛.品种，vicky.品种）；//更改静态变量会更改所有对象上的静态变量Dog.prototype.breed=“梗”；控制台.日志（绒毛.品种，vicky.品种）；

您可以利用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.

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

2021更新

在2021，您可以简单地使用static关键字

截至2021 4月，TC39将STATIC关键字移至第4阶段语言功能。将静态JS特性变成一组正式的JS语言特性需要很长时间，然而，等待的原因是缺乏浏览器支持；现在，主流浏览器支持static关键字，并支持公共静态字段和私有静态字段的开放季节。

下面是实现静态JavaScript类成员的新方法的一般示例

class ColorFinder {
  static #red = "#ff0000";
  static #green = "#00ff00";
  static #blue = "#0000ff";
  
  static colorName(name) {
    switch (name) {
      case "red": return ColorFinder.#red;
      case "blue": return ColorFinder.#blue;
      case "green": return ColorFinder.#green;
      default: throw new RangeError("unknown color");
    }
  }
  
  // Somehow use colorName
}

以上示例取自TC39存储库，静态字段

要了解更多关于这个新的JS语言特性的实现（单击此处）。

阅读更多关于该特性本身的信息，以及演示静态字段语法的示例（单击此处）。