Kas yra vartotojo apibrėžtas tipo sargas?

Question

Accepted Answer

A **user-defined type guard** yra funkcija, kurios grąžinamo tipo anotacija yra **tipo predikatas** (`x is T`). Kai ji grąžina `true`, kompiliatorius susiaurina argumentą į `T` iškviečiančiame kode — leidžiant jums inkapsuliuoti pasirinktus runtime patikrinti.

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

Be `pet is Cat` predikato, `isCat` grąžinant `boolean` *nepraploš* `pet` — kompiliatorius vis tiek pamatytų `Cat | Dog` viduje `if`. Predikatas yra tai, kas jam to moko.

## Nežinomos išorinės duomenų pavalidavimas

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

## Įspėjimas

Kompiliatorius **pasitiki** jūsų predikatu — jei kūno logika neteisinga, jūs gaunate nesaugų susiaurinimą. Sudėtingoms strukturoms schemos validatorius (zod) sugeneruoja teisingus sargus jums.

## Kodėl tai svarbu

Tipo sargai jums leidžia paversti savavališkus runtime patikrinti į iš naujo panaudojamas susiaurinimo funkcijas — būtinas nežinomiems duomenims validuoti API/ribose ir unions nariams atskirti, kai paprastas `typeof`/`in` patikrinimas nepakanka.