Hur fungerar typslutledning?

Question

Accepted Answer

**Typslutledning** är när TypeScript räknar ut typer automatiskt från sammanhanget, så du behöver inte annotera allt. Det slutleder från initialvärden, return-satser och användning.

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

## Slutledning i funktioner och 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
```

Denna **kontextuell typning** är anledningen till att callbacks sällan behöver parameterannoteringar — TypeScript vet att `map` på en `number[]` skickar en `number`.

## let vs const utvidgning

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

`const` slutleder den *literala* typen eftersom det aldrig kan ändras; `let` vidgar till den allmänna typen. Det spelar roll för unions:

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

## När man bör annotera ändå

- Funktionsparametrar (kan inte slutledas).
- När slutledningen är för vid/trång (t.ex. du vill ha `string` inte litteralen).
- Tomma behållare: `const xs = []` slutleder `any[]` — annotera som `number[]`.

## Varför det är viktigt

Slutledning gör TypeScript-kod nästan lika koncis som JavaScript medan den förblir fullt typerad.

Att förstå *när* den aktiveras (och när den vidgas) låter dig annotera bara där det faktiskt hjälper.