"this", Prototypes & the Object Model

// "this" is decided by HOW a function is called, not where it is defined.
const user = {
  name: 'Ada',
  greet() { return `Hi, ${this.name}` },
}

console.log(user.greet())        // "Hi, Ada"  — called as a method

const fn = user.greet
console.log(fn())                // "Hi, undefined" — lost its receiver

// Fix 1: bind
const bound = user.greet.bind(user)
console.log(bound())             // "Hi, Ada"

// Fix 2: call / apply set "this" for one invocation
console.log(user.greet.call({ name: 'Grace' }))   // "Hi, Grace"

// Fix 3: arrow functions have NO own "this" — they inherit it lexically
class Timer {
  constructor() { this.ticks = 0 }
  start() {
    setInterval(() => { this.ticks++ }, 1000)   // arrow keeps "this" = the Timer
  }
  startBroken() {
    setInterval(function () { this.ticks++ }, 1000)  // "this" is not the Timer
  }
}
 

// Every object has a hidden link to a prototype. Lookup walks the chain.
const animal = {
  speak() { return `${this.name} makes a sound` },
}

const dog = Object.create(animal)   // dog's prototype is animal
dog.name = 'Rex'

console.log(dog.speak())                          // "Rex makes a sound"
console.log(Object.getPrototypeOf(dog) === animal) // true
console.log(dog.hasOwnProperty('speak'))           // false — it is inherited

// class is exactly this, with nicer syntax
class Animal {
  constructor(name) { this.name = name }
  speak() { return `${this.name} makes a sound` }
}
class Dog extends Animal {
  speak() { return `${super.speak()} (a bark)` }
}

const rex = new Dog('Rex')
console.log(rex.speak())
console.log(Object.getPrototypeOf(Dog.prototype) === Animal.prototype)  // true
// Methods live on the PROTOTYPE, shared by every instance — not copied per object.
 

// Private fields (#) are real privacy, enforced by the engine
class BankAccount {
  #balance = 0                      // not accessible from outside, at all

  constructor(owner) { this.owner = owner }

  deposit(amount) {
    if (amount <= 0) throw new RangeError('amount must be positive')
    this.#balance += amount
    return this
  }

  get balance() { return this.#balance }      // getter — read like a property

  static from(owner, initial) {               // static factory
    return new BankAccount(owner).deposit(initial)
  }
}

const acct = BankAccount.from('Ada', 100)
console.log(acct.balance)     // 100
// acct.#balance            -> SyntaxError, cannot even be referenced

// Freezing and copying
const config = Object.freeze({ retries: 3 })
// config.retries = 5      -> silently ignored (throws in strict mode)

const clone = structuredClone({ a: { b: [1, 2] } })   // real deep copy