TL;DR : TypeScript Generics permet aux développeurs d'écrire du code réutilisable qui peut fonctionner avec différents types de données tout en maintenant la sécurité des types. Ils sont essentiels pour créer des applications TypeScript robustes et évolutives.
Pour garantir que le code soit transparent et gérable, Typescript nécessite la gestion sûre et efficace de plusieurs types de données. L'une des fonctionnalités principales de Typescript est les génériques Typescript, qui permettent la création de fonctions, de classes et d'interfaces tout en respectant des limitations de type strictes. Les génériques vous permettent d'écrire moins de code, de faire moins d'erreurs et, surtout, de créer des composants flexibles pour différents types de données.
Cet article explore l'essentiel des génériques dactylographiés, y compris leur utilisation dans les fonctions, les classes et les interfaces, et montre comment ils rendent le code polyvalent et robuste.
Que sont les génériques Typescript ?
Les génériques Typescript peuvent définir du code TypeScript avec des types d'espace réservé, ce qui lui permet d'être flexible, extensible et réutilisable tout en restant sécurisé.
Typescript effectue des contrôles de sécurité des types pendant la compilation en tant qu'espace réservé qui définit un type générique. Lorsque le composant est implémenté, le type réel remplace l'espace réservé. Cette technique facilite la gestion et la réduction de la duplicité car vous n'avez pas besoin d'implémentations distinctes pour chaque type de données.
Sans génériques, vous écririez plusieurs versions d'une fonction ou d'une classe pour gérer différents types de données, ce qui entraînerait une duplication de code. Les génériques permettent une implémentation unique réutilisable sur différents types tout en conservant la vérification de type statique.
Les exemples de code de la section suivante vous aideront à comprendre cette différence.
Quand utiliser les génériques Typescript ?
Les génériques peuvent être utilisés dans différentes parties du texte dactylographié pour aider à gérer les types plus efficacement. Ils jouent un rôle déterminant dans les fonctions, interfaces, classes et autres structures où la flexibilité est essentielle.
1. Types génériques dans les fonctions
Les génériques sont souvent appliqués dans les fonctions pour réduire la redondance. Par exemple, considérons une fonction qui prend une chaîne ou un nombre comme paramètre.
function identity(value: any): any { return value; } const result1 = identity(42); // result1: any const result2 = identity("hello"); // result2: any
Cette fonction fonctionne bien. Mais il utilise n’importe quel type, ce qui signifie que Typescript perd la trace du type spécifique. Par conséquent, la valeur de retour est saisie comme any, et Typescript ne peut plus appliquer la sécurité des types. Si nous devons maintenir la sécurité des types, nous devrons écrire deux fonctions différentes, l’une renvoyant une chaîne tandis que l’autre renvoie un nombre. Cependant, cette approche augmentera la duplication de code.
Nous pouvons améliorer la fonction ci-dessus en utilisant des génériques pour préserver les informations de type.
function identity(value: any): any { return value; } const result1 = identity(42); // result1: any const result2 = identity("hello"); // result2: any
Le T représente le type que la méthode utilise dans ce cas. S'il est présent, Typescript confirmera que le type d'entrée et le type dans le paramètre de retour sont les mêmes.
De plus, nous pouvons définir la fonction sans définir explicitement le type de paramètre.
function identity<t>(value: Type): T { return value; } const result1 = identity<number>(42); // result1: number const result2 = identity<string>("hello"); // result2: string </string></number></t>
Dans Typescript, vous pouvez utiliser plusieurs paramètres de type générique lorsque vous travaillez avec plusieurs types dans une seule fonction ou un seul composant. Par exemple, vous souhaiterez peut-être une fonction qui prend deux types d'entrées différents et les renvoie par paire.
const result3 = identity(100); // result3: number const result4 = identity("world"); // result4: string
Dans ce cas, la fonction renvoie un tuple avec un premier élément de type T et un deuxième élément de type U. Cela permet une gestion sécurisée de deux types distincts par la fonction.
2. Types par défaut dans TypeScript
Dans Typescript, vous pouvez fournir un type par défaut pour un générique, le rendant facultatif. Si aucun type n'est fourni, Typescript utilisera le type par défaut.
function multipleParams<t u>(first: T, second: U): [T, U] { return [first, second]; } const result1 = multipleParams<string number>("hello", 42); // result1: [string, number] const result2 = multipleParams<string number>("hello", "world"); // result2: gives a type error </string></string></t>
Dans cet exemple, le paramètre de type T est par défaut une chaîne. Si le développeur n'indique pas de type spécifique lorsqu'il appelle la fonction, T sera une chaîne par défaut.
3. Interfaces génériques
Les génériques Typescript peuvent également être appliqués aux interfaces. Imaginez que vous souhaitiez définir une interface Box avec une valeur de n'importe quel type.
function createArray<t string>(length: number, value: T): T[] { return Array(length).fill(value); } const stringArray = createArray(3, "hello"); // T defaults to string, so stringArray is a string array const numberArray = createArray<number>(3, 42); // T is explicitly set to a number, so numberArray is a number array </number></t>
C'est plus égal à l'exemple des fonctions génériques ; ce code fonctionnera également sans problème puisque nous n'avons pas défini de type spécifique. Mais comme la valeur est saisie comme any, nous pouvons rencontrer des bugs liés au type.
Pour sécuriser le type, on peut définir ici une interface générique.
interface Box { value: any; } const numberBox: Box = { value: 123 }; // correct const stringBox: Box = { value: "hello" }; // correct
L'interface est générique, et son type de valeur est strictement contraint à la variable Type. La variable Type peut être spécifiée sous forme de nombre ou de chaîne lors de la création d'une instance afin que le Typescript garantisse que les types appropriés sont respectés.
4. Cours génériques
Les classes peuvent également être écrites en utilisant des génériques pour gérer différents types tout en maintenant la sécurité des types. Créons une classe Storage qui peut stocker et récupérer des valeurs de n'importe quel type.
interface Box<type> { value: Type; } const numberBox: Box<number> = { value: 123 }; // number const stringBox: Box<string> = { value: "hello" }; // string const stringBox2: Box<string> = { value: 123 }; // incorrect </string></string></number></type>
Cette classe fonctionne, mais comme les données sont de type any, la méthode getItem renvoie any, supprimant la sécurité de type. Nous pouvons donc réécrire la classe en utilisant des génériques pour améliorer la sécurité des types.
class Storage { private data: any; setItem(item: any): void { this.data = item; } getItem(): any { return this.data; } } const storage = new Storage(); storage.setItem(123); const item = storage.getItem();
Dans ce cas, le type T est utilisé par la classe Storage. Typescript garantit que les données sont correctes lorsque vous définissez leur type lorsque vous créez une instance. La méthode getItem dans cet exemple de code donnera un nombre.
5. Contraintes génériques
Vous pouvez utiliser des contraintes génériques pour restreindre les types qu'un générique peut accepter, en vous assurant qu'ils ont des propriétés spécifiques.
Par exemple, si vous avez une fonction qui doit accéder à la propriété length d'une entrée, vous pouvez utiliser une contrainte pour garantir que seuls les types avec une propriété length sont autorisés . Cela empêche Typescript de générer des erreurs ou de laisser passer des types incompatibles.
function identity(value: any): any { return value; } const result1 = identity(42); // result1: any const result2 = identity("hello"); // result2: any
Ici, la valeur T n'est pas définie avec la propriété length. Pour ignorer le problème, nous pouvons ajouter une contrainte spécifiant que T doit avoir une propriété length. Nous faisons cela en disant T extends { length: number }.
function identity<t>(value: Type): T { return value; } const result1 = identity<number>(42); // result1: number const result2 = identity<string>("hello"); // result2: string </string></number></t>
Maintenant, cette fonction aura la propriété length ; il ne donnera aucune erreur et s'exécutera avec la longueur de l'entrée.
Conclusion
Les génériques Typescript vous permettent d'écrire du code flexible, recyclable et sécurisé. Vous pouvez gérer de nombreux types de données sans répéter le code à l'aide de classes, de méthodes et d'interfaces avec ces génériques. Les contraintes génériques, les nombreux types et les types par défaut sont quelques-uns des principaux cas d'utilisation que nous avons examinés dans cet article et avons montré comment chacun peut améliorer l'évolutivité et la maintenabilité des programmes.
Comprendre les génériques Typescript peut vous aider à écrire un code plus précis, adaptable et plus sûr, rendant vos applications Typescript plus robustes.
Blogs connexes
- Webpack vs Vite : quel bundle est fait pour vous ?
- Créer des micro-frontends avec un seul spa : un guide
- Maîtrisez le JavaScript asynchrone avec RxJS
- API Axios et Fetch ? Choisir le bon client HTTP
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!

