Question

我有一个可以使用任意参数调用的函数f。当使用2个参数调用它时，它会执行一个操作。当使用＆gt; 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上200ms vs 4000ms）。这可以进一步优化吗？

Answer 1

ES5为该确切任务引入了.reduce()函数。它调用前两个项的一些函数，然后再次调用它传递第一个调用和第三个项的返回值，然后再次调用它，传递那个调用的返回值和第四个项，等等。

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

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

Answer 2

这样的东西会减少数组的创建和操作

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

Answer 3

为什么不使用object作为参数？

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

Answer 4

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

定义高阶函数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

折叠函数参数的最佳方法是什么？

4 个答案: