TypeScript Tuples
Nous savons que les types de données des éléments d'un tableau sont généralement les mêmes (les tableaux de type any[] peuvent être différents). Si les éléments stockés ont des types de données différents, vous devez utiliser des tuples.
Un tuple en TypeScript est un type spécial de tableau qui permet de stocker des éléments de types différents dans le tableau. Contrairement aux tableaux ordinaires, chaque élément d'un tuple a un type et une position clairs. Les tuples peuvent être utilisés dans de nombreux scénarios pour représenter des structures de données de longueur fixe et avec des types d'éléments connus.
La syntaxe de création d'un tuple est la suivante :
let tuple: [类型1, 类型2, 类型3, ...];
Exemple
Déclarer un tuple et l'initialiser :
let mytuple: [number, string]; mytuple = [42,"Example"];
Dans l'exemple ci-dessus, mytuple est un tuple qui contient un élément de type number et un élément de type string.
Accès aux tuples
Les éléments d'un tuple sont accessibles à l'aide d'index. L'index du premier élément est 0, celui du deuxième est 1, et ainsi de suite ; le nième est n-1. La syntaxe est la suivante :
tuple_name[index]
Exemple
L'exemple suivant définit un tuple qui contient deux types d'éléments : des nombres et des chaînes de caractères.
TypeScript
Compilez le code ci-dessus pour obtenir le code JavaScript suivant :
JavaScript
Le résultat de sortie est:
42 Example true
Opérations sur les tuples
Nous pouvons utiliser les deux fonctions suivantes pour ajouter de nouveaux éléments à un tuple ou en supprimer des éléments :
push() ajoute un élément au tuple, en l'ajoutant à la fin.
pop() supprime un élément (le dernier) du tuple et renvoie l'élément supprimé.
La méthode push peut ajouter un élément à la fin d'un tuple, et le type doit être conforme aux contraintes de type définies dans le tuple. S'il dépasse les contraintes de type du tuple, TypeScript signalera une erreur.
TypeScript
Compilez le code ci-dessus pour obtenir le code JavaScript suivant :
JavaScript
Le résultat de sortie est:
[ 42, 'Hello', 'World' ]
La méthode pop supprime un élément à la fin d'un tuple et retourne cet élément. Le type de l'élément retourné sera inféré en fonction des types définis du tuple.
Exemple
// Supprimer le dernier élément
let lastElement = tuple.pop();
console.log(lastElement); // Sortie : true
console.log(tuple); // Sortie : [42, "Hello"]
Mise à jour des tuples
Les tuples sont mutables, ce qui signifie que nous pouvons effectuer des opérations de mise à jour sur les tuples :
TypeScript
Compilez le code ci-dessus pour obtenir le code JavaScript suivant :
JavaScript
Le résultat de sortie est:
元组的第一个元素为:42 元组中的第一个元素更新为:121
Déstructuration des tuples
Nous pouvons également affecter les éléments d'un tuple à des variables, comme indiqué ci-dessous :
TypeScript
Compilez le code ci-dessus pour obtenir le code JavaScript suivant :
JavaScript
Le résultat de sortie est:
42 Hello
Utilisation des tuples étiquetés
TypeScript permet également d'ajouter des étiquettes à chaque élément d'un tuple, ce qui rend la signification du tuple plus claire :
let tuple: [id: number, name: string] = [1, "John"];
Dans cet exemple, id et name sont des étiquettes du tuple, ce qui peut rendre le code plus lisible.
Applications pratiques des tuples
Les tuples sont souvent utilisés dans des scénarios où une fonction retourne plusieurs valeurs, ou pour représenter des données avec une certaine structure fixe, par exemple :
Exemple
return [1, "John Doe"];
}
const [userId, userName] = getUserInfo();
console.log(userId); // Sortie : 1
console.log(userName); // Sortie : John Doe
Inférence de type des tuples
TypeScript peut automatiquement inférer le type d'un tuple en fonction des éléments du tableau :
let tuple = [42, "Hello"] as const; // 元组类型:[42, "Hello"]
Grâce à l'assertion as const, TypeScript traitera ce tuple comme un tuple constant immuable.
Concaténation de tuples
Les tuples peuvent être concaténés à l'aide de la méthode concat du tableau, mais notez que le résultat après concaténation est un tableau ordinaire, et non un tuple.
Exemple
let tuple2: [boolean, number] = [true, 100];
let result = tuple1.concat(tuple2); // Le résultat est un tableau : [42, "Hello", true, 100]
console.log(result); // Sortie : [42, "Hello", true, 100]
Découpage de tuples
Vous pouvez utiliser la méthode slice du tableau pour effectuer des opérations de découpage sur un tuple, en renvoyant un nouveau tableau.
Exemple
let sliced = tuple.slice(1); // Découpage à partir de l'index 1
console.log(sliced); // Sortie : ["Hello", true]
Itération sur les tuples
Vous pouvez utiliser une boucle for...of ou la méthode forEach pour parcourir les éléments d'un tuple.
Exemple
// Utilisation d'une boucle for...of
for (let item of tuple) {
console.log(item);
}
// Utilisation de la méthode forEach
tuple.forEach(item => console.log(item));
Conversion en tableau standard
Bien qu'un tuple soit un tableau de longueur fixe et de types fixes, vous pouvez le convertir en un tableau ordinaire via les méthodes de Array.prototype pour un traitement ultérieur.
Exemple
// Convertir en tableau et utiliser les méthodes de tableau
let array = Array.from(tuple);
array.push("New Element");
console.log(array); // Sortie : [42, "Hello", true, "New Element"]
Extension des tuples
En utilisant l'opérateur rest, vous pouvez facilement fusionner plusieurs tuples en un nouveau tuple :
Exemple
let tuple2: [boolean] = [true];
let extendedTuple: [number, string, ...typeof tuple2] = [42, "Hello", ...tuple2];
console.log(extendedTuple); // Sortie : [42, "Hello", true]