1. String.prototype.replaceAll: Eradicating Regex Mutation Traps

Prior to ES2021, replacing all occurrences of a substring in JavaScript was notoriously error-prone and fraught with edge-case vulnerabilities:

• The str.replace() Single-Match Trap: Calling 'hello world'.replace('l', 'x') only replaces the first instance (resulting in 'hexlo world'). To replace all instances, developers had to provide a global regular expression: str.replace(/l/g, 'x').
• The Regex Escape Injection Hazard: When replacing dynamic user-supplied strings, developers had to escape special regex characters (such as ., *, +, ?, [, ]). Forgetting to escape characters led to catastrophic regex injection vulnerabilities or runtime parsing crashes.
• The RegExp.lastIndex Stateful Bug: Reusing global RegExp objects across asynchronous functions introduced insidious bugs because global RegExp instances maintain internal state in their lastIndex property, causing alternating matching results in concurrent web requests.
• Replacement Dollar Patterns: Both replace and replaceAll support special replacement patterns: $$ inserts a dollar sign, $& inserts the matched substring, and $' inserts the portion of string following the match. In replaceAll, if the search string is not a regex, replacement patterns remain consistent without requiring double-escaping hacks.
• The ES2021 Solution: String.prototype.replaceAll(searchValue, replaceValue) executes directly in V8 C++ runtime code without spinning up the irregular expression parsing engine, eliminating regex compilation latency and improving string manipulation throughput.

// ES2021 Clean Substring Replacement
const query = 'SELECT * FROM users WHERE status = ? AND role = ?';
const sanitized = query.replaceAll('?', '$$VAL$$');
// Result: 'SELECT * FROM users WHERE status = $$VAL$$ AND role = $$VAL$$'

2. Logical Assignment Operators: Short-Circuiting Mutation Semantics

ES2021 introduced three logical assignment operators combining logical operations with variable assignment: &&=, ||=, and ??=. Crucially, these operators implement short-circuit evaluation semantics rather than unconditional assignment:

• Logical OR Assignment (a ||= b): Assigns b to a only if a is falsy. Equivalent to a || (a = b). Note that if a is truthy, the assignment operator is never executed, preventing unnecessary setter invocations or proxy traps!
• Logical AND Assignment (a &&= b): Assigns b to a only if a is truthy. Equivalent to a && (a = b).
• Nullish Coalescing Assignment (a ??= b): Assigns b to a only if a is null or undefined. Unlike ||=, it safely preserves valid falsy values like 0, false, and "":

interface AppConfig {
  retries?: number;
  verbose?: boolean;
}

function initializeOptions(opts: AppConfig) {
  // Sets retries only if null or undefined; preserves 0 retries!
  opts.retries ??= 3;
  
  // Sets verbose only if undefined/null; preserves false!
  opts.verbose ??= false;
  return opts;
}

3. Promise.any & AggregateError: First-Fulfillment Concurrency

JavaScript promises previously supported three combinators: Promise.all, Promise.allSettled, and Promise.race. ES2021 completed the quartet by introducing Promise.any:

Consider a high-availability edge proxy querying three independent DNS-over-HTTPS (DoH) upstreams (Cloudflare, Google, Quad9). Using Promise.any, the proxy dispatches all three queries in parallel; the moment the fastest upstream resolves, execution proceeds immediately. Only if all three upstreams fail does Promise.any reject with an AggregateError containing the underlying network exceptions.

4. Memory Management: WeakRef & FinalizationRegistry

ES2021 introduced advanced low-level capabilities for memory-sensitive JavaScript applications through WeakRef and FinalizationRegistry:

• WeakRef (Weak References): A standard object reference prevents the V8 garbage collector from reclaiming the object from heap memory. A WeakRef creates a reference that does not prevent garbage collection. Calling ref.deref() returns the target object if it still exists in memory, or undefined if the GC has already collected it.
• FinalizationRegistry: Registers cleanup callbacks executed after an object has been garbage collected, enabling developers to release unmanaged WebGL textures, close underlying POSIX file descriptors, or log memory leak diagnostics.
• The Non-Deterministic GC Invariant: The TC39 specification strongly cautions developers: garbage collection schedules are inherently non-deterministic. A WeakRef must never be used to drive critical application business logic, but strictly for opportunistic memory caches and unmanaged resource tracking.

// In-Memory LRU Cache with WeakRef
class WeakCache {
  #cache = new Map();

  set(key, obj) {
    this.#cache.set(key, new WeakRef(obj));
  }

  get(key) {
    const ref = this.#cache.get(key);
    if (!ref) return undefined;
    const value = ref.deref();
    if (!value) {
      this.#cache.delete(key); // Automatically purge stale keys
      return undefined;
    }
    return value;
  }
}

5. Numeric Separators & Developer Ergonomics

Numeric separators (_) allow developers to insert underscores inside numeric literals (such as 1_000_000_000 or binary bytes 0b1010_0001). In the V8 engine, numeric separators are stripped during the lexical analysis tokenization phase, meaning they introduce zero runtime bytecode overhead or memory impact while dramatically improving code review readability and preventing off-by-a-zero configuration errors in production financial systems.

6. The TC39 Process & Annual ECMAScript Release Cadence

ES2021 exemplifies the success of the TC39 annual release process instituted after ES6 (ES2015). Rather than waiting years for monolithic specification revisions, language features progress through four formal maturity stages (Stage 1 Proposal to Stage 4 Finished). Once a proposal achieves two independent browser implementations and full test262 suite validation, it is incorporated into the annual snapshot, guaranteeing predictable, incremental evolution for modern full-stack JavaScript architectures.