Ty­peS­cript Arrays : comment créer et manipuler des tableaux Ty­peS­cript ?

Le typage statique permet au com­pi­la­teur Ty­peS­cript de sur­veil­ler le type de données des éléments d’un tableau. Les Ty­peS­cript Arrays réduisent ainsi le risque d’erreurs dans votre code, ce qui vous permet de dé­ve­lop­per des ap­pli­ca­tions plus sûres et plus fiables.

Ty­peS­cript Arrays : dé­fi­ni­tion et ex­pli­ca­tion

En Ty­peS­cript, les tableaux sont appelés Arrays. Il s’agit en fait de listes ordonnées de valeurs per­met­tant, comme en Ja­vaS­cript, de stocker une col­lec­tion d’éléments. Ces éléments peuvent avoir dif­fé­rents types de données, y compris des nombres, des chaînes de ca­rac­tères, des objets ou même d’autres tableaux. Ty­peS­cript présente l’avantage de supporter le typage statique, ce qui signifie que vous pouvez définir le type de données des éléments dans un tableau. Cela améliore notamment la détection des erreurs lors du dé­ve­lop­pe­ment.

Une ca­rac­té­ris­tique décisive des tableaux est leur taille dynamique. Cela vous permet d’ajouter ou de supprimer des éléments sans avoir à dé­ter­mi­ner leur taille à l’avance. Les Ty­peS­cript Arrays sont mo­di­fiables par défaut, mais vous pouvez également créer des tableaux immuables en utilisant des méthodes comme map et filter.

Les tableaux fa­ci­li­tent le filtrage, le tri et l’itération sur les éléments et four­nis­sent une structure cohérente pour l’or­ga­ni­sa­tion des données. De plus, ils peuvent servir de base à l’im­plé­men­ta­tion de struc­tures de données telles que les piles (LIFO, Last-In-First-Out) et les files d’attente (FIFO, First-In-First-Out). Ils con­vien­nent aussi à la re­pré­sen­ta­tion de listes, de tableaux et de col­lec­tions dans une multitude d’ap­pli­ca­tions. En fa­ci­li­tant la gestion d’éléments du même type, les tableaux sont par­ti­cu­liè­re­ment utiles pour traiter des données provenant de sources externes, qu’il s’agisse d’API ou de bases de données.

Ty­peS­cript Arrays : quelle syntaxe ?

En Ty­peS­cript, les tableaux sont déclarés avec les mots-clés let, const ou var suivis d’un nom de variable et d’une in­di­ca­tion de type de données. La dé­cla­ra­tion du type de données se fait par deux points et indique le type de données que les éléments du tableau doivent avoir. Ces éléments sont placés entre crochets et séparés par des virgules dans un bloc d’ini­tia­li­sa­tion du tableau.

La syntaxe générale pour déclarer un tableau Ty­peS­cript se présente comme suit :

const variableName: datatype[] = [element1, element2, ...];

• va­ria­ble­Name : le nom que vous avez choisi pour le tableau
• datatype : le type de données que les éléments du tableau doivent avoir
• [element1, element2, …] : les éléments ou valeurs réels qui doivent être stockés dans le tableau. Ces éléments doivent avoir le type de données défini pré­cé­dem­ment

Voici plusieurs exemples pour illustrer la syntaxe :

// Data type: Number
const numbers: number[] = [1, 2, 3, 4, 5];
// Data type: String
const numbers: string[] = ["Alice", "Bob", "Charlie"];
// Data type: Boolean
const booleans: boolean[] = [true, false];

Ty­peS­cript Arrays : les méthodes de tableaux à connaître

Les méthodes de tableau Ty­peS­cript sont ex­trê­me­ment utiles et puis­santes, car elles vous per­met­tent de traiter, de trans­for­mer et d’organiser ef­fi­ca­ce­ment des données dans des tableaux. Le tableau suivant vous donne un aperçu des méthodes courantes dans Ty­peS­cript et de leurs domaines d’ap­pli­ca­tion.

Ty­peS­cript Arrays : exemples d’uti­li­sa­tion

Les tableaux Ty­peS­cript sont des outils in­dis­pen­sables lorsqu’il s’agit d’organiser et de traiter des données dans des ap­pli­ca­tions. Nous vous pré­sen­tons quelques-unes des prin­ci­pales opé­ra­tions.

Accès aux éléments d’un tableau

L’accès aux éléments d’un tableau dans Ty­peS­cript est une opération de base qui vous permet de récupérer des éléments spé­ci­fiques dans un tableau. Vous pouvez accéder aux éléments d’un tableau à l’aide de leur index, qui re­pré­sente leur position dans le tableau. En Ty­peS­cript, l’in­dexa­tion des tableaux est basée sur le zéro. Le premier élément a donc l’index 0 et le deuxième l’index 1.

let myArray: number[] = [10, 20, 30, 40, 50];
// Accessing elements using index
let firstElement: number = myArray[0]; // Output: 10
let secondElement: number = myArray[1]; // Output: 20
let thirdElement: number = myArray[2]; // Output: 30
// Assigning a new value to an array element
myArray[3] = 99; // 4th element in myArray = 99

Dés­truc­tu­ra­tion d’un tableau

La dés­truc­tu­ra­tion de tableau en Ty­peS­cript permet d’extraire ra­pi­de­ment et fa­ci­le­ment des valeurs d’un tableau et de les affecter à des variables.

let numberArray: number[] = [1, 2, 3];
// Array destructuring
let [firstNumber, secondNumber, thirdNumber] = numberArray;
// Access values
console.log(firstNumber); // Outputs 1
console.log(secondNumber); // Outputs 2
console.log(thirdNumber); // Outputs 3

Itération sur les éléments dans les tableaux Ty­peS­cript

Voici un exemple d’itération sur un tableau en Ty­peS­cript à l’aide d’une boucle for :

let numbers: number[] = [1, 2, 3, 4, 5];
for (let i = 0; i < numbers.length; i++) {
    console.log(numbers[i]);
}

Dans cet exemple, nous avons un tableau numbers contenant des nombres. Nous utilisons une boucle for pour itérer dans le tableau. La boucle commence à i = 0 et nous aug­men­tons i à chaque passage de la boucle. Avec numbers[i], nous accédons à l’élément respectif du tableau et le re­tour­nons.

Nous obtenons alors la sortie :

1
2
3
4
5

093957d8103b608356182c175c5ba61a