Question

如果我有：

function foo(number, ...args) {
   //foo to add args to sum
}

我希望调用者可以调用foo：

foo(10, 1, 2, 3); // 16

或：

foo(10, [1, 2, 3]); //16

问题是如何实现这一点。我可以这样做：

function foo(number, ...args) {
    let toAddArr = Array.isArray(args[0]) ? args[0] : args;
    for (let toAdd of toAddArr) {
        number = number + toAdd;
    }
    return number;
}

Answer 1

你可以使用一些递归：

function foo(...args) {
    var sum = 0;
    args.forEach((arg) => {
        if (!Array.isArray(arg))
            sum += arg
        else
            sum += foo(...arg); // if it's an array, destructure
    });
    return sum;
}

使用该代码，如果需要，您甚至可以在数组内传递数组：）

使用for循环进行编辑：

function foo(...args) {
    var sum = 0;
    for (var arg of args) {
        if (!Array.isArray(arg))
            sum += arg
        else
            sum += foo(...arg); // if it's an array, destructure
    };
    return sum;
}

Answer 2

您可以将.concat与.apply一起使用，将.reduce用于function foo(...args) { return ([].concat.apply([], args)).reduce(function (prev, curr) { return prev + curr; }, 0); }，就像这样

geometry: function(feature) {
  var geom = feature.get('stylegeom');
  if (!geom) {
    geom = new ol.geom.MultiPoint(feature.getGeometry().getCoordinates());
    feature.set('stylegeom', geom);
  }
  return geom;
}

Example

Answer 3

您可以将参数转换为数组并将它们连接起来。

function foo(){
   return [].concat.apply([],Array.prototype.slice.call(arguments)).reduce( function (p,c) { return p + c; }, 0);
}
var x1 = foo(10, [1,2,3]);
console.log(x1);

var x2 = foo(10,1,2,3);
console.log(x2);

Answer 4

对于嵌套数组递归可能会很好地工作。您可以只有数字或数组或嵌套数组或混合。

  function add() {
    return Array.prototype.reduce.call(arguments, function(p, c) {
      if (Array.isArray(c)) {
        return p + add.apply(null, c);
      } else {
        return p + c;
      }
    });
  }

ES6：如果rest参数是一个数组，会发生什么？

4 个答案: