Static Initialization Block

Documentation Index

Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt

Use this file to discover all available pages before exploring further.

class ClassName {
  static staticProperty = "initial value";

  static {
    // Statements execute during class evaluation
    this.staticProperty = this.staticProperty.toUpperCase();
  }
}

​

Execution Mechanics

• Evaluation Timing: The block executes synchronously and exactly once when the JavaScript engine evaluates the class definition. It does not run during the instantiation of class objects.
• Context Binding: Inside the static block, the this keyword is bound to the class constructor object itself, not to an instance of the class.
• Lexical Ordering: A class can contain multiple static initialization blocks. They are evaluated in lexical (top-to-bottom) order, interleaved with static field declarations.

class ExecutionOrder {
  static propA = 1;

  static {
    console.log(this.propA); // 1
    this.propB = 2; 
  }

  static propC = 3;

  static {
    console.log(this.propC); // 3
  }
}

​

Scope and Access

• Privileged Access: The static block shares the lexical scope of the class body. It has privileged access to all private members of the class. This includes not only private static fields and methods, but also private instance fields and methods. This capability allows the block to interact with or share references to private instance state before the class is fully exposed to the surrounding scope.
• Local Scope: Variables declared using let or const inside the static block are block-scoped. Variables declared using var are scoped to the static block’s own VariableEnvironment, which acts as a function boundary in this context. Consequently, declarations do not leak into the outer scope, nor do they automatically become static properties of the class.

class ScopedClass {
  static #privateStaticField;
  #privateInstanceField;

  static {
    const localConst = "Internal State";
    var localVar = "Does not leak";
    
    this.#privateStaticField = localConst;
    
    // The block also recognizes #privateInstanceField, 
    // allowing privileged access to instance internals if an instance is passed in.
  }
  // localConst and localVar are inaccessible here
}

​

Constraints and Limitations

• Synchronous Execution: The block is strictly synchronous. The await keyword is a syntax error inside a static initialization block.
• No Generators: The yield keyword cannot be used within the block.
• No Return: A return statement is not permitted and will throw a SyntaxError.
• Super Binding: While super() cannot be invoked (as the block is not a constructor), super.property or super.method() can be used to access static members of a parent class.