Hvordan fungerer type inference?

Question

Accepted Answer

**Type inference** er TypeScript, der automatisk finder ud af typer fra kontekst, så du ikke behøver at annotere alt. Det udleder fra startværdier, return statements og brug.

```ts
let x = 10;          // inferred: number
let s = "hi";        // inferred: string
const arr = [1, 2];  // inferred: number[]
const obj = { a: 1, b: "x" }; // inferred: { a: number; b: string }
```

## Inference i funktioner og callbacks

```ts
function double(n: number) { return n * 2; } // return inferred as number

[1, 2, 3].map(n => n * 2); // `n` inferred as number from the array — no annotation needed
```

Denne **kontekstuelle typning** er grunden til, at callbacks sjældent har brug for parameterannotationer — TypeScript ved, at `map` på en `number[]` passerer et `number`.

## let vs const widening

```ts
let a = "hello";     // widened to string (let can be reassigned)
const b = "hello";   // narrowed to the literal type "hello"
```

`const` udleder den *bogstavelige* type, fordi den aldrig kan ændres; `let` udvides til den generelle type. Dette betyder noget for unions:

```ts
const dir = "up";              // type "up"
let dir2 = "up";               // type string
```

## Hvornår du skal annotere alligevel

- Funktionsparametre (kan ikke udledes).
- Når inference er for bred/snæver (f.eks. du vil have `string` ikke bogstaveligt).
- Tomme beholdere: `const xs = []` udleder `any[]` — annoteringerer som `number[]`.

## Hvorfor det betyder noget

Inference holder TypeScript-kode næsten lige så præcis som JavaScript og forbliver fuldt typet.

At forstå *hvornår* det aktiveres (og hvornår det udvides) lader dig annotere kun der, hvor det faktisk hjælper.