Hvordan fungerer typeinferens?

Question

Accepted Answer

**Typeinferens** er TypeScript som automatisk figurer ut typer fra kontekst, slik at du ikke må annotere alt. Den infererer fra initialverdier, return-setninger og bruk.

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

## Inferens i funksjoner 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 typingen** er hvorfor callbacks sjelden trenger parameterannotasjoner — TypeScript vet at `map` på en `number[]` sender et `number`.

## let vs const utvidelse

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

`const` infererer den *litterale* typen fordi den aldri kan endres; `let` utvider til den generelle typen. Dette betyr noe for unions:

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

## Når man skal annotere likevel

- Funksjonsparametere (kan ikke infereres).
- Når inferens er for bred/smal (f.eks. du vil ha `string` ikke den litterale).
- Tomme kontainere: `const xs = []` infererer `any[]` — annoteringsporten som `number[]`.

## Hvorfor det betyr noe

Inferens holder TypeScript-kode nesten like kortfattet som JavaScript mens den forblir fullt typet.

Å forstå *når* den aktiveres (og når den utvider) lar deg annotere bare hvor det faktisk hjelper.