Encapsulation

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28class Account {
  constructor(owner, balance) {
    this.owner = owner;
    this.balance = balance;
  }

  withdraw(amount) {
    if (amount > this.balance) throw new RangeError('Insufficient funds.');
    this.balance -= amount;
    return this.balance;
  }
}

const acct = new Account('Amaka', 100);

try {
  acct.withdraw(500);
} catch (err) {
  console.log('withdraw refused:', err.message);
}

// ...and then this happens anyway.
acct.balance = -9999;
console.log('balance is now', acct.balance);

// Or worse, a typo silently invents a property and the real one never changes.
acct.balence = 50;
console.log('balance:', acct.balance, '| typo lives on:', acct.balence);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44class Account {
  #balance;

  constructor(owner, opening) {
    this.owner = owner;
    if (opening < 0) throw new RangeError('Opening balance cannot be negative.');
    this.#balance = opening;
  }

  get balance() {
    return this.#balance;
  }

  deposit(amount) {
    this.#assertAmount(amount);
    this.#balance += amount;
    return this;
  }

  withdraw(amount) {
    this.#assertAmount(amount);
    if (amount > this.#balance) {
      throw new RangeError(`Cannot withdraw ${amount}; balance is ${this.#balance}.`);
    }
    this.#balance -= amount;
    return this;
  }

  // Methods can be private too.
  #assertAmount(amount) {
    if (typeof amount !== 'number' || Number.isNaN(amount)) {
      throw new TypeError('Amount must be a number.');
    }
    if (amount <= 0) throw new RangeError('Amount must be positive.');
  }
}

const acct = new Account('Amaka', 100);
acct.deposit(50).withdraw(30);
console.log('balance:', acct.balance);

try { acct.withdraw(500); } catch (err) { console.log('refused:', err.message); }
try { acct.deposit(-5); } catch (err) { console.log('refused:', err.message); }
try { acct.deposit('ten'); } catch (err) { console.log('refused:', err.message); }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15class Account {
  #balance = 100;
  get balance() { return this.#balance; }
}

const acct = new Account();

console.log('own keys:', Object.keys(acct));
console.log('JSON:', JSON.stringify(acct));
console.log('spread:', { ...acct });
console.log('is #balance in there?', 'balance' in acct, Object.hasOwn(acct, '#balance'));

// Reaching for it from outside is a syntax error, not a runtime miss.
// Uncomment the next line and the whole panel refuses to parse.
// console.log(acct.#balance);

1
2
3
4
5
6
7
8
9
10
11class Account {
  constructor(balance) {
    this._balance = balance;    // "please do not touch"
  }
  get balance() { return this._balance; }
}

const acct = new Account(100);
acct._balance = -9999;          // nothing stops this
console.log(acct.balance);
console.log('and it shows up everywhere:', Object.keys(acct), JSON.stringify(acct));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17class Ticket {
  #serial;
  constructor(serial) { this.#serial = serial; }

  static isTicket(value) {
    return #serial in value;      // true only for real Tickets
  }

  get serial() { return this.#serial; }
}

const real = new Ticket('A-1');
const fake = { serial: 'A-1' };

console.log('real:', Ticket.isTicket(real));
console.log('fake:', Ticket.isTicket(fake));
console.log('but the fake passes a naive check:', 'serial' in fake);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29class Seat {
  constructor(row, number) {
    this.row = row;
    this.number = number;
    Object.freeze(this);
  }

  get label() { return `${this.row}${this.number}`; }

  // Changes return a new Seat rather than mutating this one.
  movedTo(row) { return new Seat(row, this.number); }
}

const a = new Seat('D', 12);
console.log(a.label);

// A frozen object refuses writes. Refusing means throwing, because class
// bodies and modules are always strict. In a sloppy-mode script the same
// assignment would have been ignored in silence, which is far worse.
try {
  a.row = 'Z';
} catch (err) {
  console.log(err.name + ':', err.message);
}
console.log('unchanged:', a.label);

const b = a.movedTo('F');
console.log('new seat:', b.label, '| original untouched:', a.label);
console.log('frozen?', Object.isFrozen(a));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40class Trip {
  // Hidden: internal bookkeeping nobody outside should see or set.
  #sold = new Set();
  #capacity;

  // Public and mutable: genuinely fine for anyone to change.
  notes = '';

  constructor(route, capacity) {
    this.route = route;          // public, but only sensible to set once
    this.#capacity = capacity;
  }

  // Read-only: derived, so allowing assignment would be meaningless.
  get sold() { return this.#sold.size; }
  get remaining() { return this.#capacity - this.#sold.size; }
  get soldOut() { return this.remaining === 0; }

  // The only door into #sold, and it enforces every rule.
  book(seat) {
    if (this.soldOut) throw new RangeError(`${this.route} is fully booked.`);
    if (this.#sold.has(seat)) throw new RangeError(`Seat ${seat} is already taken.`);
    this.#sold.add(seat);
    return this;
  }

  toString() { return `${this.route}: ${this.sold}/${this.#capacity} sold`; }
}

const trip = new Trip('Lagos - Abuja', 3);
trip.book('1A').book('1B');
trip.notes = 'morning run, luggage on the roof';

console.log(String(trip));
console.log('remaining:', trip.remaining, '| fully booked:', trip.soldOut);

try { trip.book('1B'); } catch (err) { console.log('refused:', err.message); }

trip.book('2A');
try { trip.book('2B'); } catch (err) { console.log('refused:', err.message); }