在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 circle(){
}
circle.prototype.pi=3.14159

以下示例和解释来自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变量设置为新值。这会导致所有实例返回相同的值。

ES6类支持静态函数，其行为与其他面向对象语言中的静态函数非常相似：

class MyClass {
  static myFunction() {
    return 42;
  }
}

typeof MyClass.myFunction; // 'function'
MyClass.myFunction(); // 42

通用静态财产仍然是第三阶段的建议，这意味着您需要巴贝尔的第三阶段预设才能使用它们。但有了Babel，你可以做到这一点：

class MyClass {
  static answer = 42;
}

MyClass.answer; // 42

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

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

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

您可以在JavaScript中创建一个静态变量，如下所示。这里count是静态变量。

var Person = function(name) {
  this.name = name;
  // first time Person.count is undefined, so it is initialized with 1
  // next time the function is called, the value of count is incremented by 1
  Person.count = Person.count ? Person.count + 1 : 1;
}

var p1 = new Person('User p1');
console.log(p1.constructor.count);   // prints 1
var p2 = new Person('User p2');
console.log(p2.constructor.count);   // prints 2

您可以使用Person函数或任何实例为静态变量赋值：

// set static variable using instance of Person
p1.constructor.count = 10;         // this change is seen in all the instances of Person
console.log(p2.constructor.count); // prints 10

// set static variable using Person
Person.count = 20;
console.log(p1.constructor.count); // prints 20