Javascript 函数和对象之间的差异及其对性能的影响

有人能解释一下为什么下面两个例子之间的内存占用有如此大的差异吗？我使用node.js作为环境

它们都产生相同的结果和映射

var util = require('util');

var startMem = process.memoryUsage().heapUsed;

/*
var test = function() {

    var testvar = function() {
        this.innerTest1 = function() {
            this.someVal1 = "this is a test";
            this.someFunc1 = function() {
                return "this is another test";
            }
        }
        this.innerTest2 = function() {
            this.someVal2 = "this is a third test";
            this.someFunc2 = function() {
                return "this is a forth test";
            }
        }
    }
}
*/
//out:
//mem: 448088


var test = function() {
    var testvar = {
        innerTest1 : {
            someVal1 : "this is a test",
            someFunc1 : function() {
                return "this is another test"
            }
        },
        innerTest2 : {
            someVal2 : "this is a third test",
            someFunc2 : function() {
                return "this is a forth test"
            }
        }
    }
}

for (var i = 0; i < 50000; i++) {
    var testobj = new test();
}

//out:
//mem: 1060040


console.log("mem: " + (process.memoryUsage().heapUsed - startMem));

var util=require（'util'）；
var startMem=process.memoryUsage（）.heapUsed；
/*
var测试=函数（）{
var testvar=函数（）{
this.innerTest1=函数（）{
this.someVal1=“这是一个测试”；
this.someFunc1=函数（）{
返回“这是另一个测试”；
}
}
this.innerTest2=函数（）{
this.someVal2=“这是第三次测试”；
this.someFunc2=函数（）{
返回“这是第四次测试”；
}
}
}
}
*/
//输出：
//成员：448088
var测试=函数（）{
var testvar={
innerTest1：{
someVal1:“这是一个测试”，
someFunc1:function（）{
return“这是另一个测试”
}
},
innerTest2：{
someVal2:“这是第三次测试”，
someFunc2:function（）{
return“这是第四次测试”
}
}
}
}
对于（变量i=0；i<50000；i++）{
var testobj=新测试（）；
}
//输出：
//成员：1060040
log（“mem:”+（process.memoryUsage（）.heapUsed-startMem））；

这两段代码的行为完全不同

在第一个示例中，在调用包含的函数之前，不会设置或创建属性/函数。但是，从不调用包含函数

例如，假设：

   this.innerTest1 = function() {
        // the property is NOT SET until this function is run
        this.someVal1 = "this is a test";
        // this function is NOT CREATED until this function is run
        this.someFunc1 = function() {
            return "this is another test";
        }
    }

同样，这也适用于分配给

innerTest1

。因此，第一个示例代码相当于下面的代码，这不是很有用

var testvar = function() {}

（解析可被视为一次性成本。）

---

在后一个示例中，每个属性都被赋值，每个函数都作为对象文本计算的一部分创建。

在第一个示例中，函数只有在调用其父函数时才被延迟创建，但在第二个示例中，所有成员都被初始化为对象文本的一部分

如果您试图减少内存占用，则应使用原型链，该链允许您在多个实例之间共享功能

基本上，而不是做：

function test() {
    var testvar = {
        someFn: function () {}
    };
}

你可以做：

var base = {
    someFn: function () {}
};

function test() {
    var testvar = Object.create(base);
}

---

循环也是第一个示例的一部分吗？它们的作用完全不同。如果您在第一个测试用例中没有调用innerTest1和innerTest2，那么比较是不公平的：someVal1/someFunc1和someVal2/someFunc2不会被创建。啊，好的，有意义。因此，在第一个例子中，如果每个函数和属性都在循环中被调用，那么它的内存占用量将是相同的？@Rasive我不想说“相同”，但它将更接近——或者至少与前面的数字有很大的不同。