Co je typ never a jak umožňuje kontroly úplnosti?

Question

IT Interview Practice · Accepted Answer

`never` je typ hodnot, které **nikdy nenastávají** — funkce, která se nikdy nevrátí (vyvolá výjimku nebo se zacyklí), nebo větev, kterou kompilátor prokázal jako nemožnou. Je to *prázdný* typ: do `never` nelze přiřadit žádnou hodnotu (kromě samotného `never`).

```ts
function fail(msg: string): never { throw new Error(msg); } // never returns
function loop(): never { while (true) {} }
```

## Proč je never užitečný: kontrola úplnosti

Když zúžíte unii na nic, TypeScript typuje zbývající hodnotu jako `never`. Můžete to využít k vynucení zpracování každého případu:

```ts
type Shape =
  | { kind: "circle"; r: number }
  | { kind: "square"; side: number };

function area(s: Shape): number {
  switch (s.kind) {
    case "circle": return Math.PI * s.r ** 2;
    case "square": return s.side ** 2;
    default:
      // if all cases are handled, s is `never` here — assignment OK
      const _exhaustive: never = s;
      return _exhaustive;
  }
}
```

Teď, když někdo přidá `{ kind: "triangle"; ... }` do `Shape`, ale zapomene na případ, `s` ve výchozím případě je typ trojúhelníku (ne `never`), takže `const _exhaustive: never = s` **se nepodaří zkompilovat** — přesně vás upozorní na switch, který je třeba aktualizovat.

## never vs void

```ts
function a(): void {}   // returns normally, just no value
function b(): never { throw "x"; } // never returns at all
```

## Proč to je důležité

`never` změní "zpracoval jsem všechny případy?" z běhové naděje na záruку v čase kompilace.

Je to klíč k bezpečnému, budoucnosti otevřenému zpracování diskriminovaných unií — přidejte variantu a kompilátor vypíše každé místo, které musíte aktualizovat.

Proč je never užitečný: kontrola úplnosti

never vs void

Proč to je důležité

Související otázky