Pourquoi les protections de type sont-elles nécessaires ? Explorer différents types et leurs cas d'utilisation

Pourquoi les gardes de type sont-ils nécessaires ? Explorer différents types et leurs cas d'utilisation

Dans TypeScript, les gardes de type jouent un rôle essentiel pour rendre la base de code plus fiable et plus conviviale pour les développeurs. Ils contribuent à garantir la sécurité des types en permettant aux développeurs d'affiner les types, ce qui contribue à réduire les erreurs d'exécution et rend le code plus facile à comprendre et à maintenir.

Que sont les gardes de type ?

Les gardes de type sont des expressions de fonctions qui effectuent des vérifications d'exécution sur les types, garantissant que les valeurs répondent à des critères spécifiques avant d'être traitées davantage. Ils aident à maintenir la sécurité des types, permettant aux développeurs de gérer les valeurs de manière appropriée.

Pourquoi les gardes de type sont-ils nécessaires ?

En JavaScript, vous rencontrez souvent des valeurs qui peuvent avoir plusieurs types, comme une fonction qui renvoie une chaîne ou un nombre. Sans protections de type, TypeScript ne serait pas en mesure de déterminer le type exact, ce qui entraînerait des erreurs d'exécution potentielles et un comportement incorrect. Les gardes de type vous permettent de vérifier le type d'une valeur au moment de l'exécution, aidant ainsi TypeScript à affiner les types et à fournir une vérification de type plus précise.

Types courants de gardes de type et leurs cas d'utilisation

1. type de gardes de type

Cas d'utilisation : Vérification de type de base pour les types primitifs.
Exemple :

function printValue(value: string | number) {
  if (typeof value === "string") {
    console.log(`String value: ${value.toUpperCase()}`);
  } else {
    console.log(`Number value: ${value.toFixed(2)}`);
  }
}

Explication : typeof est efficace avec les types primitifs (string, number, boolean). Cela permet à la fonction de gérer différemment les types de chaîne et de nombre.

2. Protections de type personnalisées (est un mot-clé)

Cas d'utilisation : Pour une logique complexe, vérification de formes ou d'interfaces personnalisées.

Exemple :

 interface Square {
    side: number;
  }
  interface Circle {
    radius: number;
  }

  function isSquare(shape: Square | Circle): shape is Square {
    return (shape as Square).side !== undefined;
  }

  function calculateArea(shape: Square | Circle) {
    if (isSquare(shape)) {
      return shape.side * shape.side;
    } else {
      return Math.PI * shape.radius * shape.radius;
    }
  }

Explication : Les protections de type personnalisées vous permettent de définir des fonctions qui vérifient des attributs spécifiques pour déterminer le type. Ici, isSquare vérifie la présence de la propriété side.

3. dans les protections de type opérateur

Cas d'utilisation : Vérifier si un objet possède une propriété spécifique.
Exemple :

 interface Car {
    drive(): void;
  }
  interface Boat {
    sail(): void;
  }

  function move(vehicle: Car | Boat) {
    if ("drive" in vehicle) {
      vehicle.drive();
    } else {
      vehicle.sail();
    }
  }

Explication : L'opérateur in vérifie l'existence d'une propriété, aidant TypeScript à comprendre le type et permettant l'accès aux méthodes pertinentes.

Conclusion

Les protections de type sont une fonctionnalité puissante de TypeScript qui permet une vérification de type précise, réduit les erreurs et améliore la lisibilité et la maintenabilité du code. En tirant parti de typeof, instanceof, des protections de type personnalisées et de l'opérateur in, vous pouvez gérer des types complexes en toute sécurité et efficacement dans les projets TypeScript.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!