Javascript：实例变量和静态方法；就记忆而言，这样可以吗？

就记忆而言，这样可以吗？ 我的意思是： 在1000个实例化对象中，将有：

1*静态法 1000*instanceVar

这有效吗？我想指出的是，instanceVar将在每个对象中进行修改，因此一个Single对象是不够的

可能有内存泄漏

if (typeof Object.create4 !== 'function') {
    Object.create4 = function (t) {
        var F, f, i, ins = {}, sta = {};

        for(i in t){
            // method: static, means will only exists 1, so is less memory intensive
            if(typeof t[i] === 'function'){
                sta[i] = t[i];
            }
            // vars: instance, means 1 for each object, so is more memory intensive
            else{
                ins[i] = t[i];
            }
        }

        // make a copy of the instances
        ins = jQuery.extend(true, {}, ins);


        F = function() {}
        F.prototype = sta;
        f = new F();

        // assign instances to the instance
        for(i in ins){
            f[i] = ins[i];
        }
        return f;
    };
}

var Vehicle4 = (function(){
    var that = {}

    that.instanceVar = {hey: 1}
    that.staticMethod = function(){
        console.log(this.instanceVar);
    }
    return that;
}())

var v31 = Object.create4(Vehicle4);
var v32 = Object.create4(Vehicle4);

v31.instanceVar.hey = 2;
v31.staticMethod();
v32.staticMethod();

---

我可以肯定地告诉您，它是正确的，您不会有内存泄漏，但关于效率，我有一些疑问。
首先，你的静态成员不是很静态。。。它们只是添加到对象的原型链中。整个原型继承系统依赖于这样一个事实：每个对象递归地继承它的原型

因此，如果向基本体对象添加属性，例如：

var inherit = function(P, C) {
    return jQuery.extend(true, {}, P, C);
}

var Vehicle = function() {}
Vehicle.prototype = {
    init: function(){
        this.instanceVar = {hey: 1}
    },
    staticMethod: function() {
        console.log(this.instanceMember);
    },
    staticMethod3: function() {
        console.log(this.instanceMember);
    }
}

var SuperVehicle = function() {}
SuperVehicle.prototype = inherit(Vehicle.prototype, {
    init: function(){
        this.super.init.call(this);
        this.instanceVar2 = {hey: 1}
    },
    staticMethod: function() {
        console.log(this.instanceVar.hey);
        console.log(this.instanceVar2.hey);
    },
    staticMethod2: function() {
        console.log(this.instanceVar.hey);
        console.log(this.instanceVar2.hey);
    }
});
SuperVehicle.prototype.super = Vehicle.prototype;

var s = new SuperVehicle();
s.init();
s.staticMethod();
s.staticMethod2();
s.staticMethod3();

窗口中的所有对象都将继承此函数，它们将是“基本体”：）

您可以称之为“静态”方法，只有当您考虑到它仅在内存中加载一次，而不是针对每个实例加载时，但您不能认为它是静态的，因为它与对象的当前实例交互（如果使用了“这”），则用其他面向对象语言进行交互。关键字在静态方法中，它会引发异常）

但我看不出你的例子有什么意义

在您的示例中，将“静态”方法固定到要创建的对象的原型中，但为每个对象实例重新创建原型。如果您为同一个“类”创建两个或多个实例，它们不会共享原型，但每个实例都具有相同的原型

就在那里：

Object.prototype.toString = function(){console.log("I am a primitive object");}

每次使用此方法创建车辆时：

F = function() {};
F.prototype = sta;
f = new F();

你为每个实例创建原型，这有点违背了原型继承的目的

我肯定会选择创建对象的经典方法（使用“new”操作符）：

通过这种方式，您可以轻松更改staticMethod并影响所有车辆实例：

var Vehicle = function(val){this.instanceMember = val;}  
Vehicle.prototype = {   
    "staticMethod": function(){console.log(this.instanceMember);}   
}    
var v1 = new Vehicle("foo");  
var v2 = new Vehicle("bar");

而在您的示例中，如果更改staticMethod，则更改将仅应用于更改发生后构造的实例。
话虽如此，在这种情况下，使用“静态”成员创建对象的传统方法要有效得多

---

附言：如果我得意忘形，我很抱歉：）

它可能对您的工作有效率，也可能没有效率，但在您尝试之前，我们不会真正知道。当你衡量了一个问题之后再进行优化。是的，在开始之前尝试学习正确的方法是愚蠢的。在你深陷crud之后尝试修复它们要好得多。我是javascript原型继承和代码重用方面的新手，所以我试图找到一些“正确”和“高效”的方法来构建我的应用程序。对我来说是静态的，在这种情况下意味着在内存中只加载一次。实际上并不需要更改静态属性。在我的方法中，如果我从一个对象继承，会发现更快的方法和变量，因为所有的东西都在这个原型链中，而缺点是需要更多的时间来实例/创建一个新对象。我甚至可以缓存创建的每个对象。我说得对吗？我会发布更多的东西。如果是你，你将如何继承？现在我看我错了。我做了一些长凳，而你的xD要快得多，所以我会按照你的方式做，在没有继承的情况下大约快x30，在继承的情况下快x20。所以在我的例子中，我需要很多东西，就是这样！谢谢，那么如何从父对象到子对象获取实例变量呢？好吧，继承部分非常简单：您只需将超类定义为对象的原型。例如：var superClass=function（）{}；var subClass=function（）{}；console.log（子类instance.name）；superClass.prototype.name=“我是超类”；subClass.prototype=新的超类（）；var subClassInstance=新的子类（）；您将看到子类项的名称与超类中的名称相同。回答第二个问题，当一个对象继承另一个对象时，它继承它的模型，它的类。。。这是原型，不是实例。您不能自然地将变量从超类的实例传递到子类的实例

var Vehicle = function(val){this.instanceMember = val;}  
Vehicle.prototype = {   
    "staticMethod": function(){console.log(this.instanceMember);}   
}    
var v1 = new Vehicle("foo");  
var v2 = new Vehicle("bar");

Vehicle.prototype.staticMethod = function(){  
    console.log(arguments[0] || this.instanceMember);  
};