ES6: What happens if the rest parameter is an array?

Question

if I have:

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

and I want a caller to be able to call foo like:

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

or:

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

The question is how to implement this. Can I do this:

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

You could use some recursion:

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

With that code, you can even pass arrays inside arrays inside arrays if you want :)

Edit, with a for loop:

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

Well you can convert the arguments to an array and concat them.

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 3

You can use .concat with .apply, and for sum .reduce, like this

function foo(...args) {
  return ([].concat.apply([], args)).reduce(function (prev, curr) {
    return prev + curr;
  }, 0);
}

Example

Answer 4

for nested arrays recursion might work nicely. You can have only numbers or arrays or nested arrays or mixed.

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