4

我有一个f可以用任意参数调用的函数。当使用 2 个参数调用它时，它会执行一个操作。当使用 >2 个参数调用它时，它本身必须折叠其他参数。也就是说，当我们调用 时f(a,b,c,d)，函数应该重新排列为f(f(f(a,b),c,d)。我需要尽可能优化它。我提供了 2 个解决方案并对其进行了基准测试：

alphabet = 'abcdefhijklmnopqrstuvwxyz'.split('');
var last_mark;
benchmark = function(msg){ 
  alert(msg.replace('$TIMEDIFF',Date.now()-last_mark)); 
  last_mark=Date.now(); 
};
fa = function(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z){
    if (c) return fa(fa(a,b),c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z);
    return a+b;
};
fb = function(a,b,rest){
    if (rest) return fb.apply(this,[fb(a,b)].concat(Array.prototype.slice.call(arguments,2)));
    return a+b;
};
benchmark("Starting benchmark:");
for (var i=0; i<100000; ++i) fa.apply(this,alphabet);
benchmark("Function 1: $TIMEDIFF");
for (var i=0; i<100000; ++i) fb.apply(this,alphabet);
benchmark("Function 2: $TIMEDIFF");

第一个解决方案更快（node.js 上 200 毫秒对 4000 毫秒）。这可以进一步优化吗？

4

4 回答 4

2

ES5.reduce()为该任务引入了一个函数。它为前两项调用某个函数，然后再次调用它并传递第一个调用的返回值和第三项，然后再次调用它传递该调用的返回值和第四项，依此类推。

var f = function () {
    return toArray( arguments ).reduce(function ( a, b ) {
        return a + b;    
    });
};

现场演示：http: //jsfiddle.net/hpAtB/1/

于 2012-11-18T22:02:53.157 回答
1

为什么不使用对象作为参数？

var o = {
  a:value1,
  b:value2,
  ...
  z:value26
};

fa(o);

function fa(obj){
  if(obj.c){  // or any other logic
    return fa(obj);
  }
  return o;
}

或全局变量（不带参数）

fa();

function fa(){
  if(o.c){  // or any other logic
    o.c = o.d + o.e;
    fa();
  }
}
于 2012-11-18T21:29:31.007 回答
1

最快的方法似乎是用迭代代替递归。

定义高阶函数folder

var folder = function(func) {
   return function() {
            var args = Array.prototype.slice.call(arguments), len = args.length, result = args[0], i = 1;
            for(; i < len; i++){
               result = func.call(this, result, args[i]); 
            }

           return result;
   };
};

检查此性能测试：http: //jsperf.com/varargs-fold

于 2012-11-18T21:53:41.223 回答
1

这样的事情会减少数组的创建和操作

fa = function(a,b){
    function recursive(a, b, rest) {
        if (rest && rest.length) 
            return recursive(recursive(a,b), rest.pop(), rest);
        return a+b;
    }
    return recursive(a, b, Array.prototype.slice.call(arguments, 2).reverse());
};

或者像这样将函数调用的数量减少一半：

fa = function(a,b) {
    function recursive(a, b, rest) {
        var result = a + b;
        return rest.length ? recursive(result, rest.pop(), rest) : result;
    }
    return recursive(a, b, Array.prototype.slice.call(arguments, 2).reverse());
};

我假设使用的成本.reverse()值得使用.pop()而不是.shift(). 您可能想尝试两种方式。

当然你也可以重用这个函数：

fa = (function() {
    function recursive(a, b, rest) {
        var result = a + b;
        return rest.length ? recursive(result, rest.pop(), rest) : result;
    }
    return function(a,b) {
        return recursive(a, b, Array.prototype.slice.call(arguments, 2).reverse());
    };
})();
于 2012-11-18T21:10:58.447 回答