# Sådan oprettes og manipuleres TypeScript-arrays

Statisk typning gør det muligt for **TypeScript-kompilatoren** at overvåge datatypen for array-elementer. Denne funktion hjælper TypeScript-arrays med at reducere sandsynligheden for fejl i din kode, så du kan udvikle mere sikre og pålidelige applikationer.

## Hvad er TypeScript-arrays?

I TypeScript er arrays **ordnede lister med værdier**. Ligesom i JavaScript kan du bruge arrays i TypeScript til at gemme en samling af elementer. Elementerne kan tilhøre forskellige datatyper, herunder tal, strenge, objekter eller andre arrays. [TypeScript](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/hvad-er-typescript/) har den fordel, at det understøtter statisk typning, hvilket betyder, at du kan angive datatypen for elementerne i en array. Dette forbedrer igen fejlfinding under udviklingen.

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ørrelsen på forhånd. I TypeScript 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å eksisterende arrays. Arrays giver en ensartet struktur til organisering af data og gør det nemmere at filtrere, sortere og iterere over elementer.

Derudover kan TypeScript-arrays danne grundlag for implementering af datastrukturer såsom stakke (LIFO – Last-In-First-Out) og køer (FIFO – First-In-First-Out). De er også velegnede til **at repræsentere lister, tabeller og samlinger** i en række forskellige applikationer. Da elementer af samme type let kan administreres, er arrays særligt nyttige ved behandling af data fra eksterne kilder, det være sig API’er eller databaser.

## Hvad er syntaksen for TypeScript-arrays?

I TypeScript deklareres arrays med nøgleordene `let`, `const` eller `var` efterfulgt af et variabelnavn og en **datatypespecifikation**. Når du deklarerer en datatype, angiver du, hvilken datatype elementerne i arrayet skal have. Dette gøres ved hjælp af et kolon. Elementerne placeres i firkantede parenteser og adskilles med kommaer i en arrayinitialiseringsblok.

Den generelle syntaks for at deklarere en TypeScript-array er som følger:

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

- **variableName** er det navn, du vælger til arrayet.
- **datatype** angiver datatypen for elementerne 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 illustrere syntaksen:

```typescript
// 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 TypeScript-array-metoder findes der?

TypeScript-array-metoder er ekstremt nyttige og kraftfulde, fordi de giver dig mulighed for effektivt **at behandle, transformere og organisere** data i arrays. Følgende tabel giver dig et overblik over almindelige array-metoder i TypeScript og hvordan de kan bruges.

<table>
  <thead>
    <tr>
      <th>Metoder</th>
      <th>Beskrivelse</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>`push()`</td>
      <td>Tilføjer et eller flere elementer til slutningen af arrayet og returnerer den nye længde af arrayet.</td>
    </tr>
    <tr>
      <td>`pop()`</td>
      <td>Fjerner det sidste element fra arrayet og returnerer det.</td>
    </tr>
    <tr>
      <td>`unshift()`</td>
      <td>Tilføjer et eller flere elementer til begyndelsen af arrayet og returnerer den nye længde af arrayet.</td>
    </tr>
    <tr>
      <td>`shift()`</td>
      <td>Fjerner det første element fra arrayet og returnerer det.</td>
    </tr>
    <tr>
      <td>`concat()`</td>
      <td>Kombinerer den aktuelle matrix med en eller flere andre matricer og returnerer en ny matrix. Den oprindelige matrix forbliver uændret.</td>
    </tr>
    <tr>
      <td>`join(separator)`</td>
      <td>Konverterer elementerne i arrayet til en streng og returnerer den. Du kan vælge en separator for elementerne.</td>
    </tr>
    <tr>
      <td>`slice(start, end)`</td>
      <td>Opretter en flad kopi af arrayet bestående af elementerne mellem de angivne indekser ‘start’ (inklusive) og ‘end’ (eksklusive). Det oprindelige array forbliver uændret.</td>
    </tr>
    <tr>
      <td>`splice(start, deleteCount, element1, element2, ...)`</td>
      <td>Indsætter nye elementer på den angivne position og/eller fjerner elementer fra arrayet.</td>
    </tr>
    <tr>
      <td>`forEach(callback)`</td>
      <td>Udfører en angivet funktion for hvert element i arrayet.</td>
    </tr>
    <tr>
      <td>`map(callback)`</td>
      <td>Opretter en ny matrix ved at anvende en funktion på hvert element i matrixen.</td>
    </tr>
    <tr>
      <td>`filter(callback)`</td>
      <td>Opretter en ny matrix med alle elementer, der består den test, der er implementeret af den angivne funktion.</td>
    </tr>
  </tbody>
</table>

## TypeScript-arrayeksempler

TypeScript-arrays er uundværlige værktøjer, når det kommer til at organisere og behandle data i applikationer. Vi vil se på nogle af de vigtigste operationer nedenfor.

### Adgang til array-elementer

Adgang til array-elementer i TypeScript er en grundlæggende operation, der giver dig mulighed for at hente specifikke elementer i et array. Du kan få adgang til array-elementer ved hjælp af deres indeks, som repræsenterer deres position i arrayet. I TypeScript **er array-indekser nulbaserede**. Det betyder, at det første element har indeks 0, og det andet element har indeks 1.

```typescript
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
```

### Destrukturering af arrays

Med **array-destrukturering** kan du hurtigt og nemt udtrække værdier fra en array og tildele dem til en variabel.

```typescript
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 TypeScript-arrays

Her er et eksempel på, hvordan man gentager en array i TypeScript ved hjælp af en **for-loop**:

```typescript
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 indeholder tal. Vi bruger en for-loop til at gennemløbe arrayet. Loopen starter ved `i = 0`, og vi inkrementerer `i` i hvert loop-gennemløb. Med `numbers[i]` kan vi få adgang til det respektive element i arrayet og udskrive det.

Dette er resultatet:

```typescript
1
2
3
4
5
```


This is a markdown version of: [https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/typescript-arrays/](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/typescript-arrays/) for AI/LLM consumption.