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

let mytuple: [number, string, boolean] = [42, "Example", true]; //Accéder aux éléments du tuple let num = mytuple[0]; //Accéder au premier élément, la valeur est 42, le type est number let str = mytuple[1]; //Accéder au deuxième élément, la valeur est "Example", le type est string let bool = mytuple[2]; //Accéder au troisième élément, la valeur est true, le type est boolean console.log(num); //Sortie : 42 console.log(str); //Sortie : Example console.log(bool); //Sortie : true

Compilez le code ci-dessus pour obtenir le code JavaScript suivant :

JavaScript

var mytuple = [42, "Example", true]; //Accéder aux éléments du tuple var num = mytuple[0]; //Accéder au premier élément, la valeur est 42, le type est number var str = mytuple[1]; //Accéder au deuxième élément, la valeur est "Example", le type est string var bool = mytuple[2]; //Accéder au troisième élément, la valeur est true, le type est boolean console.log(num); //Sortie : 42 console.log(str); //Sortie : Example console.log(bool); //Sortie : true

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

var tuple = [42, "Hello"]; //Ajouter un élément qui correspond au type tuple.push("World"); //Valide, car le tuple définit un type string optionnel console.log(tuple); //Sortie : [42, "Hello", "World"]

Compilez le code ci-dessus pour obtenir le code JavaScript suivant :

JavaScript

var tuple = [42, "Hello"]; //Ajouter un élément qui correspond au type tuple.push("World"); //Valide, car le tuple définit un type string optionnel console.log(tuple); //Sortie : [42, "Hello", "World"]

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

let tuple: [number, string, boolean] = [42, "Hello", vrai];

// 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

var mytuple = [42, "Example", "Taobao", "Google"]; //Créer un tuple console.log("Le premier élément du tuple est :" + mytuple[0]) //Mise à jour de l'élément du tuple mytuple[0] = 121 console.log("Le premier élément du tuple est mis à jour à :"+ mytuple[0])

Compilez le code ci-dessus pour obtenir le code JavaScript suivant :

JavaScript

var mytuple = [42, "Example", "Taobao", "Google"]; //Créer un tuple console.log("Le premier élément du tuple est :" + mytuple[0]); //Mise à jour de l'élément du tuple mytuple[0] = 121; console.log("Le premier élément du tuple est mis à jour à :" + mytuple[0]);

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

let a: [number, string, boolean] = [42, "Hello", true];//Créer un tuple var [b,c] = a console.log( b ) console.log( c )

Compilez le code ci-dessus pour obtenir le code JavaScript suivant :

JavaScript

var a = [42, "Hello", true]; //Créer un tuple var b = a[0], c = a[1]; console.log(b); console.log(c);

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

function getUserInfo(): [number, string] {
    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 tuple1: [number, string] = [42, "Hello"];
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 tuple: [number, string, boolean] = [42, "Hello", vrai];

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

let tuple: [number, string, boolean] = [42, "Hello", vrai];

// 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

let tuple: [number, string, boolean] = [42, "Hello", vrai];

// 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 tuple1: [number, string] = [42, "Hello"];
let tuple2: [boolean] = [true];

let extendedTuple: [number, string, ...typeof tuple2] = [42, "Hello", ...tuple2];

console.log(extendedTuple); // Sortie : [42, "Hello", true]
Autres extensions