ES6+ Features

Destructuring unpacks values out of arrays or properties out of objects into distinct variables in one expression. Array form [a, b] = arr binds by position; object form {x, y} = obj binds by matching property name. To swap two variables you write [a, b] = [b, a]: the right side builds a temporary array, then its elements are assigned back, so no extra temp variable is needed.

Spread ... expands an iterable or object's contents in place. In an array literal [...iterable] it lays out each element, so [...'ab'] yields ['a', 'b']; in a call f(...arr) it passes each element as a separate argument; in an object literal {...obj} it copies own enumerable properties (a shallow copy). It reads from a source — unlike rest ..., which collects multiple items into one.

Use the class keyword with a name, an optional constructor for per-instance setup, and method definitions directly in the body (no commas, no function keyword). The constructor runs when you call new ClassName(args), which builds a fresh object, binds it to this, and returns it. Methods written in the body are shared, not copied per instance.

Default parameters let you write function f(x = 10) so a parameter gets a fallback value when the argument is missing. The default applies only when the argument is undefined — either omitted entirely or passed explicitly as undefined. Other falsy values like 0, '', null, or false are real arguments and suppress the default. The default expression is evaluated lazily, once per call, only when needed.

An ES module exposes bindings with export (named, or one default) and pulls them in elsewhere with import. Anything not exported stays private to the file — module scope is the top level, not the global scope, so top-level declarations do not become global variables. Each module runs once, has its own scope, and is always in strict mode automatically, with no 'use strict' directive needed.

class B extends A makes B a subclass of A. In B's constructor you must call super(args) before using this, which runs the parent constructor; super.method() invokes a parent method. static members belong to the class itself, not instances, and are inherited by subclasses. A #field is truly private — accessible only inside the declaring class body, invisible to subclasses and outside code, and not the same as a naming convention.

for...of iterates the values of an iterable (Array, String, Map, Set, etc.), so on ['a','b'] it yields 'a' then 'b'. for...in iterates the enumerable string property keys of any object, including inherited ones and extra properties added to an array, so on an array it yields index strings like '0', '1' plus any custom keys. Use for...of for ordered values, for...in for object keys.

a ?? b returns a unless a is null or undefined, in which case it returns b. It differs from ||, which returns the right side for any falsy left operand — 0, '', NaN, and false included. So 0 ?? 5 is 0 but 0 || 5 is 5. This makes ?? the correct choice for defaulting only on missing values while keeping legitimate falsy ones like 0 or ''.

?. reads a property, calls a method, or indexes safely: if the value on its left is null or undefined, the whole expression short-circuits and evaluates to undefined instead of throwing. So a?.b.c returns undefined when a is nullish, skipping the rest of the chain. Forms include obj?.prop, obj?.[key], and fn?.(). It only guards against nullish — other falsy values are accessed normally.

Dynamic import('./mod') is a function-like form that loads a module at runtime and returns a promise resolving to the module namespace object. Unlike a static top-level import, it can run conditionally, inside functions, with a specifier computed at runtime, and you await it or chain .then(). Bundlers use it for code splitting and lazy loading, so a chunk is fetched only when actually needed rather than upfront.

A class desugars to a constructor function plus prototype wiring: methods written in the body live on Constructor.prototype, shared by instances, exactly like manual prototype assignment. But classes are not pure sugar — their methods are non-enumerable (so they don't show up in for...in), a class declaration is not hoisted in a usable way (referencing it before declaration is a ReferenceError, unlike a function), and the whole body always runs in strict mode.

Destructuring composes recursively: const {a: {b}} = obj reaches into nested objects, aliasing renames with {x: y} (binding y), and = value supplies a default applied only when the slot is undefined. Rest ...rest gathers the remaining array elements or object properties into one binding (object rest must be last). You can destructure directly in a parameter list, e.g. function f({x = 1, y} = {}), combining defaults at both the property and the whole-parameter level.

ESM imports are live read-only bindings: an importer sees the exporter's current value, so a variable updated in the module reflects on the import side, unlike CommonJS, which copies the value at require time. ESM's import/export are static — resolvable before execution — which enables tree-shaking. It also supports top-level await. CommonJS (require/module.exports) is dynamic, synchronous, and value-copying, loaded at call time rather than parsed up front.