TypeScript offre un système de types robuste, mais certains types peuvent prêter à confusion, à savoir n'importe lequel, inconnu et jamais. Décomposons-les pour une meilleure compréhension.

Le tout type

Le type any est le plus simple des trois. Il désactive essentiellement la vérification de type, permettant à une variable de contenir n'importe quel type de valeur. Par exemple:

let value: any;
value = 42;             // number
value = "Hello";        // string
value = [1, 2, 3];      // array
value = () => {};       // function
value = { key: "val" }; // object
value = new Date();     // date

Dans tous ces cas, TypeScript ne génère aucune erreur, nous permettant d'effectuer n'importe quelle opération sur la variable sans contraintes de type. Cela peut être utile lors de la migration d'un projet JavaScript vers TypeScript. Cependant, s'appuyer sur n'importe quel type annule les avantages de la sécurité des types, ce qui en fait un mauvais choix dans la plupart des cas. Pensez plutôt à utiliser inconnu.

Le type inconnu

Le type inconnu est plus sûr que n'importe quel autre car il nécessite des vérifications de type avant d'effectuer des opérations. Il représente l'ensemble de toutes les valeurs possibles, mais avec la sécurité des types appliquée.

let value: unknown;
value = 42;
value = "Hello";

// To perform operations, we need to narrow down the type
if (typeof value === "number") {
  console.log(value   1); // TypeScript knows value is a number here
}

L'utilisation d'inconnu est bénéfique pour les fonctions qui acceptent tout type d'entrée, comme les fonctions de journalisation, car elle applique des vérifications de type avant de poursuivre les opérations.

Le type jamais

Le type never représente l'ensemble vide de valeurs, indiquant que quelque chose ne devrait jamais se produire. Aucune valeur ne peut être attribuée à un type never, ce qui le rend utile pour des vérifications exhaustives et représente un code inaccessible.

type User = { type: "admin" } | { type: "standard" };

function handleUser(user: User) {
  switch (user.type) {
    case "admin":
      // handle admin
      break;
    case "standard":
      // handle standard
      break;
    default:
      const _exhaustiveCheck: never = user;
      // This ensures all cases are handled
  }
}

Si un nouveau type d'utilisateur est ajouté, TypeScript générera une erreur, garantissant que tous les cas sont traités, ce qui ne sera jamais inestimable pour maintenir des vérifications exhaustives dans votre code.

Conclusion

Comprendre tout ce qui est inconnu et n'améliore jamais la sécurité des types de TypeScript. Utilisez-les avec parcimonie, en préférant l'inconnu pour des vérifications de type plus sûres, et n'utilisez jamais pour des vérifications exhaustives et un code inaccessible. Ces types, lorsqu'ils sont utilisés correctement, font de TypeScript un outil puissant pour créer des applications fiables.
Bon codage !