javascript

JavaScript Rules

Modern Syntax

• const by default, let when reassignment is needed, never var. var is function-scoped and hoisted — it creates bugs that const/let (block-scoped) prevent
• Arrow functions for callbacks and short functions. Regular function for top-level declarations and methods that need this. Arrow functions inherit this from the enclosing scope — using them as object methods breaks this binding
• Template literals over concatenation: `Hello ${name}` not "Hello " + name. Tagged templates (html`...`) for DSLs and sanitization
• Destructure at point of use: const { name, email } = user — but don't deeply destructure (const { address: { city } } = user) because it obscures the data source and throws on null
• Optional chaining (?.) and nullish coalescing (??) over manual checks. ?? only catches null/undefined, NOT 0, "", or false — that's the difference from ||. If you want to default on all falsy values, use ||. If only null/undefined, use ??

Async

• async/await over .then() chains — flatter, readable, debuggable with stack traces. .then() loses the call stack on errors
• try/catch in async functions catches both sync throws and rejected promises. But catch at the right level — wrapping every line in try/catch is noise. Catch where you can handle the error meaningfully
• Promise.all() for independent concurrent operations — runs in parallel. Promise.allSettled() when you need all results even if some fail. Promise.all() short-circuits on the first rejection and you lose the other results
• Unhandled promise rejections crash Node.js (v15+) and log warnings in browsers. Always handle them: return the promise, await it, or attach .catch()
• for await...of for async iterables (streams, paginated APIs). Don't await inside a regular for loop when operations are independent — that serializes them unnecessarily

Functions

• Pure functions where possible: same input → same output, no side effects. Pure functions are testable without mocks, cacheable, and safe to parallelize
• Default parameters: function fetch(url, retries = 3) — but defaults are evaluated left-to-right per call, so function f(a, b = a * 2) works and function f(a = b, b) doesn't
• Return early to flatten nesting: guard clauses at the top (if (!user) return null;), happy path at indent level 1
• Named exports for tree-shaking: export function fetchUser() — default exports can't be tree-shaken by name and make refactoring harder (the import name is arbitrary)