Airbnb JavaScript Style Guide - Summary

Types

• Primitives: access by value (string, number, boolean, null, undefined, symbol, bigint)
• Complex: access by reference (object, array, function)

References

• Use const for all references; avoid var
• Use let only if reassigning references
• Both const and let are block-scoped, unlike function-scoped var

Objects

• Use literal syntax for object creation
• Use computed property names when creating objects with dynamic properties
• Use object method and property value shorthand
• Group shorthand properties at the beginning
• Only quote invalid identifier properties
• Don't call Object.prototype methods directly
• Prefer object spread ({...obj}) over Object.assign

Arrays

• Use literal syntax for array creation
• Use Array#push instead of direct assignment
• Use array spreads ... to copy arrays
• Use ... for iterable conversion; Array.from for array-like objects
• Use return statements in array method callbacks
• Use line breaks after opening and before closing array brackets for multiline arrays

Destructuring

• Use object destructuring when accessing multiple properties
• Use array destructuring
• Use object destructuring for multiple return values, not array destructuring

Strings

• Use single quotes ('') for strings
• Don't write strings that cause line breaks over 100 characters
• Use template literals for string composition
• Never use eval() on strings
• Don't unnecessarily escape characters

Functions

• Use named function expressions instead of function declarations
• Wrap IIFEs in parentheses
• Never declare functions in non-function blocks
• Never name a parameter arguments
• Use rest syntax (...) instead of arguments
• Use default parameter syntax rather than mutating function arguments
• Avoid side effects with default parameters
• Always put default parameters last
• Never use the Function constructor

Arrow Functions

• Use arrow functions for anonymous functions
• Omit braces and use implicit return when function body is a single expression
• Wrap expressions over multiple lines in parentheses
• Always include parentheses around arguments
• Avoid confusing arrow function syntax with comparison operators

Classes & Constructors

• Use class syntax; avoid manipulating prototype directly
• Use extends for inheritance
• Methods can return this for method chaining
• Don't use empty constructors or ones that just delegate to parent
• Avoid duplicate class members
• Class methods should use this or be static

Modules

• Always use ES modules (import/export) over non-standard module systems
• Don't use wildcard imports
• Don't export directly from an import
• Only import from a path in one place
• Don't export mutable bindings
• Prefer default export for single exports
• Put all imports above non-import statements
• Multi-line imports should follow proper indentation

Iterators and Generators

• Prefer JavaScript's higher-order functions over loops
• Don't use generators for now (poor ES5 transpilation)

Properties

• Use dot notation when accessing properties
• Use bracket notation [] when accessing properties with a variable
• Use exponentiation operator (**) when calculating exponentiations

Variables

• Always use const or let, never undeclared variables
• Use one declaration per variable or assignment
• Group all consts and then all lets
• Assign variables where you need them in a reasonable place
• Don't chain variable assignments
• Avoid unary increments and decrements (++, --)
• Avoid linebreaks before or after = in assignments

Comparison Operators & Equality

• Use === and !== over == and !=
• Use shortcuts for booleans, but explicit comparisons for strings and numbers
• Use braces for case/default clauses with lexical declarations
• Keep ternaries simple and on single lines when possible
• Avoid unneeded ternary statements
• Use parentheses when mixing operators
• Use nullish coalescing (??) only for null/undefined cases

Blocks

• Use braces with multiline blocks
• Put else on same line as closing brace of if
• Avoid unnecessary else blocks when if contains a return

Control Statements

• Break long conditions onto multiple lines with operators at the start of lines
• Don't use selection operators in place of control statements

Comments

• Use /** ... */ for multiline comments
• Use // for single line comments above the subject
• Start comments with a space for readability
• Prefix comments with FIXME: or TODO: for actionable items

Whitespace

• Use soft tabs (2 spaces)
• Place 1 space before leading braces
• Place 1 space before parentheses in control statements
• Set off operators with spaces
• End files with a single newline
• Use indentation for long method chains with leading dots
• Leave a blank line after blocks and before statements
• Don't pad blocks with blank lines or use multiple blank lines

Commas

• Use trailing commas, not leading
• Include additional trailing commas for cleaner diffs

Semicolons

• Use semicolons at the end of statements

Type Casting & Coercion

• Perform type coercion at the beginning of statements
• Use explicit conversion functions: String(), Number(), parseInt(), Boolean()

Naming Conventions

• Be descriptive; avoid single letter names
• Use camelCase for objects, functions, and instances
• Use PascalCase for classes and constructors
• Don't use leading/trailing underscores
• Don't save references to this; use arrow functions or bind
• Filename should match default export name
• Acronyms should be all uppercase or all lowercase

Accessors

• Accessor functions aren't required but be consistent if used
• Use verb prefixes like get, set, is, has appropriately

Events

• Pass objects with data rather than raw values when triggering events

jQuery

• Prefix jQuery objects with $
• Cache jQuery lookups
• Use optimal selectors and scoping for DOM queries

Testing

• Write tests for all code
• Aim for high test coverage
• Write regression tests when fixing bugs