Objects, Prototypes & Classes

// An object can hold behaviour, and methods reach the object through `this`
const account = {
  owner: "Ada",
  balance: 100,
  deposit(amount) {
    if (amount <= 0) throw new RangeError("deposit must be positive")
    this.balance += amount
    return this                          // return this to allow chaining
  },
  withdraw(amount) {
    if (amount > this.balance) throw new RangeError("insufficient funds")
    this.balance -= amount
    return this
  },
  toString() { return `${this.owner}: ${this.balance}` },
}
account.deposit(50).withdraw(30)
console.log(String(account), `${account}`)      // toString is used by string conversion

// A factory function makes many such objects
function makeAccount(owner, balance = 0) {
  return {
    owner, balance,
    deposit(a) { this.balance += a; return this },
  }
}
const a = makeAccount("Bob"), b = makeAccount("Cy", 10)
a.deposit(5)
console.log(a.balance, b.balance, a.deposit === b.deposit)   // each object gets its OWN copy of the method

const animal = {
  legs: 4,
  describe() { return `${this.name} has ${this.legs} legs` },
}
const dog = Object.create(animal)      // dog's prototype is animal
dog.name = "Rex"
console.log(dog.describe())            // describe is found on animal; this is still dog
console.log(Object.hasOwn(dog, "name"), Object.hasOwn(dog, "legs"), "legs" in dog)
console.log(Object.getPrototypeOf(dog) === animal)

// Shadowing: an own property hides the inherited one
dog.legs = 3
console.log(dog.legs, animal.legs)

// The chain for a plain array
const arr = [1, 2]
console.log(Object.getPrototypeOf(arr) === Array.prototype, Object.getPrototypeOf(Array.prototype) === Object.prototype, Object.getPrototypeOf(Object.prototype))
console.log(Object.hasOwn(arr, "push"), typeof arr.push)

// Constructor functions: how it was done before class (still what class does underneath)
function Account(owner) {
  this.owner = owner
  this.balance = 0
}
Account.prototype.deposit = function (a) { this.balance += a; return this }
const x = new Account("Ada"), y = new Account("Bob")
x.deposit(10)
console.log(x.balance, y.balance, x.deposit === y.deposit, x instanceof Account, x.constructor === Account)

class Account {
  // public fields (own properties, per instance)
  transactions = []

  constructor(owner, balance = 0) {
    this.owner = owner
    this.balance = balance
  }

  // methods live on Account.prototype — one copy, shared
  deposit(amount) {
    if (amount <= 0) throw new RangeError("deposit must be positive")
    this.balance += amount
    this.transactions.push(["deposit", amount])
    return this
  }

  toString() { return `${this.owner}: ${this.balance}` }
}

const a = new Account("Ada", 100)
a.deposit(50).deposit(25)
console.log(String(a), a.transactions.length)
console.log(a instanceof Account, Object.hasOwn(a, "deposit"), typeof Account.prototype.deposit)
console.log(typeof Account, Account.name)          // a class IS a function

try { a.deposit(-5) } catch (e) { console.log(e.name, e.message) }

// Each instance has its own fields; methods are shared
const b = new Account("Bob")
console.log(a.transactions === b.transactions, a.deposit === b.deposit)

class Shape {
  constructor(name) { this.name = name }
  area() { return 0 }
  describe() { return `${this.name} with area ${this.area().toFixed(2)}` }
}

class Circle extends Shape {
  constructor(r) {
    super("circle")         // must run before touching this
    this.r = r
  }
  area() { return Math.PI * this.r ** 2 }      // override
}

class Square extends Shape {
  constructor(side) { super("square"); this.side = side }
  area() { return this.side ** 2 }
  describe() { return super.describe() + " (four equal sides)" }   // extend, not replace
}

const shapes = [new Circle(1), new Square(2), new Shape("blob")]
for (const s of shapes) console.log(s.describe())      // polymorphism: same call, each class answers

const c = shapes[0]
console.log(c instanceof Circle, c instanceof Shape, c instanceof Object)
console.log(Object.getPrototypeOf(Circle.prototype) === Shape.prototype)

// Extending built-ins works too
class Stack extends Array {
  peek() { return this.at(-1) }
}
const st = new Stack()
st.push(1, 2, 3)
console.log(st.peek(), st.length, st instanceof Array)

// A derived class without a constructor gets one that forwards arguments
class Named extends Shape {}
console.log(new Named("auto").name)

class Temperature {
  #celsius = 0                       // private: only code inside this class can touch it
  static #count = 0                  // private static
  static ABSOLUTE_ZERO = -273.15     // public static constant

  constructor(c) { this.celsius = c; Temperature.#count++ }

  get celsius() { return this.#celsius }
  set celsius(v) {
    if (v < Temperature.ABSOLUTE_ZERO) throw new RangeError("below absolute zero")
    this.#celsius = v
  }
  get fahrenheit() { return this.#celsius * 9 / 5 + 32 }     // computed, no storage
  set fahrenheit(f) { this.celsius = (f - 32) * 5 / 9 }

  static fromFahrenheit(f) { const t = new Temperature(0); t.fahrenheit = f; return t }
  static get created() { return Temperature.#count }

  #round(n) { return Math.round(n * 10) / 10 }               // private method
  toString() { return `${this.#round(this.#celsius)}°C` }
}

const t = new Temperature(25)
console.log(t.celsius, t.fahrenheit, String(t))
t.fahrenheit = 212
console.log(t.celsius)
try { t.celsius = -300 } catch (e) { console.log(e.message) }

console.log(String(Temperature.fromFahrenheit(32)), Temperature.created, Temperature.ABSOLUTE_ZERO)
console.log(t.celsius === t["celsius"], "#celsius" in t, Object.keys(t))     // private fields are invisible from outside

// Composition: capabilities as small objects
const canFly = { fly() { return `${this.name} flies` } }
const canSwim = { swim() { return `${this.name} swims` } }

class Duck {
  constructor(name) { this.name = name }
}
Object.assign(Duck.prototype, canFly, canSwim)      // mixin: copy behaviours in
const d = new Duck("Donald")
console.log(d.fly(), "|", d.swim())

// Composition with plain objects and functions — no class needed
const withLogging = obj => ({ ...obj, log(msg) { return `[${this.name}] ${msg}` } })
const service = withLogging({ name: "api", call: () => "ok" })
console.log(service.log(service.call()))

// Make your own class iterable: for…of, spread and destructuring all work
class Range {
  constructor(from, to) { this.from = from; this.to = to }
  *[Symbol.iterator]() {                    // a generator method — Module 09
    for (let i = this.from; i <= this.to; i++) yield i
  }
}
const r = new Range(1, 5)
console.log([...r], Math.max(...r))
for (const n of r) if (n % 2) console.log("odd", n)
const [first, second] = r
console.log(first, second)

// Duck typing: if it has the method, it works — no inheritance required
const printAll = things => things.map(t => t.describe())
console.log(printAll([{ describe: () => "plain object" }, new (class { describe() { return "instance" } })()]))