Question

是否可以安全地假设对于时间关键的应用程序，最好使用函数声明或函数表达式，而不是在重度执行的回调中使用内联函数？

考虑以下测试程序：

var x;
var count3 = function count3() {
    x++;
}

var count2 = function () {
    x++;
}

function count() {
    x++;
}

function execute(cb) {
    cb();
}

x = 0;
var a = new Date().getTime();
for (var i = 0; i < 100000000; i++) {
    execute(function named() {
        x++;
    })
}
a = new Date().getTime() - a;
console.log("Named inline function: " + a);
x = 0;
a = new Date().getTime();
for (var i = 0; i < 100000000; i++) {
    execute(function () {
        x++;
    })
}

a = new Date().getTime() - a;
console.log("Anonymous inline function: " + a);
x = 0;
a = new Date().getTime();
for (var i = 0; i < 100000000; i++) {
    execute(count);
}

a = new Date().getTime() - a;
console.log("Function declaration: " + a);
x = 0;
a = new Date().getTime();
for (var i = 0; i < 100000000; i++) {
    execute(count2);
}

a = new Date().getTime() - a;
console.log("Anonymous function expression:" + a);
x = 0;
a = new Date().getTime();
for (var i = 0; i < 100000000; i++) {
    execute(count3);
}

a = new Date().getTime() - a;
console.log("Named function expression:" + a);

这给出了以下输出（以ms为单位）：

Named inline function: 2347
Anonymous inline function: 2121
Function declaration: 771
Anonymous function expression:750
Named function expression:752

在我简陋的笔记本电脑上，函数声明和函数表达式比内联函数快3倍。

Answer 1

是的，这可以概括。从技术上讲，循环体中的函数表达式在每次循环转换时被重新计算为新的函数对象。正如您的测试所证实的那样，这一点明显慢于（数百万次迭代）而不是一次静态＆＃34;在循环外定义的函数。无论函数是否被命名并不重要，它在执行上下文中引入另一个变量的开销很小。

但是，这仅在函数真正在迭代内声明时才有意义，如示例中所示。如果你有一个

function executeAll(cb) {
    for (var i = 0; i < 100000000; i++) {
        cb();
    }
}

然后

之间没有区别

executeAll(function() { x++; });

和

function increase() { x++; }
executeAll(increase);

因为cb参数是＆＃34;静态＆＃34;引用 one 函数。

Javascript执行功能很强：内联或声明？

1 个答案: