Ce este restricționarea tipului și cum o face compilatorul?

Question

Accepted Answer

**Restricționarea** este modul în care TypeScript rafinează un tip larg (cum ar fi o uniune) la unul mai specific într-o ramură de cod, bazat pe verificări în timp de execuție. Compilatorul urmărește fluxul de control și actualizează tipul în consecință.

```ts
function process(x: string | number) {
  if (typeof x === "string") {
    x.toUpperCase(); // ✅ here x is narrowed to string
  } else {
    x.toFixed(2);    // ✅ here x must be number
  }
}
```

## Instrumentele de restricționare

```ts
typeof x === "string"          // typeof guard — for primitives
x instanceof Date              // instanceof — for classes
"role" in obj                  // in operator — property existence
Array.isArray(x)               // built-in guards
if (x) { ... }                  // truthiness narrows out null/undefined/0/""
if (x === null) { ... }         // equality narrowing
```

## Uniunile discriminate se restricționează curat

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

function area(s: Shape) {
  switch (s.kind) {            // the discriminant
    case "circle": return Math.PI * s.r ** 2;  // s is the circle variant
    case "square": return s.side ** 2;          // s is the square variant
  }
}
```

Verificarea câmpului literal partajat (`kind`) îi spune compilatorului exact ce variantă ai, deblochând proprietățile acelei variante.

## Gardienele personalizate extind restricționarea

```ts
function isUser(x: unknown): x is User { return !!x && typeof (x as any).name === "string"; }
```

## De ce este important

Restricționarea este ceea ce face tipurile de uniune *utilizabile* — te permite să accesezi în siguranță membrii specifici tipului doar după ce ai dovedit tipul, transformând verificările în timp de execuție în garanții la compile time.

Este mecanismul zilnic din spatele gestionării `string | number`, `T | null` și stării etichetate.