JavaScript Prototype Chain: How Inheritance Really Works in JS

const animal = {
  breathe() { return this.name + ' is breathing'; }
};

const dog = Object.create(animal); // dog.[[Prototype]] = animal
dog.name = 'Rex';
dog.bark = () => 'woof';

// Property lookup:
dog.bark();    // 'woof' — found on dog itself
dog.breathe(); // 'Rex is breathing' — NOT on dog, found on animal
dog.toString(); // found on Object.prototype (top of chain)

// Chain: dog → animal → Object.prototype → null
Object.getPrototypeOf(dog) === animal;         // true
Object.getPrototypeOf(animal) === Object.prototype; // true
Object.getPrototypeOf(Object.prototype) === null;   // true

// Constructor function .prototype = template for instances
function Person(name) { this.name = name; }
Person.prototype.greet = function() { return 'Hi, I am '+this.name; };

const alice = new Person('Alice');
alice.greet(); // Works! From Person.prototype

// new keyword does:
// 1. Creates empty object {}
// 2. Sets [[Prototype]] = Person.prototype
// 3. Calls Person with this = new object
// 4. Returns the object

// .prototype (on function): used as [[Prototype]] for new instances
// [[Prototype]] (on object): the actual chain link
alice.__proto__ === Person.prototype; // true (same as getPrototypeOf)

class Animal {
  constructor(name) { this.name = name; }
  speak() { return this.name + ' makes a sound'; }
}

class Dog extends Animal {
  speak() { return this.name + ' barks'; }
  fetch() { return this.name + ' fetches!'; }
}

const dog = new Dog('Rex');
dog.speak();  // 'Rex barks' — overridden
dog.fetch();  // 'Rex fetches!' — own method

// Class IS just prototype sugar:
// Animal.prototype.speak exists
// Dog.prototype.[[Prototype]] === Animal.prototype
// dog.[[Prototype]] === Dog.prototype

// Problem: inheritance is single-parent
// Solution: copy methods from multiple sources
const Serializable = {
  toJSON() { return JSON.stringify(this); },
  fromJSON(json) { return Object.assign(Object.create(this),JSON.parse(json));}
};

const Validatable = {
  validate() { return this.rules.every(r=>r(this)); }
};

class User {}
Object.assign(User.prototype, Serializable, Validatable);
// User instances now have toJSON, fromJSON, validate
// Multiple mixins without deep inheritance hierarchy