Constructors, and Objects That Can't Be Broken

Chapter 15’s Deck ended with a flaw pointed straight at:

const empty = new Deck();
console.log(empty.size(), empty.deal());

0 undefined

A deck with no cards in it. Perfectly legal, completely useless, and the only thing preventing it was you remembering to call fill().

Removing that “remembering” is what this chapter is about.

A constructor

class Temperature {
  #celsius: number;

  constructor(celsius: number) {
    this.#celsius = celsius;
  }

  inFahrenheit(): number {
    return this.#celsius * 9 / 5 + 32;
  }
}

const t = new Temperature(100);
console.log(t.inFahrenheit());

212

constructor is a method with a fixed name that runs when the object is built. new Temperature(100) calls it with 100, and by the time new hands you the object, #celsius is already set.

That’s the whole idea: there is no moment at which a half-built object exists. You cannot get a Temperature that hasn’t got a temperature, because the only way to make one goes through the constructor.

And the compiler now enforces what’s needed:

const t = new Temperature();

error TS2554: Expected 1 arguments, but got 0.

Chapter 15’s Deck couldn’t do that. new Deck() was fine, and the problem only showed up later, somewhere else, as an undefined.

The shorthand

Assigning every parameter to a field of the same name gets repetitive fast:

class Point {
  #x: number;
  #y: number;

  constructor(x: number, y: number) {
    this.#x = x;
    this.#y = y;
  }
}

Each name appears three times. TypeScript has a shorthand for exactly this, and you’ll see it constantly:

class Point {
  constructor(private x: number, private y: number) {}

  describe(): string {
    return `(${this.x}, ${this.y})`;
  }
}

console.log(new Point(3, 4).describe());

(3, 4)

Put private (or readonly, or public) on a constructor parameter and TypeScript declares the field and assigns it for you. The constructor body is genuinely empty because there’s nothing left to write.

These are parameter properties, and they’re not magic. Look at the compiled output:

class Point {
    x;
    y;
    constructor(x, y) {
        this.x = x;
        this.y = y;
    }
    describe() { return `(${this.x}, ${this.y})`; }
}

Exactly the long version, written out for you.

readonly

Some things shouldn’t change after the object is built. A book’s title, a point’s coordinates, an order’s ID.

class Book {
  constructor(readonly title: string, private pages: number) {}
}

const b = new Book("Dune", 412);
console.log(b.title);
b.title = "Other";

error TS2540: Cannot assign to 'title' because it is a read-only property.

readonly is const for fields. It can be set in the constructor and never again, so a Book can be read by anyone and changed by nobody, which is often exactly the right shape.

Note that title here is readable from outside while pages is not. Public and immutable is a perfectly good combination, and usually a better default than private-with-a-getter.

Invariants

Here’s the idea the whole chapter is built around.

An invariant is something that is true about an object for its entire life. Not “usually true”, not “true if the caller is careful”. Always true, from the moment it’s made until it’s thrown away.

A thermostat’s target is between 5 and 30 degrees. A deck has 52 cards or fewer. A page count is never negative.

Naming it in a sentence is most of the work. Once you can say it, there are exactly two places to defend it: the constructor, and every method that changes anything.

function clampTarget(n: number): number {
  if (n < 5) return 5;
  if (n > 30) return 30;
  return n;
}

class Thermostat {
  #target: number;

  constructor(target: number) {
    this.#target = clampTarget(target);
  }

  setTarget(n: number): void {
    this.#target = clampTarget(n);
  }

  getTarget(): number {
    return this.#target;
  }
}

const t = new Thermostat(100);
console.log(t.getTarget());

t.setTarget(-40);
console.log(t.getTarget());

t.setTarget(21);
console.log(t.getTarget());

30
5
21

Ask for 100 and you get 30. Ask for -40 and you get 5. There is no way to put this object in a state that breaks the rule, because both doors are guarded and there are only two doors.

That is what # bought you. A public target field would mean the invariant is a comment, and t.target = 500 would sail past every check you wrote.

const d = new Deck();
console.log(d.size());

52