4ca686b7be
So, I was reading the new Flow type strictness and noticed https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/ Specifically, I wondered whether the `sum_all` example would copy the arguments into an array, then loop over. Sadly, it does. ```js function sum_all(...rest) { let ret = 0; for (let i = 0; i < rest.length; i++) { ret += rest[i]; } return ret; } // output function sum_all() { var ret = 0; for (var _len = arguments.length, rest = Array(_len), _key = 0; _key < _len; _key++) { rest[_key] = arguments[_key]; } for (var i = 0; i < rest.length; i++) { ret += rest[i]; } return ret; } ``` But then I noticed if I changed `let i = 0` to `let i: number = 0`, it worked directly on `arguments`. That lead me down a rabbit hole to `Path#_guessExecutionStatusRelativeTo`. When tracing through, the last comparison made no sense to me. It was trying to find the index of `"init"` in a list of `["declarations"]` and `"body"` in `["directives", "body"]`. Red flags and such. But it makes sense when you're trying to compare the visitor order of the common ancestor path. Then we're trying to find `"init"` in a list of `["init", "test", "update", "body"]`. Oh, and there's `"body"` in there too! And now we know the `ForStatement`'s `init` is executed before the `body`.
babel-plugin-transform-es2015-parameters
Compile ES2015 default and rest parameters to ES5
This plugin transforms ES2015 parameters to ES5, this includes:
- Destructuring parameters
- Default parameters
- Rest parameters
Examples
In
function test(x = "hello", { a, b }, ...args) {
console.log(x, a, b, args);
}
Out
function test() {
var x = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "hello";
var _ref = arguments[1];
var a = _ref.a,
b = _ref.b;
for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
args[_key - 2] = arguments[_key];
}
console.log(x, a, b, args);
}
Installation
npm install --save-dev babel-plugin-transform-es2015-parameters
Caveats
Default parameters desugar into let declarations to retain proper semantics. If this is
not supported in your environment then you'll need the
transform-block-scoping plugin.
Usage
Via .babelrc (Recommended)
.babelrc
{
"plugins": ["transform-es2015-parameters"]
}
Via CLI
babel --plugins transform-es2015-parameters script.js
Via Node API
require("babel-core").transform("code", {
plugins: ["transform-es2015-parameters"]
});
Options
loose
boolean, defaults to false.
In loose mode, parameters with default values will be counted into the arity of the function. This is not spec behavior where these parameters do not add to function arity.
The loose implementation is a more performant solution as JavaScript engines will fully optimize a function that doesn't reference arguments. Please do your own benchmarking and determine if this option is the right fit for your application.
// Spec behavior
function bar1 (arg1 = 1) {}
bar1.length // 0
// Loose mode
function bar1 (arg1 = 1) {}
bar1.length // 1