Encapsulation

A customer’s wallet balance showed minus 4,000 rupees. The withdraw function could not have done that, it checks the balance first. It took a day to find a refund script in another folder that did wallet.balance -= amount directly and never went near the check.

Nobody wrote a bug in withdraw. The bug was that withdraw was optional.

The idea

Encapsulation is two things done together: the data and the code that guards it live in one class, and the data is closed to everyone else. The rule that a balance never goes negative is called an invariant. Encapsulation is how you make an invariant impossible to skip, instead of something everyone has to remember.

The leak

class Wallet {
  balance = 0
}
 
const wallet = new Wallet()
wallet.balance = 500
wallet.balance -= 4500
 
console.log(wallet.balance) // -4000

Every field in a TypeScript class is public unless you say otherwise. So this Wallet is a variable with a class around it. Any file that can see the object can set any number.

Closing it

class Wallet {
  private balance = 0
 
  deposit(amount: number): void {
    if (amount <= 0) throw new Error('Deposit must be positive')
    this.balance += amount
  }
 
  withdraw(amount: number): void {
    if (amount > this.balance) throw new Error('Insufficient balance')
    this.balance -= amount
  }
 
  getBalance(): number {
    return this.balance
  }
}
 
const wallet = new Wallet()
wallet.deposit(500)
wallet.withdraw(200)
console.log(wallet.getBalance()) // 300
 
wallet.balance = 9999
// Error: Property 'balance' is private and only accessible within
//   class 'Wallet'.

One word, private, and the refund script from the top of this page no longer compiles. Its author is sent to withdraw, which is where the check lives.

try {
  wallet.withdraw(4500)
} catch (error) {
  if (error instanceof Error) console.log(error.message)
  // > Insufficient balance
}
 
console.log(wallet.getBalance()) // 300

The bad request was refused and the balance did not move. In catch, TypeScript treats error as unknown, because JavaScript lets you throw anything. The instanceof check narrows it to an Error so that .message is allowed.

Read only, and the constructor shortcut

Some data should be readable by anyone and writable by nobody. TypeScript has three tools for that, and the next snippet uses all of them.

class Wallet {
  private balance = 0
 
  constructor(readonly owner: string) {}
 
  get available(): number {
    return this.balance
  }
 
  deposit(amount: number): void {
    if (amount <= 0) throw new Error('Deposit must be positive')
    this.balance += amount
  }
}
 
const wallet = new Wallet('Asha')
wallet.deposit(500)
 
console.log(wallet.owner) // Asha
console.log(wallet.available) // 500
 
wallet.owner = 'Ravi'
// Error: Cannot assign to 'owner' because it is a read-only property.
wallet.available = 0
// Error: Cannot assign to 'available' because it is a read-only property.

constructor(readonly owner: string) {} is a parameter property. Putting readonly, private or public in front of a constructor parameter declares the field and assigns it in one go. It replaces three lines, and you will see it on every page from here on.

get available() is a getter with no matching setter, so from outside it behaves like a read only property.

private is a promise, # is a lock

This one catches people. private is checked by the compiler and then erased, like every other type. At runtime the field is an ordinary property.

class Wallet {
  private balance = 500
  #pin = '4321'
 
  checkPin(pin: string): boolean {
    return pin === this.#pin
  }
}
 
const wallet = new Wallet()
const sneaky = wallet as any
sneaky.balance = -4000
 
console.log(sneaky.balance) // -4000
console.log(Object.keys(wallet)) // [ 'balance' ]
console.log(wallet.checkPin('4321')) // true

as any switches the checker off for that value, and private goes with it. The #pin field is different. The # is JavaScript’s own private syntax, enforced by the engine, and it does not even show up in Object.keys.

My rule: private for application code, because it reads well and works with parameter properties. # when something really must not be reachable, like a secret, or when you are writing a library for strangers.

Two ways to get it wrong

class Cart {
  private items: string[] = []
 
  add(item: string): void {
    this.items.push(item)
  }
 
  getItems(): readonly string[] {
    return this.items
  }
}
 
const cart = new Cart()
cart.add('Masala dosa')
 
cart.getItems().push('Free biryani')
// Error: Property 'push' does not exist on type 'readonly string[]'.
console.log(cart.getItems().length) // 1

Checkpoint