Comment simplifier votre code TypeScript avec 6 types d'utilitaires essentiels

TypeScript est un sur-ensemble de JavaScript qui vous permet d'ajouter un typage statique à votre base de code. Avec son puissant système de typage, TypeScript offre une meilleure lisibilité du code et la possibilité de détecter les erreurs au moment de la compilation.

L'un des aspects les plus bénéfiques de TypeScript est ses types d'utilitaires intégrés, qui peuvent simplifier vos efforts de codage et vous faire gagner un temps de développement précieux. Jetez un œil à ces types d'utilitaires TypeScript incontournables qui peuvent vous aider à écrire facilement du code de type sécurisé.

TypeScript Le type d'utilitaire partiel vous permet de rendre facultatives toutes les propriétés d'un objet. Il vous permet de créer des objets avec certaines propriétés qui peuvent être manquantes ou indéfinies. Prenez par exemple :

interface Utilisateur { 
 nom: chaîne; 
 âge: nombre; 
 e-mail: chaîne;
}

En utilisant le Type d'utilitaire partiel, vous pouvez créer un nouveau type avec toutes les propriétés de l'interface utilisateur définies comme facultatives :

taper Utilisateur facultatif = Partiel

Maintenant, vous pouvez créer une instance du type OptionalUser avec seulement quelques propriétés définies :

constante utilisateur: Utilisateur facultatif = { nom: "John" };

Vous pouvez rencontrer des situations où vous devez créer un objet avec certaines propriétés facultatives. Cela peut être utile surtout lors de la construction de formulaires qui ont plusieurs champs, car tous ne sont peut-être pas nécessaires et dans de tels cas, une utilité partielle peut être vitale.

Le type d'utilitaire de sélection de TypeScript peut vous aider à générer un nouveau type en sélectionnant uniquement un sous-ensemble de propriétés à partir d'un type existant. Cela s'avère pratique lorsque vous devez limiter un objet plus grand à quelques propriétés requises ou si vous souhaitez appliquer un typage strict aux propriétés dont vous avez besoin.

interface Utilisateur { 
 emplacement: chaîne;
 âge: nombre; 
 e-mail: chaîne;
}
taper PersonnesansEmail = Choisir'emplacement' | 'âge'>;
constante personne: PersonneSansEmail = { 
 emplacement: 'ETATS-UNIS', 
 âge: 30
};

Dans cet exemple, une interface nommée "User" définit trois propriétés: email, age et location.

En utilisant le Choisissez le type d'utilitaire, vous pouvez extraire les propriétés "location" et "age" de manière sélective à partir de l'interface utilisateur, ce qui entraîne la création d'un nouveau type appelé "PersonWithoutEmail".

Vous pouvez ensuite créer une nouvelle instance du type "PersonWithoutEmail" et attribuer des valeurs uniquement aux propriétés "location" et "age". La propriété "email" ayant été omise de ce type, vous ne pouvez pas l'affecter à l'objet.

Avec le type d'utilitaire Pick, vous pouvez créer un nouveau type qui intègre uniquement les propriétés souhaitées. Cela peut aider à rendre votre code plus lisible et plus facile à utiliser.

Le type readonly signifie que les attributs d'un objet sont immuables après sa création. Ce type garantit la cohérence des données de l'objet à long terme, ce qui se traduit par une gestion du code plus fluide et plus sécurisée.

interface Utilisateur {
 nom en lecture seule: chaîne; 
 âge en lecture seule: nombre; 
 e-mail en lecture seule: chaîne;
}

En utilisant le Type d'utilitaire en lecture seule, vous pouvez créer un nouveau type avec toutes les propriétés de l'interface utilisateur désignées comme étant en lecture seule :

taper ReadonlyUser = Lecture seule

Vous pouvez spécifier des valeurs de propriété lors de la création d'une instance ReadonlyUser :

constante utilisateur: ReadonlyUser = { 
 nom: "John", 
 âge: 30, 
 e-mail: "[email protected]"
};

