JavaScript gains features every year; most are small, a few rewire how ordinary code looks. Between 2020 and 2022 the language got the two operators that removed most defensive ifs (?. and ??), logical assignment, BigInt, the last two promise combinators, real class privacy, Error.cause, top-level await and a handful of methods that end common workarounds (at, replaceAll, Object.hasOwn). Everything here runs on Node 16 and in every evergreen browser, and this module's exercises use all of it. This lesson is the feature list with the precise semantics and the one pitfall of each.

Optional chaining ?.

user?.address?.city          // undefined if user or address is null/undefined — instead of throwing
user?.["home-address"]       // computed access
onDone?.(result)             // call only if defined
arr?.[0]

Short-circuits the whole chain on the first nullish link: a?.b.c.d evaluates to undefined without touching .c when a is nullish. It only guards null/undefined — a 0 or "" continues. Do not sprinkle it everywhere: ?. on a value that should exist hides a bug; use it where absence is a legitimate state.

Nullish coalescing ?? and logical assignment

const port = config.port ?? 3000;        // only null/undefined trigger the default — 0 stays 0
const label = config.label || "untitled";  // any falsy triggers — "" becomes "untitled"
opts.retries ??= 3;                       // assign only if nullish
opts.verbose ||= false;                   // assign if falsy
cache.entry &&= refresh(cache.entry);     // assign only if truthy

?? versus || is the difference between "missing" and "falsy" — choose deliberately (module 7). Mixing ?? with ||/&& without parentheses is a syntax error by design. The logical assignments short-circuit: a ??= f() does not call f when a is already set (unlike a = a ?? f(), which also always assigns — a difference visible with setters).

BigInt

const big = 9007199254740993n;                  // beyond Number.MAX_SAFE_INTEGER; the n suffix makes a BigInt
big + 1n;  big * 2n;  big ** 2n;  7n / 2n;     // 3n — integer division truncates
typeof big;                                      // "bigint"
big + 1;                                          // TypeError: cannot mix BigInt and other types — convert explicitly: Number(big), BigInt(1)
BigInt(1.5);                                      // RangeError
JSON.stringify({ big });                          // TypeError — provide toJSON or convert to string
0n === 0; 0n == 0;                                // false, true

Arbitrary-precision integers for ids, timestamps in nanoseconds, cryptography, exact money arithmetic. Mixed arithmetic is an error on purpose; Math functions do not accept BigInt.

Promise.allSettled (2020) and Promise.any (2021)

Module 8 covered them: every outcome, and first success with AggregateError on total failure. AggregateError itself is 2021.

globalThis, import(), import.meta

globalThis is the global object in every environment (window, self, global were platform-specific). Dynamic import() and import.meta (import.meta.url) are 2020 and the basis of module 9's ESM story. export * as ns from "mod" completes the re-export forms.

Strings and arrays

"a-b-c".replaceAll("-", "+");                      // every occurrence without a regex (2021)
[..."a1b2".matchAll(/\d/g)];                      // every match with groups (2020)
[1, 2, 3].at(-1);  "abc".at(-1);                  // negative indices (2022)
Object.hasOwn(obj, "k");                          // the safe hasOwnProperty (2022) — works on Object.create(null)
[1, [2, [3]]].flat(Infinity);  arr.flatMap(f);    // 2019, still underused
1_000_000; 0xFF_FF; 1_000n;                      // numeric separators (2021) — purely visual

Classes: fields, private members, static blocks (2022)

class Counter {
  static instances = 0;
  static { Counter.instances = 0; }        // static initialisation block — several statements at class load
  #count = 0;                              // private field
  count = 0;                               // public field
  #bump() { this.#count++; }               // private method
  static isCounter(x) { return #count in x; }   // brand check (16.4+)
  get value() { return this.#count; }
}

Module 5 covered the semantics; this is the year they became standard everywhere.

Error.cause (2022) and top-level await (2022)

new Error("save failed", { cause }) — module 7's wrapping idiom. Top-level await in ES modules makes module evaluation asynchronous and importers wait — for configuration and connections at startup; not available in CommonJS.

Regular expressions

The d flag / hasIndices (2022) gives match.indices with [start, end] per group — for highlighting and error positions (module 10). matchAll requires g. Named groups and lookbehind were 2018.

WeakRef and FinalizationRegistry (2021)

Module 6: hold without retaining; rarely appropriate.

Feature detection, and when to polyfill

Everything above is syntax or built-ins. Syntax (?., ??=, #x, numeric separators) cannot be polyfilled — a runtime that lacks it fails to parse the file; only a transpiler (Babel, esbuild, TypeScript with a lower target) can rewrite it. Built-ins (replaceAll, at, Object.hasOwn, Promise.any) can be detected and filled: if (!Array.prototype.at) { Object.defineProperty(Array.prototype, "at", { value(i) { … }, writable: true, configurable: true }); } — non-enumerable, guarded, following the spec (core-js does this for everything). Detect features, never user agents.

Common mistakes

• ?. on values that must exist (masking bugs); a?.b.c expecting .c to be guarded too (it is — the chain short-circuits — but (a?.b).c is not).
• || where ?? was meant for 0/""; ?? mixed with || without parentheses.
• Mixing BigInt and Number; JSON.stringify on BigInt.
• Polyfilling syntax (impossible) or patching prototypes with enumerable properties.
• Assuming a feature exists because it is "standard" — check the runtime's version.

Interview angle

• "?? versus ||?" Nullish (null/undefined) versus falsy; 0 and "" survive ??.
• "What does a?.b.c do when a is null?" The whole chain short-circuits to undefined; .c is never evaluated.
• "Why can't BigInt mix with Number?" Precision would be ambiguous; the language forces explicit conversion.
• "Can you polyfill optional chaining?" No — syntax needs transpiling; only built-ins can be polyfilled.
• "Name three ES2022 features." Class fields/private members/static blocks, Error.cause, top-level await, at(), Object.hasOwn, the d flag.

Key takeaways

• ?. guards nullish links and short-circuits the chain; ??/??= mean "missing", ||/||= mean "falsy".
• BigInt for big integers, never mixed implicitly with Number; n suffix; no JSON.
• allSettled/any/AggregateError, globalThis, import()/import.meta, matchAll, replaceAll, at, Object.hasOwn, numeric separators.
• 2022: class fields, #private, static blocks, brand checks, Error.cause, top-level await, regex d.
• Syntax must be transpiled; built-ins can be detected and polyfilled — detect features, not browsers.