What is a `static { ... }` initialization block in a JavaScript class body — when does it run, and what is `this` inside it?

## The gap it fills Before ES2022 there were two ways to do class-level setup, and both were awkward. You could cram logic into a static field initializer, which must be a single expression — so a loop or a `try/catch` meant smuggling in an immediately-invoked function. Or you could run statements *after* the class declaration, which leaves the class briefly half-configured and puts its setup somewhere a reader will not look. A static initialization block puts that code inside the class body where it belongs. ```js class Registry { static byCode = new Map(); static { for (const [code, label] of [[1, 'ok'], [2, 'retry'], [3, 'fail']]) { this.byCode.set(code, label); } } } Registry.byCode.get(2); // "retry" ``` ## When it runs Once, during evaluation of the class definition — the same moment the static fields are initialized, and before any other code can observe the finished class. Blocks and static fields share one ordering: **source order, top to bottom**. A block can therefore read a field declared above it and will see `undefined` for one declared below. ```js class Ordering { static a = 1; static { console.log(this.a, this.b); } // 1 undefined static b = 2; static { console.log(this.a, this.b); } // 1 2 } ``` A class can contain any number of blocks, and they all run in that same interleaved order. Because this is class-definition time, a throw inside a block propagates out of the `class` statement itself and the class binding is never created — useful for fail-fast validation of configuration the class depends on. ## What `this` is `this` is the class constructor being defined — the same value a static method sees when called on the class. There is no instance in scope, because none exists yet. `super` is also available and refers to the parent *class*, so `super.someStatic` reads the parent's static property: ```js class Parent { static defaults = { retries: 3 }; } class Child extends Parent { static config; static { this.config = { ...super.defaults, retries: 5 }; } } Child.config; // { retries: 5 } ``` The class binding is also in scope by name inside the block, so `Registry.byCode` works as well as `this.byCode`. Prefer `this` when a subclass should get its own value, and the explicit name when it must not vary. ## Access to private names A static block is inside the class body, so it can use the class's `#private` names — including private *instance* names, in the sense that it can capture a function that will later read them. That makes it the sanctioned mechanism for a controlled leak, sometimes called the friend pattern: ```js let readSecret; class Vault { #secret = 42; static { readSecret = (v) => v.#secret; } } readSecret(new Vault()); // 42 ``` Without the block you would have to define such an accessor in a constructor or a method, which runs per instance instead of once. ## The restrictions A static block is not a function body, and the grammar reflects that. `return` is a syntax error. `arguments` is not available. `await` and `yield` cannot be used as expressions there, so no top-level await inside a block. `var` declarations and function declarations inside it are scoped to the block, not to the class or the module. The block does have its own variable scope, so temporaries you declare there do not leak. ## When to reach for one Good uses: building a lookup table or frozen constant that needs more than one expression; validating environment or configuration at definition time so a misconfigured class fails immediately rather than on first call; wiring a subclass into a registry the parent owns; setting up the friend accessor above. Weak uses: anything with side effects beyond the class — network calls, timers, writes to shared modules — because the block runs the instant the module containing the class is evaluated, whether or not anyone ends up using the class. Setup that is expensive or fallible is often better done lazily behind a static getter.