Lorsque vous marquez les propriétés d'un objet en lecture seule, il devient impossible de modifier les valeurs de ces propriétés :

nom.utilisateur = "Jeanne";
// Erreur: impossible d'attribuer à 'nom' car il s'agit d'une propriété en lecture seule.

Le type Readonly est particulièrement important dans les situations où vous voulez vous assurer qu'un objet particulier ne change pas, mais il est référencé. Par exemple, si vous avez un objet qui contient des paramètres de configuration importants, vous voudrez vous assurer qu'il reste inchangé.

Ce type garantit que toutes les propriétés essentielles d'un objet sont présentes, alors que le type partiel offre plus de flexibilité en vous permettant de spécifier un sous-ensemble de propriétés tout en laissant les autres facultatif. Cela peut s'avérer bénéfique dans des situations où certaines propriétés peuvent ne pas être nécessaires ou sont sujettes à changement.

interface Utilisateur {
 nom: chaîne; 
 emplacement: nombre; 
 adresse: chaîne;
}

En utilisant le Type d'utilitaire requis, il est possible de créer un nouveau type qui combine tous les attributs de l'interface utilisateur tout en exigeant que chacune de ces propriétés soit présente. La création d'une instance RequiredUser n'est possible qu'une fois que toutes ses propriétés ont été correctement définies.

constante utilisateur: Utilisateur requis = { 
 nom: "John Doe", 
 emplacement: "ETATS-UNIS", 
 adresse: "Kansas 9745-0622"
};

L'utilisation du type d'utilitaire Requis garantit que toutes les propriétés requises sont présentes dans un objet.

Le type d'utilitaire Omit vous permet de créer un nouveau type en excluant des propriétés particulières d'un type existant.

interface Personne {
 emplacement: chaîne; 
 âge: nombre;
 e-mail: chaîne;
}
taper PersonnesansEmail = Omettre'e-mail'>;
constante personne: PersonneSansEmail = { emplacement: "ETATS-UNIS"; âge: 30 };

L'interface Personne a trois propriétés: âge, lieu et e-mail. Le type PersonWithoutEmail utilise un type d'utilitaire Omit pour inclure toutes les propriétés d'un objet Person, à l'exception de l'e-mail. Vous pouvez ensuite créer une instance de ce nouveau type, sans spécifier de valeur pour une propriété d'e-mail.

Vous devez garder à l'esprit que le type d'utilitaire Omit partage des similitudes importantes avec le type d'utilitaire Pick, car il vous permet de concevoir un nouveau type en utilisant uniquement les propriétés que vous spécifiez.

Vous pouvez utiliser le type d'utilitaire d'enregistrement pour définir un type d'objet pour lequel les clés et les valeurs ont un type particulier. Sa définition est :

taper Enregistrers'étend clé de n'importe quel, T> = { [P dans K]: T ;} ;

Cela associe le type T à la valeur de chaque clé, tandis que K est une union de clés de n'importe quel type. L'objet résultant a son type de propriété P défini sur T.

Considérez le scénario d'un type d'objet avec des clés de chaîne et des valeurs numériques. Dans ce cas, vous pouvez appliquer le Type d'utilitaire d'enregistrement comme:

taper MonEnregistrement = Enregistrer<chaîne, nombre>;
constante monObjet: MonEnregistrement = { 
"fou": 1, 
"bar": 2, 
"baz": 3,
}

Cet exemple spécifie MyRecord comme type d'objet avec des clés de chaîne et des valeurs numériques. L'objet myObject incarne une exemplification de ce type, avec les clés "foo", "bar" et "baz" affectées à leurs valeurs correspondantes.

Cet article a révélé la puissance des types d'utilitaires TypeScript - ils peuvent être un atout précieux lorsqu'il s'agit de rationaliser votre code et de rendre le développement plus rapide et plus efficace. Ces types d'utilitaires et TypeScript en général peuvent faire des merveilles pour garantir que votre code est toujours sans erreur et adhère à des structures spécifiques.