Hoe Ty­pe­Script-arrays maken en bewerken

Statische typering maakt het mogelijk voor de Ty­pe­Script-compiler om het ge­ge­vens­ty­pe van array-elementen te con­tro­le­ren. Deze functie helpt Ty­pe­Script-arrays om de kans op fouten in uw code te ver­min­de­ren, waardoor u veiligere en be­trouw­baar­de­re ap­pli­ca­ties kunt ont­wik­ke­len.

Wat zijn Ty­pe­Script-arrays?

In Ty­pe­Script zijn arrays geordende lijsten met waarden. Net als in Ja­vaScript kun je arrays in Ty­pe­Script gebruiken om een ver­za­me­ling elementen op te slaan. Elementen kunnen tot ver­schil­len­de ge­ge­vens­ty­pen behoren, waaronder getallen, strings, objecten of andere arrays. Ty­pe­Script heeft het voordeel dat het statische typering on­der­steunt, wat betekent dat je het ge­ge­vens­ty­pe van de elementen in een array kunt spe­ci­fi­ce­ren. Dit verbetert op zijn beurt de fout­de­tec­tie tijdens de ont­wik­ke­ling.

Een be­lang­rijk kenmerk van arrays is hun dy­na­mi­sche grootte, waardoor u elementen kunt toevoegen of ver­wij­de­ren zonder vooraf de grootte te hoeven bepalen. In Ty­pe­Script zijn arrays standaard ver­an­der­lijk. U kunt echter on­ver­an­der­lij­ke arrays maken door gebruik te maken van array-methoden zoals map en filter. On­ver­an­der­lij­ke arrays kunnen worden gebruikt om nieuwe arrays te maken op basis van bestaande arrays. Arrays bieden een con­sis­ten­te structuur voor het or­ga­ni­se­ren van gegevens en maken het ge­mak­ke­lij­ker om elementen te filteren, sorteren en doorlopen.

Bovendien kunnen Ty­pe­Script-arrays een basis vormen voor het im­ple­men­te­ren van da­ta­struc­tu­ren zoals stacks (LIFO - Last-In-First-Out) en wacht­rij­en (FIFO - First-In-First-Out). Ze zijn ook geschikt voor het weergeven van lijsten, tabellen en ver­za­me­lin­gen in ver­schil­len­de toe­pas­sin­gen. Omdat elementen van hetzelfde type ge­mak­ke­lijk kunnen worden beheerd, zijn arrays bijzonder nuttig bij het verwerken van gegevens uit externe bronnen, of het nu gaat om API’s of databases.

Wat is de syntaxis voor Ty­pe­Script-arrays?

In Ty­pe­Script worden arrays ge­de­cla­reerd met de sleu­tel­woor­den let, const of var, gevolgd door een va­ri­a­be­le­naam en een ge­ge­vens­ty­pe­spe­ci­fi­ca­tie. Wanneer u een ge­ge­vens­ty­pe de­cla­reert, geeft u aan welk ge­ge­vens­ty­pe de elementen in de array moeten hebben. Dit doet u met een dubbele punt. De elementen worden tussen vierkante haken geplaatst en ge­schei­den door komma’s in een array-ini­ti­a­li­sa­tie­blok.

De algemene syntaxis voor het de­cla­re­ren van een Ty­pe­Script-array is als volgt:

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

• va­ria­ble­Na­me is de naam die u voor de array kiest.
• datatype spe­ci­fi­ceert het ge­ge­vens­ty­pe van de elementen in de array.
• [element1, element2, …] zijn de daad­wer­ke­lij­ke elementen of waarden die in de array moeten worden op­ge­sla­gen. Deze elementen moeten het ge­ge­vens­ty­pe hebben dat voor de array is opgegeven.

Hier zijn enkele voor­beel­den die de syntaxis helpen il­lu­stre­ren:

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

Welke Ty­pe­Script-array-methoden zijn er?

Ty­pe­Script-array-methoden zijn uiterst nuttig en krachtig omdat ze u in staat stellen om gegevens efficiënt te verwerken, te trans­for­me­ren en te or­ga­ni­se­ren in arrays. De volgende tabel geeft u een overzicht van veel­ge­bruik­te array-methoden in Ty­pe­Script en hoe deze kunnen worden gebruikt.

Voor­beel­den van Ty­pe­Script-arrays

Ty­pe­Script-arrays zijn onmisbare hulp­mid­de­len voor het or­ga­ni­se­ren en verwerken van gegevens in ap­pli­ca­ties. Hieronder bekijken we enkele van de be­lang­rijk­ste be­wer­kin­gen.

Toegang tot array-elementen

Toegang krijgen tot array-elementen in Ty­pe­Script is een ba­sis­be­wer­king waarmee u spe­ci­fie­ke elementen binnen een array kunt ophalen. U kunt toegang krijgen tot array-elementen met behulp van hun index, die hun positie in de array aangeeft. In Ty­pe­Script zijn array-indexen gebaseerd op nul. Dit betekent dat het eerste element index 0 heeft en het tweede element 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

Arrays ontleden

Met array de­struc­tu­ring kun je snel en eenvoudig waarden uit een array halen en deze aan een variabele toewijzen.

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

Herhalen van elementen in Ty­pe­Script-arrays

Hier is een voorbeeld van hoe je een array in Ty­pe­Script kunt doorlopen met behulp van een for-lus:

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

In dit voorbeeld hebben we de array numbers, die getallen bevat. We gebruiken een for-lus om door de array te itereren. De lus begint bij i = 0 en we verhogen i in elke lus­door­loop. Met numbers[i] kunnen we het be­tref­fen­de element van de array openen en weergeven.

Dit is de uitvoer:

1
2
3
4
5