Wprowadzenie do zaawansowanego zawężania typów

Zaawansowane zawężanie typów umożliwia doprecyzowywanie złożonych typów w czasie wykonywania za pomocą zaawansowanych technik, takich jak strażniki typów, analiza przepływu sterowania i niestandardowe predykaty.

Narzędzia te sprawiają, że kod TypeScript jest bezpieczniejszy i bardziej przewidywalny.

Czym jest zawężanie typów?

Zawężanie typów to proces przekształcania szerszego typu (np. string | number) w bardziej szczegółowy typ za pomocą sprawdzeń wykonywanych w czasie działania programu.

Używanie typeof do zawężania typów

Operator typeof może służyć do zawężania typów prymitywnych:

function printValue(value: string | number): void {
  if (typeof value === 'string') {
    console.log(`String: ${value}`);
  } else {
    console.log(`Number: ${value}`);
  }
}

printValue('Hello'); // String: Hello
printValue(42); // Number: 42

Używanie instanceof do zawężania typów

Operator instanceof może służyć do zawężania typów instancji klas:

class Dog {
  bark() {
    console.log('Woof!');
  }
}

class Cat {
  meow() {
    console.log('Meow!');
  }
}

function makeSound(animal: Dog | Cat): void {
  if (animal instanceof Dog) {
    animal.bark();
  } else {
    animal.meow();
  }
}

makeSound(new Dog()); // Woof!
makeSound(new Cat()); // Meow!

Używanie własnych strażników typów

Można tworzyć własne funkcje strażników typów, aby precyzyjniej zawężać typy:

type Fish = { swim: () => void };
type Bird = { fly: () => void };

declare const animal: Fish | Bird;

function isFish(animal: Fish | Bird): animal is Fish {
  return (animal as Fish).swim !== undefined;
}

if (isFish(animal)) {
  animal.swim();
} else {
  animal.fly();

Analiza przepływu sterowania

Analiza przepływu sterowania w TypeScript automatycznie zawęża typy na podstawie logicznego przebiegu kodu:

function getLength(value: string | string[]): number {
  if (Array.isArray(value)) {
    return value.length;
  } else {
    return value.length;
  }
}

console.log(getLength('Hello')); // 5
console.log(getLength(['a', 'b', 'c'])); // 3

Zalety zaawansowanego zawężania typów

Zaawansowane zawężanie typów usprawnia kod poprzez:

• Ograniczenie liczby błędów w czasie działania programu.
• Zwiększenie bezpieczeństwa i czytelności kodu.
• Zapewnienie precyzyjnej kontroli nad obsługą typów.

Zadanie praktyczne

Proszę utworzyć funkcję, która przyjmuje parametr typu string | number i loguje inny komunikat dla każdego typu. Proszę użyć typeof do zaimplementowania tej logiki.

Gratulacje!

Nauczyli się Państwo używać zaawansowanych technik zawężania typów w TypeScript do bezpiecznego i skutecznego doprecyzowywania złożonych typów oraz obsługiwania ich. Proszę ćwiczyć te techniki, aby tworzyć bardziej niezawodny kod z bezpiecznym typowaniem!