如果要创建全局静态变量：

var my_id = 123;

将变量替换为以下内容：

Object.defineProperty(window, 'my_id', {
    get: function() {
            return 123;
        },
    configurable : false,
    enumerable : false
});

如果您来自基于类的静态类型的面向对象语言（如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（）；//“静态值”

在Javascript中有4种模拟函数局部静态变量的方法。

方法1：使用函数对象财产（在旧浏览器中受支持）

function someFunc1(){
    if( !('staticVar' in someFunc1) )
        someFunc1.staticVar = 0 ;
    alert(++someFunc1.staticVar) ;
}

someFunc1() ; //prints 1
someFunc1() ; //prints 2
someFunc1() ; //prints 3

方法2：使用闭包，变体1（旧浏览器支持）

var someFunc2 = (function(){
    var staticVar = 0 ;
    return function(){
        alert(++staticVar) ;
    }
})()

someFunc2() ; //prints 1
someFunc2() ; //prints 2
someFunc2() ; //prints 3

方法3：使用闭包，变体2（在旧浏览器中也支持）

var someFunc3 ;
with({staticVar:0})
    var someFunc3 = function(){
        alert(++staticVar) ;
    }

someFunc3() ; //prints 1
someFunc3() ; //prints 2
someFunc3() ; //prints 3

方法4：使用闭包，变体3（需要支持EcmaScript 2015）

{
    let staticVar = 0 ;
    function someFunc4(){
        alert(++staticVar) ;
    }
}

someFunc4() ; //prints 1
someFunc4() ; //prints 2
someFunc4() ; //prints 3

严格模式的方法4

'use strict'
{
    let staticVar = 0 ;
    var someFunc4 = function(){
        alert(++staticVar) ;
    } ;
}

someFunc4() ; //prints 1
someFunc4() ; //prints 2
someFunc4() ; //prints 3

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

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

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

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

{
   var statvar = 0;
   function f_counter()
   {
      var nonstatvar = 0;
      nonstatvar ++;
      statvar ++;
      return statvar + " , " + nonstatvar;
   }
}
alert(f_counter());
alert(f_counter());
alert(f_counter());
alert(f_counter());

这只是我在某处学到的另一种静态变量的方法。