• Use one const or let declaration per variable. eslint: one-var

    1. // bad
    2. const items = getItems(),
    3.     goSportsTeam = true,
    4.     dragonball = 'z';
    6. // bad
    7. // (compare to above, and try to spot the mistake)
    8. const items = getItems(),
    9.     goSportsTeam = true;
    10.     dragonball = 'z';
    12. // good
    13. const items = getItems();
    14. const goSportsTeam = true;
    15. const dragonball = 'z';

  • Group all your consts and then group all your lets.

  • 13.4 Assign variables where you need them, but place them in a reasonable place.

    1. // bad - unnecessary function call
    2. function checkName(hasName) {
    3.   const name = getName();
    5.   if (hasName === 'test') {
    6.     return false;
    7.   }
    9.   if (name === 'test') {
    10.     this.setName('');
    11.     return false;
    12.   }
    14.   return name;
    15. }
    17. // good
    18. function checkName(hasName) {
    19.     return false;
    20.   }
    22.   const name = getName();
    24.   if (name === 'test') {
    25.     this.setName('');
    26.     return false;
    27.   }
    29.   return name;
    30. }

  • Don’t chain variable assignments. eslint: no-multi-assign

    Why? Chaining variable assignments creates implicit global variables.

  • Avoid using unary increments and decrements (++, --). eslint no-plusplus

    1. // bad
    3. const array = [1, 2, 3];
    4. let num = 1;
    5. num++;
    6. --num;
    8. let sum = 0;
    9. let truthyCount = 0;
    10. for (let i = 0; i < array.length; i++) {
    11.   let value = array[i];
    12.   sum += value;
    13.   if (value) {
    14.     truthyCount++;
    15.   }
    16. }
    18. // good
    20. const array = [1, 2, 3];
    22. num += 1;
    24. const sum = array.reduce((a, b) => a + b, 0);
    25. const truthyCount = array.filter(Boolean).length;

  • 13.7 Avoid linebreaks before or after = in an assignment. If your assignment violates , surround the value in parens. eslint operator-linebreak.

    Why? Linebreaks surrounding = can obfuscate the value of an assignment.

    1. // bad
    3. var some_unused_var = 42;
    5. // Write-only variables are not considered as used.
    6. var y = 10;
    7. y = 5;
    9. // A read for a modification of itself is not considered as used.
    10. var z = 0;
    11. z = z + 1;
    13. // Unused function arguments.
    14. function getX(x, y) {
    15.     return x;
    16. }
    18. // good
    20. function getXPlusY(x, y) {
    21.   return x + y;
    22. }
    24. var x = 1;
    25. var y = a + 2;
    27. alert(getXPlusY(x, y));
    29. // 'type' is ignored even if unused because it has a rest property sibling.
    30. // This is a form of extracting an object that omits the specified keys.
    31. var { type, ...coords } = data;