Génériques TypeScript
Les génériques sont une fonctionnalité du langage de programmation qui permet d'utiliser des espaces réservés pour représenter des types au lieu de types concrets lors de la définition de fonctions, de classes, d'interfaces, etc.
Les génériques sont une fonctionnalité très utile lors de l'écriture de code réutilisable, flexible et sûr au niveau des types.
L'objectif principal de l'utilisation des génériques est de gérer des données de types non spécifiés, permettant au code de s'appliquer à plusieurs types de données sans perdre la vérification des types.
Les avantages des génériques incluent :
Réutilisation du code :Vous pouvez écrire du code générique indépendant de types spécifiques, ce qui améliore la réutilisabilité du code.
Sécurité des types :La vérification des types est effectuée au moment de la compilation, évitant les erreurs de type à l'exécution.
Abstraction :Permet d'écrire du code plus abstrait et générique qui s'adapte à différents types de données et structures de données.
Identifiants génériques
Dans les génériques, certains identifiants conventionnels sont couramment utilisés, tels que les courantsT(représentant Type),U、Vetc. Mais en fait, vous pouvez utiliser n'importe quel identifiant.
T: Représente "Type", et est le nom le plus courant de paramètre de type générique.
function identity<T>(arg: T): T {
return arg;
}K, V: Utilisé pour représenter les paramètres de type génériques pour les clés (Key) et les valeurs (Value).
interface KeyValuePair<K, V> {
key: K;
value: V;
}E: Utilisé pour représenter le paramètre de type générique pour les éléments de tableau.
function printArray<E>(arr: E[]): void {
arr.forEach(item => console.log(item));
}R: Utilisé pour représenter le paramètre de type générique pour les valeurs de retour de fonction.
function getResult<R>(value: R): R {
return value;
}U, V: Généralement utilisé pour représenter les deuxième et troisième paramètres de type génériques.
function combine<U, V>(first: U, second: V): string {
return `${first} ${second}`;
}
Ces identifiants sont conventionnels. En fait, vous pouvez choisir n'importe quel nom qui respecte les règles de nommage des identifiants. L'essentiel est de rendre le code lisible et facile à comprendre, il est donc recommandé d'utiliser des noms descriptifs pour les paramètres de type génériques afin d'aider à comprendre leur objectif.
Fonctions génériques
Utilisez des génériques pour créer une fonction capable de gérer différents types :
Exemple
return arg;
}
// Utilisation d'une fonction générique
let result = identity<string>("Hello");
console.log(result); // Sortie : Hello
let numberResult = identity<number>(42);
console.log(numberResult); // Sortie : 42
Analyse :Dans l'exemple ci-dessus,identityest une fonction générique, en utilisant<T>pour représenter le type générique. Elle accepte un paramètrearget la valeur de retour sont tous deux du type génériqueT. Lors de son utilisation, vous pouvez spécifier explicitement le type générique via des chevrons<>. Le premier appel spécifiestringtype, et le second appel spécifienumbertype.
2. Interfaces génériques
Vous pouvez utiliser des génériques pour définir des interfaces, ce qui permet aux membres de l’interface d’utiliser n’importe quel type :
Exemple
interface Pair<T, U> {
first: T;
second: U;
}
// Utilisation d’une interface générique
let pair: Pair<string, number> = { first: "hello", second: 42 };
console.log(pair); // Sortie : { first: 'hello', second: 42 }
Analyse :Ici, une interface générique est définiePair, qui possède deux paramètres de typeTetU. Ensuite, un objet a été créé à l’aide de cette interface génériquepair, oùfirstest de type chaîne,secondest un type numérique.
3. Classes génériques
Les génériques peuvent également être appliqués aux variables d'instance et aux méthodes d'une classe :Exemple
class Box<T> {
private value: T;
constructor(value: T) {
this.value = value;
}
getValue(): T {
return this.value;
}
}
// Utilisation d'une classe générique
let stringBox = new Box<string>("TypeScript");
console.log(stringBox.getValue()); // Sortie : TypeScript
Analyse :Dans cet exemple,Boxest une classe générique, utilisant<T>pour représenter le type générique. Le constructeur et les méthodes peuvent tous deux utiliser le type génériqueT. En instanciantBox<string>, nous avons créé uneBoxqui stocke une chaîne, et grâce à lagetValue, nous avons obtenu la valeur stockée.
4. Contraintes génériques
Parfois, vous souhaitez restreindre la portée de type des génériques ; vous pouvez utiliser des contraintes génériques :
Exemple
interface Lengthwise {
length: number;
}
function logLength<T extends Lengthwise>(arg: T): void {
console.log(arg.length);
}
// Utilisation correcte
logLength("hello"); // Sortie : 5
// Utilisation incorrecte, car les nombres n'ont pas de propriété length
logLength(42); // Erreur
Analyse :Dans cet exemple, une fonction générique est définielogLength, qui accepte un argument de typeT, mais il existe une condition de contrainte, à savoirTdoit implémenter l'Lengthwiseinterface, qui nécessite unelengthpropriété. Par conséquent, il est correct d'appelerlogLength("hello"), mais il n'est pas permis d'appelerlogLength(42), car les nombres n'ont pas delengthpropriété.
5. Génériques et valeurs par défaut
Vous pouvez définir des valeurs par défaut pour les génériques, afin que lorsqu'aucun paramètre de type n'est spécifié, le type par défaut puisse être utilisé :
Exemple
function defaultValue<T = string>(arg: T): T {
return arg;
}
// Utilisation d'une fonction générique avec des valeurs par défaut
let result1 = defaultValue("hello"); // Inféré comme type string
let result2 = defaultValue(42); // Inféré comme type number
Explication :Cet exemple démontre une fonction générique avec des valeurs par défaut. La fonctiondefaultValueaccepte un paramètre génériqueT, et définit son type par défaut àstring. Lors de son utilisation, si aucun type n'est explicitement spécifié, le type par défaut sera utilisé. Dans l'exemple, lors du premier appelresult1est inféré commestringtype, et lors du second appelresult2est inféré commenumbertype.