Prototypes & Inheritance

Every object has a hidden [[Prototype]] link to another object. When you read a property, the engine checks the object itself, then follows [[Prototype]] up the chain object by object until it finds the property or reaches null, where the search ends and the result is undefined. This is how inheritance and method sharing work in JavaScript.

Objects inherit by linking to a prototype rather than copying. Object.create(parent) makes a new object whose [[Prototype]] is parent, while Object.setPrototypeOf(child, parent) rewires an existing object's link. A property missing on the child is then resolved by walking up to the parent, so the parent's methods are shared live, not duplicated, across all children.

Object.freeze(obj) makes obj immutable: you cannot add, remove, or change its own properties, and it returns that same object, not a copy. It is shallow — only the top level is frozen, so a nested object stored as a property can still be mutated through its reference. In strict mode a write to a frozen property throws a TypeError.

__proto__ is an instance's link to its own prototype — the object used in lookup; it is deprecated, so prefer Object.getPrototypeOf. .prototype exists only on constructor functions: it is the object that new assigns as the new instance's [[Prototype]]. So (new Foo).__proto__ === Foo.prototype, and a plain instance has no .prototype of its own.

new Proxy(target, handler) wraps a target object so operations on the proxy run through the handler first. Each handler method is a trap — get, set, has, deleteProperty, and others — that intercepts the matching fundamental operation, letting you customise or validate it. A trap you omit falls through to the default behaviour on the target unchanged.

They form a ladder. preventExtensions only blocks adding new properties. seal does that and also marks existing ones non-configurable, so none can be deleted, but their values stay writable. freeze adds non-writable on top, so nothing can change at all. The matching tests are isExtensible, isSealed, and isFrozen.

new String('hi') returns a wrapper object — typeof gives object, not string — boxing the primitive in a String instance. Literals like 'hi' stay primitives, and when you call a method the engine boxes them in a short-lived temporary wrapper, reads through its prototype, then discards it. Explicit wrapper objects break ===, typeof, and truthiness, so literals are preferred.

JavaScript has no enum keyword, so you build one from a frozen object: const Color = Object.freeze({ RED: 'red', GREEN: 'green' }). Freezing blocks reassignment and new members. Using Symbol('RED') as the values guarantees each member is unique and never equal to a stray string, at the cost of not serializing to JSON.

An arrow class field is an own instance property assigned in the constructor, not a prototype method. So investor.getPayment finds the base field first and the subclass's prototype method on Investor.prototype is shadowed — the override never runs.

new Foo() creates an object whose [[Prototype]] is set to Foo.prototype, which itself links up to Object.prototype, forming the lookup chain. The chain ends at an object with no prototype: Object.prototype, whose [[Prototype]] is null, and objects made with Object.create(null), which have no prototype and so do not inherit Object's methods.