如果你想使用原型，那么有一种方法

var p = function Person() {
    this.x = 10;
    this.y = 20;
}
p.prototype.counter = 0;
var person1 = new p();
person1.prototype = p.prototype;
console.log(person1.counter);
person1.prototype.counter++;
var person2 = new p();
person2.prototype = p.prototype;
console.log(person2.counter);
console.log(person1.counter);

这样做，您将能够从任何实例访问计数器变量，并且属性中的任何更改都将立即反映出来！！

还有其他类似的答案，但没有一个对我很有吸引力

var nextCounter = (function () {
  var counter = 0;
  return function() {
    var temp = counter;
    counter += 1;
    return temp;
  };
})();

如果您来自基于类的静态类型的面向对象语言（如Java、C++或C#），我假设您试图创建与“类型”相关联的变量或方法，而不是与实例相关联的。

使用带有构造函数的“经典”方法的示例可能会帮助您了解基本OO JavaScript的概念：

function MyClass () { // constructor function
  var privateVariable = "foo";  // Private variable 

  this.publicVariable = "bar";  // Public variable 

  this.privilegedMethod = function () {  // Public Method
    alert(privateVariable);
  };
}

// Instance method will be available to all instances but only load once in memory 
MyClass.prototype.publicMethod = function () {    
  alert(this.publicVariable);
};

// Static variable shared by all instances
MyClass.staticProperty = "baz";

var myInstance = new MyClass();

staticProperty在MyClass对象（这是一个函数）中定义，与它创建的实例无关，JavaScript将函数视为一级对象，因此作为一个对象，可以将财产分配给函数。

UPDATE:ES6引入了通过class关键字声明类的能力。它是现有的基于原型的继承的语法糖。

static关键字允许您轻松定义类中的静态财产或方法。

让我们看看上面用ES6类实现的示例：

类MyClass{//类构造函数，等效于//构造函数的函数体构造器（）{const privateVariable=“private value”；//构造函数范围内的私有变量this.publicVariable='公共值'；//公共财产this.privilegedMethod=函数（）{//具有构造函数范围变量访问权限的公共方法console.log（privateVariable）；};}//原型方法：publicMethod（）{console.log（this.publicVariable）；}//所有实例共享的静态财产static staticProperty='静态值'；静态静态方法（）{console.log（this.staticProperty）；}}//我们可以将财产添加到类原型中MyClass.prototype.additionalMethod=函数（）{console.log（this.publicVariable）；};var myInstance=新建MyClass（）；myInstance.publicMethod（）；//“公共价值”myInstance.additionalMethod（）；//“公共价值”myInstance.privilegedMethod（）；//“私人价值”MyClass.staticMethod（）；//“静态值”

我通常使用这种方法有两个主要原因：

如果我想存储函数的本地值，我会使用“local.x”、“local.y”、“local.TempData”等。。。！

如果我想存储函数的静态值，我会使用“static.o”、“static.Info”、“static.count”等。。。！

[Update2]：方法相同，但使用IIFE方法！

[Update1]：通过预编辑脚本自动创建函数的“静态”和“本地”对象！

更新答案：

在ECMAScript 6中，可以使用static关键字创建静态函数：

class Foo {

  static bar() {return 'I am static.'}

}

//`bar` is a property of the class
Foo.bar() // returns 'I am static.'

//`bar` is not a property of instances of the class
var foo = new Foo()
foo.bar() //-> throws TypeError

ES6类没有为静态引入任何新的语义。您可以在ES5中这样做：

//constructor
var Foo = function() {}

Foo.bar = function() {
    return 'I am static.'
}

Foo.bar() // returns 'I am static.'

var foo = new Foo()
foo.bar() // throws TypeError

您可以指定Foo的属性，因为在JavaScript中，函数是对象。

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

面向对象编程实际上有两种不同的风格，一种是基于类的（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更友好的不同代码模式可能会更好。比如一个中央数据存储或缓存，甚至一个专用的帮助对象来保存所有必要的静态变量。