Ty­pe­Script: creazione e ma­ni­po­la­zio­ne di array

La ti­piz­za­zio­ne statica consente al com­pi­la­to­re di Ty­pe­Script di con­trol­la­re il tipo di dati degli elementi dell’array. In questo modo gli array di Ty­pe­Script riducono la pro­ba­bi­li­tà che il tuo codice contenga errori e ti per­met­to­no di svi­lup­pa­re ap­pli­ca­zio­ni sicure e af­fi­da­bi­li.

Che cosa sono gli array di Ty­pe­Script?

In Ty­pe­Script gli array sono elenchi ordinati di valori. Come in Ja­va­Script, puoi uti­liz­za­re gli array di Ty­pe­Script per salvare una raccolta di elementi. Questi elementi possono essere di diversi tipi di dati, compresi numeri, catene di caratteri, oggetti o altri array. Ty­pe­Script ha il vantaggio di sup­por­ta­re la ti­piz­za­zio­ne statica, ossia ti permette di definire il tipo di dati degli elementi in un array. Questa ca­rat­te­ri­sti­ca migliora il ri­le­va­men­to degli errori durante lo sviluppo. Senza contare che può anche inferire il tipo di variabile basandosi sul suo valore iniziale.

Una proprietà fon­da­men­ta­le degli array è la loro di­men­sio­ne dinamica. In questo modo puoi ag­giun­ge­re o rimuovere elementi senza dover prima stabilire la di­men­sio­ne. In Ty­pe­Script gli array sono mo­di­fi­ca­bi­li per im­po­sta­zio­ne pre­de­fi­ni­ta. È comunque possibile creare array im­mu­ta­bi­li, ossia nuovi array basati su array già esistenti, uti­liz­zan­do metodi array come map e filter. Questi com­po­nen­ti fa­ci­li­ta­no le ope­ra­zio­ni di fil­trag­gio, or­di­na­men­to e ite­ra­zio­ne sugli elementi, offrendo una struttura coerente per l’or­ga­niz­za­zio­ne dei dati.

Inoltre, è possibile sfruttare gli array di Ty­pe­Script come base per l’im­ple­men­ta­zio­ne di strutture dati come pile (LIFO, Last In First Out) e code (FIFO, First In First Out). Sono adatti anche a rap­pre­sen­ta­re elenchi, tabelle e raccolte in una gran varietà di ap­pli­ca­zio­ni. Grazie alla facilità di gestione degli elementi dello stesso tipo, gli array sono par­ti­co­lar­men­te utili per l’ela­bo­ra­zio­ne di dati da fonti esterne, che si tratti di API o database.

La sintassi degli array di Ty­pe­Script

In Ty­pe­Script gli array sono di­chia­ra­ti con le parole chiave let, const o var, seguite da un nome di variabile e da un’in­di­ca­zio­ne del tipo di dati. Per la di­chia­ra­zio­ne del tipo di dati si uti­liz­za­no i due punti, indicando quale tipo di dati deve essere assegnato agli elementi nell’array. Questi elementi sono po­si­zio­na­ti in un blocco di ini­zia­liz­za­zio­ne dell’array tra parentesi quadre e separati da virgole. Ciò li dif­fe­ren­zia dalle variabili.

La sintassi generale per la di­chia­ra­zio­ne di un array di Ty­pe­Script è la seguente:

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

• va­ria­ble­Na­me è il nome che hai scelto per l’array.
• datatype indica il tipo di dati da assegnare agli elementi nell’array.
• [element1, element2, …] sono i veri e propri elementi o i valori da salvare nell’array. Questi elementi devono essere del tipo di dati definito in pre­ce­den­za.

Di seguito trovi alcuni esempi che ti spiegano meglio la sua sintassi:

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

Metodi degli array di Ty­pe­Script

I metodi degli array di Ty­pe­Script sono estre­ma­men­te utili e potenti perché ti per­met­to­no di elaborare, tra­sfor­ma­re e or­ga­niz­za­re i dati contenuti in un array in modo ef­fi­cien­te. La tabella seguente mostra una pa­no­ra­mi­ca dei metodi degli array più comuni in Ty­pe­Script e i loro campi di ap­pli­ca­zio­ne.

Esempi di utilizzo degli array di Ty­pe­Script

Gli array di Ty­pe­Script sono strumenti in­di­spen­sa­bi­li per or­ga­niz­za­re ed elaborare i dati nelle ap­pli­ca­zio­ni. Nelle parti seguenti ti mostriamo alcune delle procedure più im­por­tan­ti.

Accesso agli elementi di un array

L’accesso agli elementi di un array in Ty­pe­Script è un’ope­ra­zio­ne fon­da­men­ta­le che ti permette di ri­chia­ma­re specifici elementi all’interno dello stesso array. È possibile accedere agli elementi di un array tramite il loro indice, che ne rap­pre­sen­ta la posizione nella struttura. In Ty­pe­Script l’in­di­ciz­za­zio­ne degli array parte da zero. Pertanto, il primo elemento ha indice 0 e il secondo ha indice 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

De­strut­tu­ra­zio­ne degli array

La de­strut­tu­ra­zio­ne degli array in Ty­pe­Script (co­no­sciu­ta anche come “object de­struc­tu­ring” in inglese) è un modo facile e veloce per estrarre valori da un array e as­se­gnar­li alle variabili.

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

Ite­ra­zio­ne sugli elementi in array di Ty­pe­Script

L’esempio seguente mostra l’ite­ra­zio­ne su un array in Ty­pe­Script per mezzo di un ciclo for:

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

Questo esempio presenta un array numbers con­te­nen­te dei numeri. Uti­liz­zia­mo un ciclo for per eseguire l’ite­ra­zio­ne sull’array. Il ciclo inizia con i = 0; i aumenta a ogni passaggio del ciclo. Uti­liz­zan­do numbers[i] accediamo all’elemento in­te­res­sa­to dell’array e il valore viene re­sti­tui­to come output.

Il risultato che otteniamo è il seguente:

1
2
3
4
5