JavaScript's Hidden Superpower: Prototypal Inheritance from __proto__ to class

const animal = {
  breathe() { return 'breathing'; }
};

const dog = {
  bark() { return 'woof'; }
};

// Set dog's prototype to animal
Object.setPrototypeOf(dog, animal);

console.log(dog.bark());    // "woof"   - own property
console.log(dog.breathe()); // "breathing" - found on prototype
console.log(dog.toString()); // "[object Object]" - found on Object.prototype

// The chain: dog -> animal -> Object.prototype -> null
console.log(Object.getPrototypeOf(dog) === animal);          // true
console.log(Object.getPrototypeOf(animal) === Object.prototype); // true
console.log(Object.getPrototypeOf(Object.prototype));         // null

// hasOwnProperty checks only own properties
console.log(dog.hasOwnProperty('bark'));    // true
console.log(dog.hasOwnProperty('breathe')); // false - it's inherited

// Base object (the "class" in prototypal terms)
const Vehicle = {
  init(make, model) {
    this.make = make;
    this.model = model;
    return this;
  },
  describe() {
    return `${this.make} ${this.model}`;
  },
};

// Create Car that delegates to Vehicle
const Car = Object.create(Vehicle);
Car.honk = function() { return 'Beep!'; };

// Create an instance of Car
const myCar = Object.create(Car).init('Toyota', 'Camry');

console.log(myCar.describe()); // "Toyota Camry" - from Vehicle
console.log(myCar.honk());     // "Beep!" - from Car

// Chain: myCar -> Car -> Vehicle -> Object.prototype -> null
console.log(Object.getPrototypeOf(myCar) === Car);         // true
console.log(Object.getPrototypeOf(Car) === Vehicle);       // true

// Pure dictionary with no prototype pollution risk
const cache = Object.create(null);
cache['constructor'] = 'safe'; // won't collide with Object.prototype.constructor
console.log(Object.getPrototypeOf(cache)); // null

// Constructor function (PascalCase by convention)
function Animal(name, sound) {
  // 'this' is the new object
  this.name = name;
  this.sound = sound;
}

// Methods on prototype - shared across ALL instances (not copied per instance)
Animal.prototype.speak = function() {
  return `${this.name} says ${this.sound}`;
};

const cat = new Animal('Cat', 'meow');
const dog = new Animal('Dog', 'woof');

// Both instances share the same speak function
console.log(cat.speak === dog.speak); // true - same function reference

// What 'new' does under the hood:
function newKeyword(Constructor, ...args) {
  const obj = Object.create(Constructor.prototype); // set prototype
  const result = Constructor.apply(obj, args);       // call constructor
  return result instanceof Object ? result : obj;    // return new object
}

const cat2 = newKeyword(Animal, 'Cat2', 'purr');
console.log(cat2.speak()); // "Cat2 says purr"

class Animal {
  constructor(name) {
    this.name = name;
  }

  speak() {
    return `${this.name} makes a noise.`;
  }

  // Static methods go on the constructor, not the prototype
  static create(name) {
    return new Animal(name);
  }
}

class Dog extends Animal {
  constructor(name) {
    super(name); // calls Animal.constructor
  }

  speak() {
    return `${this.name} barks.`; // overrides Animal.speak
  }
}

const d = new Dog('Rex');
console.log(d.speak());                   // "Rex barks."
console.log(d instanceof Dog);            // true
console.log(d instanceof Animal);         // true - prototype chain

// Under the hood, 'class' creates the same prototype structure:
console.log(typeof Dog);                  // "function"
console.log(Dog.prototype.constructor === Dog); // true
console.log(Object.getPrototypeOf(Dog) === Animal); // true (static chain)
console.log(Object.getPrototypeOf(Dog.prototype) === Animal.prototype); // true

const parent = { inherited: true };
const child = Object.create(parent);
child.own = true;

// for...in includes inherited enumerable properties
for (const key in child) {
  console.log(key); // "own", then "inherited"
}

// Safe iteration - only own properties
for (const key in child) {
  if (Object.hasOwn(child, key)) { // modern API
    console.log(key); // "own" only
  }
}

// Object.keys - only own enumerable properties (never inherited)
console.log(Object.keys(child));          // ["own"]
console.log(Object.getOwnPropertyNames(child)); // ["own"] including non-enumerable

// hasOwnProperty can be shadowed - use Object.hasOwn instead
const risky = Object.create(null);
risky.hasOwnProperty = () => true; // would break old pattern
// risky.hasOwnProperty('foo') - always true! Bug.

// Modern safe check:
console.log(Object.hasOwn(risky, 'foo')); // false - correct

// VULNERABLE: naive deep merge with user input
function merge(target, source) {
  for (const key of Object.keys(source)) {
    if (typeof source[key] === 'object') {
      merge(target[key] ??= {}, source[key]);
    } else {
      target[key] = source[key];
    }
  }
}

// Attacker sends: {"__proto__": {"isAdmin": true}}
const malicious = JSON.parse('{"__proto__": {"isAdmin": true}}');
merge({}, malicious);

// Now EVERY object has isAdmin = true!
const innocent = {};
console.log(innocent.isAdmin); // true - prototype was polluted!

// SAFE: Check for __proto__ and prototype keys
function safeMerge(target, source) {
  for (const key of Object.keys(source)) {
    if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
      continue; // skip dangerous keys
    }
    if (typeof source[key] === 'object' && source[key] !== null) {
      safeMerge(target[key] ??= Object.create(null), source[key]);
    } else {
      target[key] = source[key];
    }
  }
}

// Behaviors as mixins (objects or functions)
const canSwim = {
  swim() { return `${this.name} is swimming`; }
};
const canFly = {
  fly() { return `${this.name} is flying`; }
};
const canWalk = {
  walk() { return `${this.name} is walking`; }
};

// Compose: duck can do all three
function createDuck(name) {
  return Object.assign(
    { name },
    canSwim,
    canFly,
    canWalk
  );
}

// Compose: fish can only swim
function createFish(name) {
  return Object.assign({ name }, canSwim);
}

const duck = createDuck('Donald');
console.log(duck.swim()); // "Donald is swimming"
console.log(duck.fly());  // "Donald is flying"

// No inheritance hierarchy - just composed capabilities
// Adding new behavior: just create a new mixin and mix it in