Les choix de Python et JavaScript dans les environnements de développement sont importants. 1) L'environnement de développement de Python comprend Pycharm, Jupyternotebook et Anaconda, qui conviennent à la science des données et au prototypage rapide. 2) L'environnement de développement de JavaScript comprend Node.js, VScode et WebPack, qui conviennent au développement frontal et back-end. Le choix des bons outils en fonction des besoins du projet peut améliorer l'efficacité du développement et le taux de réussite du projet.

Oui, le noyau du moteur de JavaScript est écrit en C. 1) Le langage C fournit des performances efficaces et un contrôle sous-jacent, qui convient au développement du moteur JavaScript. 2) Prendre le moteur V8 comme exemple, son noyau est écrit en C, combinant l'efficacité et les caractéristiques orientées objet de C. 3) Le principe de travail du moteur JavaScript comprend l'analyse, la compilation et l'exécution, et le langage C joue un rôle clé dans ces processus.

JavaScript est au cœur des sites Web modernes car il améliore l'interactivité et la dynamicité des pages Web. 1) Il permet de modifier le contenu sans rafraîchir la page, 2) manipuler les pages Web via Domapi, 3) prendre en charge les effets interactifs complexes tels que l'animation et le glisser-déposer, 4) Optimiser les performances et les meilleures pratiques pour améliorer l'expérience utilisateur.

