# Hvad er TypeScript-funktioner? Definition, typesikkerhed og anvendelse

Med TypeScript kan brugerne deklarere typer for funktioner, parametre og returværdier. Da TypeScript kontrollerer, om de korrekte datatyper anvendes, hjælper deklarering af typer med at **opdage fejl tidligere** og øger kodekvaliteten.

## Hvad er TypeScript-funktioner?

TypeScript-funktioner er en central komponent i [TypeScript](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/hvad-er-typescript/). Funktioner i TypeScript ligner dem i JavaScript, men har den ekstra fordel, at **de er statisk typede**. Med denne tilgang er datatyper for variabler, parametre og returværdier allerede defineret ved kompilering og kan ikke ændres under udførelsen. Dette reducerer fejl i produktionsmiljøet.

En anden egenskab ved TypeScript-funktioner er deres fleksibilitet. Funktioner kan have valgfri og **standardværdier for parametre**, hvilket gør det nemmere at tilpasse dem til forskellige anvendelsestilfælde. Mulige anvendelser omfatter databehandling, brugergrænsefladeinteraktioner, asynkron programmering og meget mere. Du kan også definere overbelastninger for at levere forskellige funktionaliteter baseret på inputværdierne.

Ud over at deklarere funktioner kan du også bruge **hjælpefunktioner** i TypeScript. Disse funktioner er en kortere notation og bruges ofte i moderne JavaScript-udviklingspraksis.

TypeScript-funktioner er afgørende for at øge sikkerheden og læsbarheden af kode, der bruges i TypeScript-projekter. Samtidig gør deres fleksibilitet og tilpasningsevne dem velegnede til en lang række krav.

## Hvad er syntaksen for TypeScript-funktioner?

**TypeScript er et supersæt-sprog til JavaScript**. Som sådan ligner syntaksen i TypeScript-funktioner syntaksen i JavaScript-funktioner. Funktionskoden følger i krøllede parenteser `{ }`. Det er her, den egentlige logik i funktionen implementeres. Her er den grundlæggende syntaks for en TypeScript-funktion:

```typescript
function functionName(parameter1: type, parameter2: type): returnType {
    // Function Code
    return result; // (optional)
}
```

- **funktion**: dette nøgleord markerer begyndelsen på funktionsdeklarationen.
- **functionName**: dette er navnet på funktionen. Du bør vælge et beskrivende navn, der afspejler funktionens opgave.
- **parameter1, parameter2**: dette er de parametre, som funktionen forventer. Hver parameter identificeres ved sit navn og den forventede datatype (typeannotation).
- **returnType**: dette er den datatype, som funktionen returnerer. Du kan også angive `void`, hvis funktionen ikke returnerer en værdi.
- **return result** er valgfrit og bruges, hvis funktionen skal returnere en værdi.

TypeScript-funktioner kaldes ved at bruge funktionsnavnet efterfulgt af parenteser. I parenteserne angiver du **argumenterne (inputværdierne)** for funktionen, hvis den forventer parametre.

```typescript
functionName(argument1, argument2, ...);
```

## Eksempler på TypeScript-funktioner

TypeScript-funktioner er ekstremt alsidige og kan bruges til at udføre beregninger, operationer og komplekse processer i applikationer.

### Anonyme funktioner

Anonyme funktioner i TypeScript er funktioner, der **ikke har et navn** og overføres direkte i udtryk eller som argumenter til andre funktioner. Anonyme funktioner er nyttige, hvis du kun har brug for en funktion ét sted i koden og ikke ønsker at tildele din egen funktionsnavn.

```typescript
var greet = function(name) {
    return "Hello, " + name + "!";
};
var message = greet("John");
console.log(message); // Output: "Hello, John!"
```

I dette eksempel gemmes den anonyme funktion i variablen `greet` og kaldes senere for at oprette en personlig hilsen til `John`.

Anonyme funktioner omfatter også **lambda-funktioner**, der er kendt som pilfunktioner.

```typescript
const add = (a: number, b: number) => a + b;
const result = add(3, 5); // Output: 8
```

Her tildeles en anonym funktion, der lægger to tal sammen, til variablen `add` og kaldes derefter.

### Standardparametre

Standardparametre (også kendt som standardparametre) i TypeScript giver dig mulighed for at definere TypeScript-funktioner, så de har **standardværdier for parametre**. Når funktionen kaldes, og der ikke overføres nogen værdi som parameter, bruges standardværdien i stedet.

```typescript
function greet(name: string = "World") {
    return "Hello, " + name + "!";
}
console.log(greet()); // Output: "Hello, World!"
console.log(greet("John")); // Output: "Hello, John!"
```

Her har funktionen `greet` standardværdien `world` for parameteren `name`. Hvis der ikke overføres nogen værdi for `name`, når funktionen kaldes, vil standardværdien automatisk blive brugt.

### Rasteparametre

Med restparametre (også kendt som restoperatører eller restparametersyntaks) i TypeScript kan du samle et **uspecificeret antal argumenter** som [TypeScript-arrays](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/typescript-arrays/) i en funktion. Dette er nyttigt, hvis du vil skrive funktioner, der kan behandle varierende mængder af argumenter.

```typescript
function sum(...numbers: number[]): number {
    let total = 0;
    for (const num of numbers) {
        total += num;
    }
    return total;
}
console.log(sum(1, 2, 3, 4, 5)); // Output: 15
```

I eksemplet samler funktionen `sum` et vilkårligt antal tal som restparameter `numbers` og lægger dem sammen for at beregne den samlede sum. Du kan indtaste så mange tal, du vil, og funktionen vil lægge dem alle sammen.

### Overbelastning

Funktionsoverbelastning bruges til at definere flere funktionsdeklarationer med samme navne, men forskellige parametre eller returtyper. Dette hjælper TypeScript med automatisk at vælge den korrekte funktionsdeklaration afhængigt af de overførte argumenter og med at udføre **typekontroller**.

```typescript
function concatenate(a: string, b: string): string;
function concatenate(a: number, b: number): string;
function concatenate(a: any, b: any): string {
    return a.toString() + b.toString();
}
console.log(concatenate("Hello, ", "World")); // Output: "Hello, World"
console.log(concatenate(3, 5)); // Output: "35"
```

I eksemplet ovenfor har vi to funktionsoverbelastninger for `concatenate`. Den første accepterer to strenge, og den anden accepterer to tal. Funktionen selv konverterer de overførte argumenter til strenge og sammenkæder dem. TypeScript vælger automatisk den passende overbelastning baseret på de overførte argumenter og udfører de nødvendige typekontroller.

Funktionsoverbelastninger er særligt nyttige, hvis du **udvikler et API eller et bibliotek**, hvor du vil sikre, at brugen af funktionen er enkel og fejlfri, uanset de forskellige typer parametre, som brugerne angiver.


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