Introduction à l’affinement avancé des types

L’affinement avancé des types vous permet de préciser des types complexes lors de l’exécution à l’aide de techniques avancées telles que les gardes de type, l’analyse du flux de contrôle et les prédicats personnalisés.

Ces outils rendent votre code TypeScript plus sûr et plus prévisible.

Qu’est-ce que l’affinement des types ?

L’affinement des types est le processus qui consiste à transformer un type large (par exemple, string | number) en un type plus précis à l’aide de vérifications effectuées lors de l’exécution.

Utiliser typeof pour affiner les types

L’opérateur typeof peut être utilisé pour affiner les types primitifs :

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

Utiliser instanceof pour affiner les types

L’opérateur instanceof peut être utilisé pour affiner les instances de classes :

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!

Utiliser des gardes de type personnalisées

Vous pouvez créer des fonctions de garde de type personnalisées pour affiner les types avec davantage de précision :

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();

Analyse du flux de contrôle

L’analyse du flux de contrôle de TypeScript affine automatiquement les types en fonction du déroulement logique de votre code :

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

Avantages de l’affinement avancé des types

L’affinement avancé des types améliore votre code en :

• Réduisant les erreurs lors de l’exécution.
• Rendant le code plus sûr et plus facile à comprendre.
• Permettant de contrôler précisément la gestion des types.

Exercice pratique

Créez une fonction qui reçoit un paramètre de type string | number et journalise un message différent pour chaque type. Utilisez typeof pour implémenter la logique.

Félicitations !

Vous avez appris à utiliser des techniques avancées d’affinement des types en TypeScript pour préciser et gérer des types complexes de manière sûre et efficace. Entraînez-vous à appliquer ces techniques pour rendre votre code plus robuste et plus sûr du point de vue des types !