2

假设对于时间要求严格的应用程序，使用函数声明或函数表达式而不是大量执行的回调中的内联函数总是更好的假设是否安全？

考虑以下测试程序：

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);

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

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

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

4

1 回答 1

3

是的，这可以概括。从技术上讲，循环体中的函数表达式在每个循环轮次都被重新评估为一个新的函数对象。正如您的测试所证实的那样，这比在循环外定义一个“静态”函数要慢得多（对于数百万次迭代）。函数是否被命名并不重要，在执行上下文中引入另一个变量的开销很小。

但是，这仅在函数确实在迭代中声明时才相关，如您的示例中所示。如果你有一个

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

那么没有区别

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

和

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

因为cb参数是对一个函数的“静态”引用。

于 2013-06-21T12:27:01.883 回答