Static Members and Static Blocks

## Two objects, not one Every class declaration creates two linked objects. There is the constructor function itself — the binding you get from `class Circle { ... }` — and there is `Circle.prototype`, the object every instance receives as its prototype. `static` is the keyword that decides which of those two objects a member is installed on. ```js class Circle { static PI = 3.14159; // own property of Circle static area(r) { return this.PI * r * r; } // own property of Circle constructor(r) { this.r = r; } // own property of each instance describe() { return `r=${this.r}`; } // property of Circle.prototype } Circle.area(2); // 12.56636 new Circle(2).area; // undefined new Circle(2).describe();// "r=2" ``` ## Why an instance cannot see a static Reading a property off `new Circle(2)` walks the object's prototype chain: the instance itself, then `Circle.prototype`, then `Object.prototype`, then `null`. The constructor `Circle` is not a link in that chain — it only *holds* `Circle.prototype` in its `.prototype` property. Nothing about that arrangement lets an instance fall back to the class. That is the whole explanation for `instance.area === undefined`, and it is why you must write `Circle.area(...)`, or `this.constructor.area(...)` if you are inside an instance method and want to reach the static through the object's own class. ## Only one copy exists A static field is one property on one object. It is not copied per instance, and mutating it is visible to every reader of the class for the lifetime of the program: ```js class Widget { static made = 0; constructor() { Widget.made++; } } new Widget(); new Widget(); Widget.made; // 2 ``` That sharing is exactly why static counters and caches need care: any code holding the class can read or write them. ## Property attributes Static methods are defined the same way prototype methods are — writable, configurable, **non-enumerable**. Public static fields are created as ordinary data properties: writable, configurable, and **enumerable**. The observable consequence: ```js Object.keys(Circle); // ["PI"] — the field, not the method Object.getOwnPropertyNames(Circle); // includes "length", "name", "prototype", "PI", "area" ``` So a `for...in` or `Object.keys` over a class shows static fields but hides static methods. Static fields also evaluate top-to-bottom at class-definition time, and their initializer expressions run with `this` bound to the class, which lets a later field read an earlier one: `static DIAMETER_FACTOR = 2; static CIRC_FACTOR = this.DIAMETER_FACTOR * this.PI;`. ## `this` inside a static Inside a static method, `this` is the object the method was called on — normally the class. `Circle.area(2)` gives `this === Circle`. Because class bodies are always strict-mode code, detaching the method loses that binding rather than falling back to a global: ```js const area = Circle.area; area(2); // TypeError: Cannot read properties of undefined (reading 'PI') ``` If you need a free-floating reference, bind it or wrap it: `const area = r => Circle.area(r)`. ## What statics are actually for The standard library is the best catalogue of good uses. Named constructors and factories that return an instance without the caller writing `new` (`Promise.resolve`, `Array.from`, `Object.create`); operations that belong to the type rather than to any one value (`Number.isNaN`, `JSON.parse`); shared constants (`Number.MAX_SAFE_INTEGER`). Application code follows the same shapes: `static fromJSON(raw)` that validates and returns an instance, `static EMPTY` as a shared sentinel, a lookup table computed once. ## The bugs this causes The two everyday mistakes are writing `this.PI` inside an *instance* method and getting `undefined` (instances do not inherit statics — use `Circle.PI` or `this.constructor.PI`), and calling `instance.someStatic()` and getting a `TypeError: instance.someStatic is not a function`. Both are the same prototype-chain fact seen from different sides.