Parenthesis around single arguments in arrow functions

Always use parentheses around the arguments. Omitting the parentheses makes the functions less readable and only works for single arguments.

Why? These declarations read better with parentheses. They are also required when you have multiple parameters so this enforces consistency.

 // bad
 [1, 2, 3].map(x => x * x);

 // good
 [1, 2, 3].map((x) => x * x);

This stuck out to me as odd. It’s an intentional part of the spec to make it more readable for simple cases.

Anyways, I’m interested in discussing this.

[jamiebuilds]

Sure, the consistency is good. But I think the rule could likely be improved upon.

In my experience writing ES6 over the last year or so, 90% of the time when you are writing an arrow function expression it’s with only a single param.

If it got to be more than that it should likely be expanded to a block arrow function in which case it should always use parentheses.

ie.

// good
[1, 2, 3].map(n => n * 2);

// bad
[1, 2, 3].map(n => {
  return n * 2;
});

// good
var fn = (a, b, c) => {
  return a + b + c;
};

// bad
var fn = (a, b, c) => a + b + c;

This is how I’ve seen most people write their code when they submit issues to Babel.

[nkbt]

I go for readability over consistency in this case. Moreover it is way more often to have only one argument. At least as for my experience. Parenthesis is excessive for 95% of all my cases. To be honest I do lots of D3 and have the only argument for all function almost all the time.

Currying without parenthesis looks awesome too