Wie funktioniert Type Inference?

Question

Accepted Answer

**Type Inference** ist TypeScript, das Typen automatisch aus dem Kontext herausfinden, sodass Sie nicht alles annotieren müssen. Es leitet Typen aus Anfangswerten, Return-Statements und Verwendung ab.

```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 in Funktionen und 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
```

Dieses **kontextuelle Typing** ist der Grund, warum Callbacks selten Parameter-Annotationen benötigen — TypeScript weiß, dass `map` auf einem `number[]` ein `number` übergibt.

## 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` leitet den *Literal*-Typ ab, weil er sich niemals ändern kann; `let` wird zum allgemeinen Typ erweitert. Dies ist wichtig für Unions:

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

## Wann Sie trotzdem annotieren sollten

- Funktionsparameter (können nicht hergeleitet werden).
- Wenn Inference zu breit/eng ist (z. B. Sie möchten `string` nicht das Literal).
- Leere Container: `const xs = []` leitet `any[]` her — annotieren Sie als `number[]`.

## Warum es wichtig ist

Inference hält TypeScript-Code fast so prägnant wie JavaScript und bleibt vollständig typisiert.

Wenn Sie verstehen, *wann* es aktiviert wird (und wann es sich erweitert), können Sie nur dort annotieren, wo es wirklich hilft.