Zawężanie za pomocą instanceof i in

Wprowadzenie

Zawężanie za pomocą instanceof

function handle(err: Error | string) {
  if (err instanceof Error) {
    console.log(err.message); // err: Error
  } else {
    console.log(err); // err: string
  }
}

instanceof z własnymi klasami

class Dog { bark() { return 'Woof'; } }
class Cat { meow() { return 'Meow'; } }
function speak(pet: Dog | Cat) {
  if (pet instanceof Dog) pet.bark();
  else pet.meow();
}

instanceof nie działa z interfejsami

Operator in

type Fish = { swim(): void };
type Bird = { fly(): void };
function move(animal: Fish | Bird) {
  if ('swim' in animal) animal.swim();
  else animal.fly();
}

Zawężanie za pomocą in z opcjonalnymi właściwościami

type A = { x?: number };
type B = { y: number };
function process(v: A | B) {
  if ('x' in v) {
    // v: A (has optional x)
  }
}

Łączenie instanceof i in

function describe(v: Error | { message: string }) {
  if (v instanceof Error) console.log('Error:', v.stack);
  else if ('message' in v) console.log('Object:', v.message);
}

in w uniach dyskryminowanych

type Square = { side: number };
type Circle = { radius: number };
function area(s: Square | Circle): number {
  return 'side' in s ? s.side ** 2 : Math.PI * s.radius ** 2;
}

instanceof w blokach catch

try {
  await fetchData();
} catch (err) {
  if (err instanceof NetworkError) { /* retry */ }
  else if (err instanceof AuthError) { /* redirect */ }
  else throw err;
}

Sprawdzanie Object.prototype a in

Priorytet zawężania

Szybkie sprawdzenie

Podsumowanie