Mi az a felhasználó által definiált típusvédelem?

Question

IT Interview Practice · Accepted Answer

A **felhasználó által definiált típusvédelem** egy olyan függvény, amelynek a visszatérési típusa egy **típus predikátum** (`x is T`). Amikor `true` értéket ad vissza, a fordító az argumentumot `T` típusra szűkíti a hívó kódban — lehetővé téve az egyéni futásidejű ellenőrzések beágyazását.

```ts
interface Cat { meow(): void; }
interface Dog { bark(): void; }

// the magic is the return type `pet is Cat`, not just `boolean`
function isCat(pet: Cat | Dog): pet is Cat {
  return "meow" in pet;
}

function speak(pet: Cat | Dog) {
  if (isCat(pet)) {
    pet.meow(); // ✅ narrowed to Cat
  } else {
    pet.bark(); // ✅ narrowed to Dog
  }
}
```

A `pet is Cat` predikátum nélkül az `isCat` függvény `boolean` visszatérési értéke *nem* szűkítené a `pet` típusát — a fordító az `if` belsejében még mindig `Cat | Dog` típust látna. A predikátum tanítja meg a fordítót.

## Ismeretlen külső adatok érvényesítése

```ts
interface User { id: number; name: string; }

function isUser(x: unknown): x is User {
  return (
    typeof x === "object" && x !== null &&
    typeof (x as any).id === "number" &&
    typeof (x as any).name === "string"
  );
}

const data: unknown = await res.json();
if (isUser(data)) data.name; // ✅ safely typed as User
```

## Figyelmeztetés

A fordító **megbízik** az Ön predikátumában — ha a függvénytörzs logikája helytelen, nem biztonságos szűkítést kapunk. Összetett típusok esetén egy sémaérvényesítő (zod) helyesen generálja az őrfüggvényeket.

## Miért fontos

A típusvédelmi függvények lehetővé teszik tetszőleges futásidejű ellenőrzések újrafelhasználható szűkítő függvénnyé alakítását — szükséges az `unknown` adatok API-határokon való érvényesítéséhez és egy unió tagjainak megkülönböztetéséhez, ha az egyszerű `typeof`/`in` ellenőrzés nem elégséges.

Ismeretlen külső adatok érvényesítése

Figyelmeztetés

Miért fontos

Kapcsolódó kérdések