Variables

  • 13.1 Always use const or let to declare variables. Not doing so will result in global variables. We want to avoid polluting the global namespace. Captain Planet warned us of that. eslint: no-undef prefer-const

    1. // bad
    2. superPower = new SuperPower();
    4. // good
    5. const superPower = new SuperPower();

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

    Why? It’s easier to add new variable declarations this way, and you never have to worry about swapping out a ; for a , or introducing punctuation-only diffs. You can also step through each declaration with the debugger, instead of jumping through all of them at once.

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

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

    Why? This is helpful when later on you might need to assign a variable depending on one of the previous assigned variables.

    1. // bad
    2. let i, len, dragonball,
    3.     items = getItems(),
    4.     goSportsTeam = true;
    6. // bad
    7. let i;
    8. const items = getItems();
    9. let dragonball;
    10. const goSportsTeam = true;
    11. let len;
    13. // good
    14. const goSportsTeam = true;
    15. const items = getItems();
    16. let dragonball;
    17. let i;
    18. let length;

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

    Why? let and const are block scoped and not function scoped.

    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.   if (hasName === 'test') {
    20.     return false;
    21.   }
    23.   const name = getName();
    25.   if (name === 'test') {
    26.     this.setName('');
    27.     return false;
    28.   }
    30.   return name;
    31. }

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

    Why? Chaining variable assignments creates implicit global variables.

    1. // bad
    2. (function example() {
    3.   // JavaScript interprets this as
    4.   // let a = ( b = ( c = 1 ) );
    5.   // The let keyword only applies to variable a; variables b and c become
    6.   // global variables.
    7.   let a = b = c = 1;
    8. }());
    10. console.log(a); // throws ReferenceError
    11. console.log(b); // 1
    12. console.log(c); // 1
    14. // good
    15. (function example() {
    16.   let a = 1;
    17.   let b = a;
    18.   let c = a;
    19. }());
    21. console.log(a); // throws ReferenceError
    22. console.log(b); // throws ReferenceError
    23. console.log(c); // throws ReferenceError
    25. // the same applies for `const`

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

    Why? Per the eslint documentation, unary increment and decrement statements are subject to automatic semicolon insertion and can cause silent errors with incrementing or decrementing values within an application. It is also more expressive to mutate your values with statements like num += 1 instead of num++ or num ++. Disallowing unary increment and decrement statements also prevents you from pre-incrementing/pre-decrementing values unintentionally which can also cause unexpected behavior in your programs.

    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];
    21. let num = 1;
    22. num += 1;
    23. num -= 1;
    25. const sum = array.reduce((a, b) => a + b, 0);
    26. const truthyCount = array.filter(Boolean).length;

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

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

    1. // bad
    2. const foo =
    3.   superLongLongLongLongLongLongLongLongFunctionName();
    5. // bad
    6. const foo
    7.   = 'superLongLongLongLongLongLongLongLongString';
    9. // good
    10. const foo = (
    11.   superLongLongLongLongLongLongLongLongFunctionName()
    12. );
    14. // good
    15. const foo = 'superLongLongLongLongLongLongLongLongString';

  • 13.8 Disallow unused variables. eslint: no-unused-vars

    Why? Variables that are declared and not used anywhere in the code are most likely an error due to incomplete refactoring. Such variables take up space in the code and can lead to confusion by readers.

    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;
    32. // 'coords' is now the 'data' object without its 'type' property.