如何在Javascript中创建静态变量？
当前回答
你可以这样想。在<body></body>中放置标记<p id=“静态变量”></p>并设置其可见性：隐藏。
当然，您可以使用jquery来管理前一个标记中的文本。实际上，这个标签成为你的静态变量。
其他回答
如果您来自基于类的静态类型的面向对象语言（如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（）；//“静态值”
要在这里浓缩所有的类概念，请测试：
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);
所以我从其他答案中看到的是，它们没有解决面向对象编程中静态属性的基本架构要求。
面向对象编程实际上有两种不同的风格，一种是基于类的（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更友好的不同代码模式可能会更好。比如一个中央数据存储或缓存，甚至一个专用的帮助对象来保存所有必要的静态变量。
以下示例和解释来自Nicholas Zakas的《Web开发人员专业JavaScript第二版》一书。这是我一直在寻找的答案，所以我认为在这里添加它会很有帮助。
(function () {
var name = '';
Person = function (value) {
name = value;
};
Person.prototype.getName = function () {
return name;
};
Person.prototype.setName = function (value) {
name = value;
};
}());
var person1 = new Person('Nate');
console.log(person1.getName()); // Nate
person1.setName('James');
console.log(person1.getName()); // James
person1.name = 'Mark';
console.log(person1.name); // Mark
console.log(person1.getName()); // James
var person2 = new Person('Danielle');
console.log(person1.getName()); // Danielle
console.log(person2.getName()); // Danielle
本例中的Person构造函数可以访问私有变量名，getName（）和setName（）方法也是如此。使用此模式，name变量将变为静态，并将在所有实例中使用。这意味着在一个实例上调用setName（）会影响所有其他实例。调用setName（）或创建新的Person实例会将name变量设置为新值。这会导致所有实例返回相同的值。
我使用了原型，并以这种方式工作：
class Cat {
constructor() {
console.log(Cat.COLLECTION_NAME);
}
}
Cat.COLLECTION_NAME = "cats";
或使用静态吸气剂：
class Cat {
constructor() {
console.log(Cat.COLLECTION_NAME);
}
static get COLLECTION_NAME() {
return "cats"
}
}
