What is the prototype chain in JavaScript?

Every object has an internal link to another object, its prototype. Reading a property checks the object first, then walks up each prototype until it finds a match or reaches null. This chain is how objects share methods without copying them.

What's the difference between __proto__ and Object.getPrototypeOf?

__proto__ is a legacy accessor property that exposes an object's prototype and predates standardization. Object.getPrototypeOf() and Object.setPrototypeOf() are the modern, standardized equivalents. Use the function forms in real code; __proto__ remains mostly for compatibility.

Is JavaScript class syntax actually different from prototypes?

No — a class declaration creates a constructor function with methods placed on its prototype object. This works just like the older function-based pattern. Class syntax adds strictness, cleaner inheritance with extends, and no hoisting of the body. Under the hood, instances still link through the same prototype chain.

What is property shadowing in JavaScript?

Shadowing happens when an object defines its own property with the same name as one on its prototype. The own property wins, and lookups never reach the prototype's version for that name. The prototype's property still exists; it is just hidden for that one object.

How do I check if a property is inherited or defined directly on an object?

Call obj.hasOwnProperty('name') to check if the property exists directly on the object itself. It returns false for properties found only further up the prototype chain. This distinguishes an object's own data from methods or fields it inherits.

JavaScript Prototypal Inheritance

The Prototype Chain

Every object links to another object called its prototype, forming a chain.

const animal = { eats: true };
const rabbit = Object.create(animal);
rabbit.hops = true;
rabbit.eats; // true — found via the prototype chain

Property lookups walk up the chain until the property is found or the chain ends.
The chain ends at Object.prototype, whose own prototype is null.
Methods like .toString() come from Object.prototype, inherited by nearly everything.
Writing a property always creates it on the object itself, never on the prototype.
Reading a missing property returns undefined only after the whole chain is checked.

Creating and Inspecting Prototypes

Use Object.create(proto) to make a new object with a specific prototype directly.

const base = { greet() { return 'hi'; } };
const obj = Object.create(base);
obj.greet(); // 'hi'

Pass null to Object.create(null) to build an object with no prototype at all.
Use Object.getPrototypeOf(obj) to read an object's current prototype safely.
```
Object.getPrototypeOf(obj) === base; // true
```
Use Object.setPrototypeOf(obj, proto) to change a prototype after creation.
Avoid __proto__ in new code; it works but is a legacy accessor, not a clean API.
Object.create is the most direct way to model inheritance without constructors.

Constructor Functions and prototype

Every function has a prototype property used as the prototype for objects it constructs.

function Dog(name) { this.name = name; }
Dog.prototype.bark = function () { return `${this.name} barks`; };
const rex = new Dog('Rex');
rex.bark(); // 'Rex barks'

Calling a function with new creates an object linked to that function's prototype.
Methods defined on prototype are shared by every instance, saving memory.
Instance-specific data, like name, belongs on this inside the constructor, not the prototype.
Check rex instanceof Dog to confirm Dog.prototype is in rex's prototype chain.
This pattern is the original way JavaScript implemented inheritance before class.

Class Syntax as Prototype Sugar

A class declaration creates a constructor function with methods on its prototype, just like the manual pattern.

class Dog {
  constructor(name) { this.name = name; }
  bark() { return `${this.name} barks`; }
}
typeof Dog; // 'function'

extends sets up the prototype chain between parent and child classes automatically.

class Puppy extends Dog {
  bark() { return `${super.bark()} (puppy style)`; }
}

super.method() inside a subclass calls the parent's version via the prototype chain.
Class methods are non-enumerable by default, unlike properties added with plain assignment.
Class bodies run in strict mode and are not hoisted like function declarations.
Despite the new syntax, Puppy.prototype is still a plain object linked to Dog.prototype.

Own Properties vs Shadowing

An own property lives directly on the object; an inherited one lives on its prototype.

const base = { color: 'red' };
const item = Object.create(base);
item.hasOwnProperty('color'); // false

Assigning to item.color creates a new own property that shadows the inherited one.

item.color = 'blue';
item.color; // 'blue' — own property wins
base.color; // 'red' — unchanged

Use Object.hasOwn(obj, key) as the modern, safer alternative to hasOwnProperty().
Shadowing never deletes or modifies the prototype's original property.
Use delete item.color to remove the own property and reveal the inherited one again.
for...in enumerates inherited properties too; filter with hasOwnProperty() when needed.