Please enable JavaScript.

Coggle requires JavaScript to display documents.

15.2: Type narrowing contd. - Coggle Diagram

15.2: Type narrowing contd.

instanceof

for objects only

class Car {
  drive() {
    console.log('Driving...');
  }
}

class Truck {
  drive() {
    console.log('Driving a truck...');
  }

  loadCargo(amount: number) {
    console.log('Loading cargo ...' + amount);
  }
}

type Vehicle = Car | Truck;

const v1 = new Car();
const v2 = new Truck();

function useVehicle(vehicle: Vehicle) {
  vehicle.drive();
  if (vehicle instanceof Truck) {
    vehicle.loadCargo(1000);
  }
}

- - - - Cat | Dog
        
        at both 1. and 2. #
      - isCat is just a function that returns a boolean
        
        TypeScript doesn't know how to interpret the result
  - - - return type of function must be
        
        parameterName is Type
      - function must return
        
        true or false
    - - function isCat(animal: Cat | Dog): animal is Cat { return (animal as Cat).numLives !== undefined; }
      - tells TypeScript
        
        ir return value is true
        
        parameter type is Cat
        
        if return value isn't true
        
        parameter type is not Cat
      - the logic of the function
        
        narrows the type
    - - Cat
        
        at 1.
      - Dog
        
        at 2.

discriminated unions

let's say we have two interfaces {would work with classes as well)

interface Bird {
  flyingSpeed: number;
}

interface Horse {
  runningSpeed: number;
}

type Animal = Bird | Horse;

and a function that needs to discriminate between the two

function moveAnimal(animal: Animal) {
  let speed;
  if ('flyingSpeed' in Animal) {
      speed = animal.flyingSpeed;
  }
  ...
  console.log('Moving at speed: ' + speed);
}

can make a discriminated union

interface Bird {
  type: 'bird';
  flyingSpeed: number;
}

interface Horse {
  type: 'horse';
  runningSpeed: number;
}

and can use the type

function moveAnimal(animal: Animal) {
  let speed;
  switch (animal.type) {
    case 'bird':
      speed = animal.flyingSpeed; // 1. what's the type here?
      break;
    case 'horse':
      speed = animal.runningSpeed; // 2. what's the type here?
  }
  console.log('Moving at speed: ' + speed);
}