在JavaScript中，任何东西都是原始类型或对象。函数是对象-（键值对）。

创建函数时，将创建两个对象。一个对象表示函数本身，另一个对象代表函数的原型。

从这个意义上讲，函数基本上是一个具有财产的对象：

function name, 
arguments length 
and the functional prototype.

因此，在何处设置静态属性：两个位置，要么在函数对象内部，要么在功能原型对象内部。

这里有一个代码片段，它使用新的JavaScript关键字创建了两个实例。

函数C（）{//函数var privateProperty=“42”；this.publicProperty=“39”；this.privateMethod=函数（）｛console.log（privateProperty）；};}C.prototype.publicMethod=函数（）｛console.log（this.publicProperty）；};C.prototype.staticPrototypeProperty=“4”；C.staticProperty=“3”；var i1=新C（）；//实例1var i2=新C（）；//实例2i1.privateMethod（）；i1.publicMethod（）；console.log（i1.__proto__.staticPrototypeProperty）；i1.__proto__.staticPrototypeProperty=“2”；console.log（i2.__proto__.staticPrototypeProperty）；console.log（i1.__proto__constructor.staticProperty）；i1.__proto__constructor.staticProperty=“9”；console.log（i2.__proto__constructor.staticProperty）；

主要思想是实例i1和i2使用相同的静态财产。

当我看到这个时，我记得JavaScript闭包。。我是这样做的。。

        function Increment() {
            var num = 0; // Here num is a private static variable
            return function () {
                return ++num;
            }
        }

        var inc = new Increment();
        console.log(inc());//Prints 1
        console.log(inc());//Prints 2
        console.log(inc());//Prints 3

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

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

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

JavaScript中最接近静态变量的是一个全局变量——这只是一个在函数或对象文本范围之外声明的变量：

var thisIsGlobal = 1;

function foo() {
    var thisIsNot = 2;
}

您可以做的另一件事是将全局变量存储在对象文本中，如下所示：

var foo = { bar : 1 }

然后像这样访问变量：foo.bar。

函数的/类只允许其对象范围使用一个构造函数。函数提升、声明和表达式

使用Function构造函数创建的函数不会创建其创建上下文的闭包；它们总是在全局范围内创建的。var functionClass=函数（）{var currentClass=形状；_继承（currentClass，superClass）；function functionClass（）｛superClass.call（this）；//与superClass构造函数链接。//实例变量列表。this.id=id；返回此；}}（特级）

闭包-闭包的副本是保存数据的函数。

每个闭包的副本都被创建到一个具有自己的自由值或引用的函数。每当您在另一个函数中使用函数时，都会使用闭包。JavaScript中的闭包就像innerFunctions维护其父函数的所有局部变量的副本。函数closureFun（参数）{//结束于闭包内的局部变量var num=参数；num++；return函数（）｛console.log（num）；｝}var closure1=closureFun（5）；var closure2=closureFun（777）；closure1（）；//5.closure2（）；//777closure2（）；//778closure1（）；//6.

ES5函数类：使用Object.defineProperty（O，P，Attributes）

Object.defineProperty（）方法直接在对象上定义新属性，或修改对象上的现有属性，然后返回对象。

使用“”创建了一些方法，以便每次都能轻松理解函数类。

'use strict';
var Shape = function ( superClass ) {
    var currentClass = Shape;
    _inherits(currentClass, superClass); // Prototype Chain - Extends

    function Shape(id) { superClass.call(this); // Linking with SuperClass Constructor.
        // Instance Variables list.
        this.id = id;   return this;
    }
    var staticVariablesJOSN = { "parent_S_V" : 777 };
    staticVariable( currentClass, staticVariablesJOSN );

    // Setters, Getters, instanceMethods. [{}, {}];
    var instanceFunctions = [
        {
            key: 'uniqueID',
            get: function get() { return this.id; },
            set: function set(changeVal) { this.id = changeVal; }
        }
    ];
    instanceMethods( currentClass, instanceFunctions );

    return currentClass;
}(Object);

var Rectangle = function ( superClass ) {
    var currentClass = Rectangle;

    _inherits(currentClass, superClass); // Prototype Chain - Extends

    function Rectangle(id, width, height) { superClass.call(this, id); // Linking with SuperClass Constructor.

        this.width = width;
        this.height = height;   return this;
    }

    var staticVariablesJOSN = { "_staticVar" : 77777 };
    staticVariable( currentClass, staticVariablesJOSN );

    var staticFunctions = [
        {
            key: 'println',
            value: function println() { console.log('Static Method'); }
        }
    ];
    staticMethods(currentClass, staticFunctions);

    var instanceFunctions = [
        {
            key: 'setStaticVar',
            value: function setStaticVar(staticVal) {
                currentClass.parent_S_V = staticVal;
                console.log('SET Instance Method Parent Class Static Value : ', currentClass.parent_S_V);
            }
        }, {
            key: 'getStaticVar',
            value: function getStaticVar() {
                console.log('GET Instance Method Parent Class Static Value : ', currentClass.parent_S_V);
                return currentClass.parent_S_V;
            }
        }, {
            key: 'area',
            get: function get() {
                console.log('Area : ', this.width * this.height);
                return this.width * this.height;
                }
        }, {
            key: 'globalValue',
            get: function get() {
                console.log('GET ID : ', currentClass._staticVar);
                return currentClass._staticVar;
            },
            set: function set(value) {
                currentClass._staticVar = value;
                console.log('SET ID : ', currentClass._staticVar);
            }
        }
    ];
    instanceMethods( currentClass, instanceFunctions );

    return currentClass;
}(Shape);

// ===== ES5 Class Conversion Supported Functions =====
function defineProperties(target, props) {
    console.log(target, ' : ', props);
    for (var i = 0; i < props.length; i++) {
        var descriptor = props[i];
        descriptor.enumerable = descriptor.enumerable || false;
        descriptor.configurable = true;
        if ("value" in descriptor) descriptor.writable = true;
        Object.defineProperty(target, descriptor.key, descriptor);
    }
}
function staticMethods( currentClass, staticProps ) {
    defineProperties(currentClass, staticProps);
};
function instanceMethods( currentClass, protoProps ) {
    defineProperties(currentClass.prototype, protoProps);
};
function staticVariable( currentClass, staticVariales ) {
    // Get Key Set and get its corresponding value.
    // currentClass.key = value;
    for( var prop in staticVariales ) {
        console.log('Keys : Values');
        if( staticVariales.hasOwnProperty( prop ) ) {
            console.log(prop, ' : ', staticVariales[ prop ] );
            currentClass[ prop ] = staticVariales[ prop ];
        }
    }
};
function _inherits(subClass, superClass) {
    console.log( subClass, ' : extends : ', superClass );
    if (typeof superClass !== "function" && superClass !== null) {
        throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
    }
    subClass.prototype = Object.create(superClass && superClass.prototype, 
            { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });
    if (superClass)
        Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
}

下面的代码片段是测试每个实例都有自己的实例成员和公共静态成员的副本。

var objTest = new Rectangle('Yash_777', 8, 7);
console.dir(objTest);

var obj1 = new Rectangle('R_1', 50, 20);
Rectangle.println(); // Static Method
console.log( obj1 );    // Rectangle {id: "R_1", width: 50, height: 20}
obj1.area;              // Area :  1000
obj1.globalValue;       // GET ID :  77777
obj1.globalValue = 88;  // SET ID :  88
obj1.globalValue;       // GET ID :  88  

var obj2 = new Rectangle('R_2', 5, 70);
console.log( obj2 );    // Rectangle {id: "R_2", width: 5, height: 70}
obj2.area;              // Area :  350    
obj2.globalValue;       // GET ID :  88
obj2.globalValue = 999; // SET ID :  999
obj2.globalValue;       // GET ID :  999

console.log('Static Variable Actions.');
obj1.globalValue;        // GET ID :  999

console.log('Parent Class Static variables');
obj1.getStaticVar();    // GET Instance Method Parent Class Static Value :  777
obj1.setStaticVar(7);   // SET Instance Method Parent Class Static Value :  7
obj1.getStaticVar();    // GET Instance Method Parent Class Static Value :  7

静态方法调用直接在类上进行，不能在类的实例上调用。但您可以从实例内部实现对静态成员的调用。使用语法：this.constructor.staticfunctionName（）；

class MyClass {
    constructor() {}
    static staticMethod() {
        console.log('Static Method');
    }
}
MyClass.staticVar = 777;

var myInstance = new MyClass();
// calling from instance
myInstance.constructor.staticMethod();
console.log('From Inside Class : ',myInstance.constructor.staticVar);

// calling from class
MyClass.staticMethod();
console.log('Class : ', MyClass.staticVar);

ES6类：ES2015类比基于原型的OO模式更简单。拥有一个方便的声明性表单可以使类模式更易于使用，并鼓励互操作性。类支持基于原型的继承、超级调用、实例和静态方法以及构造函数。

示例：参考我以前的帖子。

我经常使用静态函数变量，很遗憾JS没有内置的机制。我经常看到代码中的变量和函数是在外部范围内定义的，即使它们只是在一个函数内使用。这很难看，容易出错，而且只是自找麻烦。。。

我想出了以下方法：

if (typeof Function.prototype.statics === 'undefined') {
  Function.prototype.statics = function(init) {
    if (!this._statics) this._statics = init ? init() : {};
    return this._statics;
  }
}

这为所有函数添加了一个“statics”方法（是的，放松一下），当调用时，它将向函数对象添加一个空对象（_statics）并返回它。如果提供了init函数，_statics将设置为init（）结果。

然后，您可以执行以下操作：

function f() {
  const _s = f.statics(() => ({ v1=3, v2=somefunc() });

  if (_s.v1==3) { ++_s.v1; _s.v2(_s.v1); }
} 

与另一个正确答案IIFE相比，这有一个缺点，即在每个函数调用中添加一个赋值和一个if，并向函数添加一个“_statics”成员，但也有一些优点：参数位于顶部而不是内部函数中，在内部函数代码中使用“static”是显式的，带有“_s”前缀，总体上看和理解起来更简单。