Classes & OOP

class Person {
  // Public instance field — one per instance
  species = "human";

  constructor(name, age) {
    this.name = name;
    this.age = age;
  }

  // Method — goes on Person.prototype, shared by all instances
  greet() {
    return `Hello, my name is ${this.name} and I'm ${this.age}.`;
  }

  // Static — lives on the class itself
  static compare(a, b) {
    return a.age - b.age;
  }
}

const john = new Person("John", 30);
john.greet();
typeof Person;                                 // "function"
Object.getPrototypeOf(john) === Person.prototype; // true
Person(); // TypeError: Class constructor Person cannot be invoked without 'new'

class Person {
  constructor(name) {
    this.name = name;
  }
  greetA() {}               // on Person.prototype — shared
  greetB = function () {};  // class field — a new function on EVERY instance
  greetC = () => this.name; // class field arrow — per instance, `this` locked
}

const a = new Person("a");
const b = new Person("b");
a.greetA === b.greetA;           // true
a.greetB === b.greetB;           // false
Object.hasOwn(a, "greetB");      // true — own property, not inherited

class BankAccount {
  #balance; // must be declared up front

  constructor(owner, balance) {
    this.owner = owner;
    this.#balance = balance;
  }

  getBalance() {
    return `The balance for ${this.owner} is $${this.#balance}`;
  }

  deposit(amount) {
    this.#validate(amount);
    this.#balance += amount;
    return `Deposited $${amount}. New balance is $${this.#balance}`;
  }

  withdraw(amount) {
    this.#validate(amount);
    if (amount > this.#balance) return "Insufficient balance.";
    this.#balance -= amount;
    return `Withdrew $${amount}. Remaining balance is $${this.#balance}`;
  }

  #validate(amount) { // private method
    if (amount <= 0) throw new RangeError("Amount must be positive");
  }

  static isAccount(obj) {
    return #balance in obj; // ergonomic brand check
  }
}

const account = new BankAccount("Alice", 1000);
account.deposit(500);   // Deposited $500. New balance is $1500
account.withdraw(200);  // Withdrew $200. Remaining balance is $1300
account.balance;        // undefined
// account.#balance;    // SyntaxError: Private field '#balance' must be declared in an enclosing class

// Closure-based privacy (works without classes)
function createAccount(initial) {
  let balance = initial;
  return {
    deposit: (n) => (balance += n),
    get balance() {
      return balance;
    },
  };
}

const acc = createAccount(100);
acc.deposit(50); // 150
acc.balance;     // 150
acc.balance = 0; // ignored — there's no setter (a TypeError in strict mode)
acc.balance;     // 150

class Config {
  static #instances = 0;
  static defaults;

  static {
    // runs once, when the class is evaluated
    const env = globalThis.process?.env?.NODE_ENV ?? "development";
    Config.defaults = { env, debug: env !== "production" };
  }

  constructor() {
    Config.#instances++;
  }

  static get count() {
    return Config.#instances;
  }
}

Config.defaults; // { env: "development", debug: true }
new Config();
Config.count;    // 1

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

class Dog extends Animal {
  constructor(name, breed) {
    super(name);        // MUST be called before using `this`
    this.breed = breed;
  }
  speak() {
    return `${super.speak()} — Woof!`; // call the parent version
  }
}

new Dog("Rex", "Lab").speak(); // "Rex makes a sound — Woof!"

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

class Circle extends Shape {
  constructor(r) {
    super();
    this.r = r;
  }
  area() {
    return Math.PI * this.r ** 2;
  }
}

class Square extends Shape {
  constructor(s) {
    super();
    this.s = s;
  }
  area() {
    return this.s ** 2;
  }
}

[new Circle(1), new Square(2)].map((s) => s.describe());
// ["Circle with area 3.14", "Square with area 4.00"]

class Dup {
  f() {
    return "first";
  }
  f() {
    return "second";
  }
}
new Dup().f(); // "second"

class Shape {
  constructor() {
    if (new.target === Shape) {
      throw new TypeError("Shape is abstract — extend it instead");
    }
    if (this.area === Shape.prototype.area) {
      throw new TypeError(`${new.target.name} must implement area()`);
    }
  }
  area() {
    throw new Error("not implemented");
  }
}

class Rect extends Shape {
  constructor(w, h) {
    super();
    this.w = w;
    this.h = h;
  }
  area() {
    return this.w * this.h;
  }
}

new Rect(2, 3).area(); // 6
new Shape();           // TypeError: Shape is abstract — extend it instead
class Bad extends Shape {}
new Bad();             // TypeError: Bad must implement area()

const canSwim = {
  swim() {
    return `${this.name} is swimming`;
  },
};
const canFly = {
  fly() {
    return `${this.name} is flying`;
  },
};

class Duck {
  constructor(name) {
    this.name = name;
  }
}
Object.assign(Duck.prototype, canSwim, canFly);

const d = new Duck("Donald");
d.swim(); // "Donald is swimming"
d.fly();  // "Donald is flying"

// Behaviours as small functions that work on shared state
const canEat = (state) => ({
  eat: (food) => `${state.name} eats ${food}`,
});
const canWalk = (state) => ({
  walk: () => `${state.name} walks`,
});
const canSwim = (state) => ({
  swim: () => `${state.name} swims`,
});

const createDog = (name) => {
  const state = { name };
  return { ...canEat(state), ...canWalk(state), ...canSwim(state) };
};
const createFish = (name) => {
  const state = { name };
  return { ...canEat(state), ...canSwim(state) };
};

createDog("Rex").walk();   // "Rex walks"
createFish("Nemo").swim(); // "Nemo swims"