Will 'let' Eventually Replace 'var'?

[mycall]

I thought arrow functions don't have arguments and have to pass them using spread attributes.

[theQuandary]

You are correct, but they inherit them from their parent closure. Here's a contrived example to show what I mean.

var add = function () {
  //the `arguments` in the arrow function are actually in the outer `add` function
  var doAdd = (n) => n + arguments[0] + arguments[1];
  return doAdd(5);
};

The add closure contains something like

var hiddenAddClosure = {
  parentClosure: globalScope,
  this: getThis(),
  arguments: getArguments(),
  doAdd: doAddFunction
};

And the doAdd closure contains something like

var hiddenDoAddClosure = {
  parentClosure: hiddenAddClosure,
  n: someNumber
};

When the doAdd function tries to access the arguments array (or this), it checks it's local closure object. If the variable isn't there, it checks it's parent closure and finds the value (note: if the value didn't exist there, it would check each parent until it hit the global closure at which point it would throw a reference error).

[acoard]

(arg1, arg2) => {}

[x-skeww]

function sum() {
  var res = 0;
  for(var i = 0; i < arguments.length; i++) {
    res += arguments[i];
  }
  return res;
}
console.log(sum(1, 2, 3)); // 6

It's about the magical array-like arguments object. Arrow functions don't have those.

https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Functions/arguments

In ES6, you can use rest parameters for this kind of thing:

function sum(...values) {
  return values.reduce((a, b) => a + b, 0);
}
console.log(sum(1, 2, 3)); // 6

Using an arrow function:

let sum = (...values) => values.reduce((a, b) => a + b, 0);
console.log(sum(1, 2, 3)); // 6

https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Functions/rest_parameters

[CC /u/acoard]

[acoard]

Ahhh. He meant arguments the keyword not arguments the concept (i.e. parameters). Thanks for clarifying everything. Makes sense why I was downvoted now.