C et JavaScript réalisent l'interopérabilité via WebAssembly. 1) Le code C est compilé dans le module WebAssembly et introduit dans un environnement JavaScript pour améliorer la puissance de calcul. 2) Dans le développement de jeux, C gère les moteurs de physique et le rendu graphique, et JavaScript est responsable de la logique du jeu et de l'interface utilisateur.

JavaScript est largement utilisé dans les sites Web, les applications mobiles, les applications de bureau et la programmation côté serveur. 1) Dans le développement de sites Web, JavaScript exploite DOM avec HTML et CSS pour réaliser des effets dynamiques et prend en charge des cadres tels que JQuery et React. 2) Grâce à la réactnative et ionique, JavaScript est utilisé pour développer des applications mobiles multiplateformes. 3) Le cadre électronique permet à JavaScript de créer des applications de bureau. 4) Node.js permet à JavaScript d'exécuter le côté du serveur et prend en charge les demandes simultanées élevées.

Python est plus adapté à la science et à l'automatisation des données, tandis que JavaScript est plus adapté au développement frontal et complet. 1. Python fonctionne bien dans la science des données et l'apprentissage automatique, en utilisant des bibliothèques telles que Numpy et Pandas pour le traitement et la modélisation des données. 2. Python est concis et efficace dans l'automatisation et les scripts. 3. JavaScript est indispensable dans le développement frontal et est utilisé pour créer des pages Web dynamiques et des applications à une seule page. 4. JavaScript joue un rôle dans le développement back-end via Node.js et prend en charge le développement complet de la pile.

C et C jouent un rôle essentiel dans le moteur JavaScript, principalement utilisé pour implémenter des interprètes et des compilateurs JIT. 1) C est utilisé pour analyser le code source JavaScript et générer une arborescence de syntaxe abstraite. 2) C est responsable de la génération et de l'exécution de bytecode. 3) C met en œuvre le compilateur JIT, optimise et compile le code de point chaud à l'exécution et améliore considérablement l'efficacité d'exécution de JavaScript.

L'application de JavaScript dans le monde réel comprend un développement frontal et back-end. 1) Afficher les applications frontales en créant une application de liste TODO, impliquant les opérations DOM et le traitement des événements. 2) Construisez RestulAPI via Node.js et Express pour démontrer les applications back-end.


Outils d'IA chauds

Undresser.AI Undress
Application basée sur l'IA pour créer des photos de nu réalistes

AI Clothes Remover
Outil d'IA en ligne pour supprimer les vêtements des photos.

Undress AI Tool
Images de déshabillage gratuites

Clothoff.io
Dissolvant de vêtements AI

Video Face Swap
Échangez les visages dans n'importe quelle vidéo sans effort grâce à notre outil d'échange de visage AI entièrement gratuit !

Article chaud

Outils chauds

Navigateur d'examen sécurisé
Safe Exam Browser est un environnement de navigation sécurisé permettant de passer des examens en ligne en toute sécurité. Ce logiciel transforme n'importe quel ordinateur en poste de travail sécurisé. Il contrôle l'accès à n'importe quel utilitaire et empêche les étudiants d'utiliser des ressources non autorisées.

SublimeText3 version Mac
Logiciel d'édition de code au niveau de Dieu (SublimeText3)

DVWA
Damn Vulnerable Web App (DVWA) est une application Web PHP/MySQL très vulnérable. Ses principaux objectifs sont d'aider les professionnels de la sécurité à tester leurs compétences et leurs outils dans un environnement juridique, d'aider les développeurs Web à mieux comprendre le processus de sécurisation des applications Web et d'aider les enseignants/étudiants à enseigner/apprendre dans un environnement de classe. Application Web sécurité. L'objectif de DVWA est de mettre en pratique certaines des vulnérabilités Web les plus courantes via une interface simple et directe, avec différents degrés de difficulté. Veuillez noter que ce logiciel

Version crackée d'EditPlus en chinois
Petite taille, coloration syntaxique, ne prend pas en charge la fonction d'invite de code

VSCode Windows 64 bits Télécharger
Un éditeur IDE gratuit et puissant lancé par Microsoft
