Question

这是我的懒函数加载器：

var make_lazy = function (calledFunc, a, b, c, d, e, f) {
    return function () {
        return calledFunc(a, b, c, d, e, f)
    }
};

它适用于除此之外的大多数功能：

function superAdd() {
    return Array.prototype.slice.apply(arguments).reduce(function (a, c) {
        return a + c;
    }, 0);
}

如何修改此函数以接受可变数量的参数？我尝试使用arguments对象但没有成功。

Answer 1

/**
 * @param args {Array}
 */
var make_lazy = function(calledFunc, args) {
  return function () {
    return calledFunc.apply(this, args);
  }
};

var lazy = make_lazy(superAdd, [3, 5]);

lazy(); // => 8

通过上述内容，您可以将不确定数量的参数分组到数组中。

上述方法的工作方式是因为你有一个可变数量的参数，只能在第一个参数之后（这是确定性的）。

使用ES6，使用点差运算符，它甚至更酷：

function make_lazy(calledFunc, ...args) {
  return () => calledFunc(...args);
}

Answer 2

在回调函数上使用带有.apply的参数，就像你为切片函数做的那样

＆＃13;

var make_lazy = function (calledFunc) {
    return function () {
       return calledFunc.apply(null,arguments);
    }
};

function one(a){
   console.log("how many args: "+arguments.length,a);
}
function two(a,b){
   console.log("how many args: "+arguments.length,a,b);
}
function three(a,b,c){
   console.log("how many args: "+arguments.length,a,b,c);
}

var onelazy = make_lazy(one);
var twolazy = make_lazy(two);
var threelazy = make_lazy(three);
onelazy(1);
twolazy(1,2);
threelazy(1,2,3);

＆＃13;

或者如果您想要将预定义值作为参数传递，只需从make_lazy函数本身中获取参数（少于第一个参数），并将其用于apply调用。

var make_lazy = function (calledFunc) {
    var args = [].splice.call(arguments,1);
    return function () {
       return calledFunc.apply(null,args);
    }
};
function two(a,b){
   console.log("Num Args: "+arguments.length,a,b);
}
var twoLazy = make_lazy(two,3,5);
twoLazy();

Answer 3

我假设您使用make_lazy函数的参数版本遇到的问题是您使用了错误的参数列表，例如：

    var make_lazy = function (calledFunc) {
      return function () {
        return calledFunc.apply(null, arguments);
      };
    };

该语句中的arguments引用返回的函数的参数，例如

    var lazy = make_lazy(superAdd, 1, 2, 3);
    lazy(3,4,5);
    // returns 12 -not- 6

因为它只接受lazy执行时应用的参数。 make_lazy函数应该在运行时存储参数，以便以后可以使用它。

因此，要回答您的问题，请将arguments存储为内部返回函数范围之外的变量：

    var make_lazy = function (calledFunc) {

      // Remove the calledFunc from the arguments list by passing in `1` to slice.
      var lazyArgs = Array.prototype.slice.call(arguments, 1);

      return function () {
        return calledFunc.apply(null, lazyArgs);
      };
    };

使用多个参数进行延迟加载

3 个答案: