Objects And Prototypes

class Animal {
  #sound = 'generic'                 // private field: a private symbol key; brand-checked; as fast as a field when warm
  static count = 0                   // on the constructor function object, not on instances
  name                               // public field: defined per instance in constructor order (shape matters: same for all)
  constructor(name) { this.name = name; Animal.count++ }
  speak() { return `${this.name}: ${this.#sound}` }   // on Animal.prototype, non-enumerable, one function object
  get loud() { return this.speak().toUpperCase() }    // accessor on the prototype
}
class Dog extends Animal {
  constructor(name) { super(name) }  // super: the parent constructor is called with the same `this` (derived: `this` exists after super returns)
  speak() { return super.speak() + '!' }   // super.speak: looked up on Dog.prototype's prototype (HomeObject), not on this
}
// desugars (roughly) to: function Animal(name){…}; Animal.prototype.speak = …; Object.defineProperty(Animal.prototype, 'loud', {get});
// Dog.prototype = Object.create(Animal.prototype); Object.setPrototypeOf(Dog, Animal)   // static inheritance via the constructor's chain
// instances of Dog: map with name (and #sound) in-object; prototype chain: Dog.prototype → Animal.prototype → Object.prototype

// the metaobject protocol: every language-level operation is one of these internal methods, each reachable via Reflect
Reflect.get(o, k, receiver)            // o.k           → [[Get]]
Reflect.set(o, k, v, receiver)         // o.k = v       → [[Set]]
Reflect.has(o, k)                      // k in o        → [[HasProperty]]
Reflect.deleteProperty(o, k)           // delete o.k    → [[Delete]]
Reflect.ownKeys(o)                     // Object.keys + symbols + non-enumerables → [[OwnPropertyKeys]]
Reflect.getOwnPropertyDescriptor(o, k) // → [[GetOwnProperty]]
Reflect.defineProperty(o, k, desc)     // → [[DefineOwnProperty]]; returns false instead of throwing
Reflect.getPrototypeOf(o) / setPrototypeOf(o, p)
Reflect.apply(fn, thisArg, args)       // fn.apply, without trusting fn.apply to be the real one
Reflect.construct(Fn, args, newTarget) // new Fn(...args), with new.target control

// a Proxy trap exists for each: get, set, has, deleteProperty, ownKeys, getOwnPropertyDescriptor, defineProperty,
// getPrototypeOf, setPrototypeOf, isExtensible, preventExtensions, apply (callable targets), construct
// the pairing is exact: the default behaviour of every trap is the matching Reflect method