Sådan oprettes og ma­ni­p­u­le­res Ty­pe­Script-arrays

Statisk typning gør det muligt for Ty­pe­Script-kom­pi­la­to­ren at overvåge datatypen for array-elementer. Denne funktion hjælper Ty­pe­Script-arrays med at reducere sand­syn­lig­he­den for fejl i din kode, så du kan udvikle mere sikre og på­li­de­li­ge ap­pli­ka­tio­ner.

Hvad er Ty­pe­Script-arrays?

I Ty­pe­Script er arrays ordnede lister med værdier. Ligesom i Ja­va­Script kan du bruge arrays i Ty­pe­Script til at gemme en samling af elementer. Ele­men­ter­ne kan tilhøre for­skel­li­ge datatyper, herunder tal, strenge, objekter eller andre arrays. Ty­pe­Script har den fordel, at det un­der­støt­ter statisk typning, hvilket betyder, at du kan angive datatypen for ele­men­ter­ne i en array. Dette forbedrer igen fejl­find­ing under ud­vik­lin­gen.

Et vigtigt træk ved arrays er deres dynamiske størrelse, som gør det muligt at tilføje eller fjerne elementer uden at skulle fastlægge stør­rel­sen på forhånd. I Ty­pe­Script er arrays som standard mutable. Du kan dog oprette immutable arrays ved hjælp af array-metoder som map og filter. Immutable arrays kan bruges til at oprette nye arrays baseret på ek­si­ste­ren­de arrays. Arrays giver en ensartet struktur til or­ga­ni­se­ring af data og gør det nemmere at filtrere, sortere og iterere over elementer.

Derudover kan Ty­pe­Script-arrays danne grundlag for im­ple­men­te­ring af da­ta­struk­tu­rer såsom stakke (LIFO – Last-In-First-Out) og køer (FIFO – First-In-First-Out). De er også velegnede til at re­præ­sen­te­re lister, tabeller og samlinger i en række for­skel­li­ge ap­pli­ka­tio­ner. Da elementer af samme type let kan ad­mi­ni­stre­res, er arrays særligt nyttige ved be­hand­ling af data fra eksterne kilder, det være sig API’er eller databaser.

Hvad er syntaksen for Ty­pe­Script-arrays?

I Ty­pe­Script de­kla­re­res arrays med nøg­le­or­de­ne let, const eller var ef­ter­fulgt af et va­ri­a­bel­navn og en da­ta­ty­pe­spe­ci­fi­ka­tion. Når du de­kla­re­rer en datatype, angiver du, hvilken datatype ele­men­ter­ne i arrayet skal have. Dette gøres ved hjælp af et kolon. Ele­men­ter­ne placeres i fir­kan­te­de pa­ren­te­ser og adskilles med kommaer i en ar­rayi­ni­ti­a­li­se­rings­blok.

Den generelle syntaks for at deklarere en Ty­pe­Script-array er som følger:

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

• va­ri­ab­le­Na­me er det navn, du vælger til arrayet.
• datatype angiver datatypen for ele­men­ter­ne i arrayet.
• [element1, element2, …] er de faktiske elementer eller værdier, der skal gemmes i arrayet. Disse elementer skal have den datatype, der er angivet for arrayet.

Her er et par eksempler, der hjælper med at il­lu­stre­re syntaksen:

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

Hvilke Ty­pe­Script-array-metoder findes der?

Ty­pe­Script-array-metoder er ekstremt nyttige og kraft­ful­de, fordi de giver dig mulighed for effektivt at behandle, trans­for­me­re og or­ga­ni­se­re data i arrays. Følgende tabel giver dig et overblik over al­min­de­li­ge array-metoder i Ty­pe­Script og hvordan de kan bruges.

Ty­pe­Script-ar­ray­ek­semp­ler

Ty­pe­Script-arrays er uund­vær­li­ge værktøjer, når det kommer til at or­ga­ni­se­re og behandle data i ap­pli­ka­tio­ner. Vi vil se på nogle af de vigtigste ope­ra­tio­ner nedenfor.

Adgang til array-elementer

Adgang til array-elementer i Ty­pe­Script er en grund­læg­gen­de operation, der giver dig mulighed for at hente spe­ci­fik­ke elementer i et array. Du kan få adgang til array-elementer ved hjælp af deres indeks, som re­præ­sen­te­rer deres position i arrayet. I Ty­pe­Script er array-indekser nul­ba­se­re­de. Det betyder, at det første element har indeks 0, og det andet element har indeks 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­struk­tu­re­ring af arrays

Med array-de­struk­tu­re­ring kan du hurtigt og nemt udtrække værdier fra en array og tildele dem til en variabel.

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

Iterering over elementer i Ty­pe­Script-arrays

Her er et eksempel på, hvordan man gentager en array i Ty­pe­Script ved hjælp af en for-loop:

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

I dette eksempel har vi arrayet numbers, som in­de­hol­der tal. Vi bruger en for-loop til at gen­nem­lø­be arrayet. Loopen starter ved i = 0, og vi in­kre­men­te­rer i i hvert loop-gennemløb. Med numbers[i] kan vi få adgang til det respek­ti­ve element i arrayet og udskrive det.

Dette er re­sul­ta­tet:

1
2
3
4
5