Çfarë është një mbrojtës i tipit i përcaktuar nga përdoruesi?

Question

Accepted Answer

Një **mbrojtës i tipit i përcaktuar nga përdoruesi** është një funksion presencat i të cilit të kthimit është një **predikat i tipit** (`x is T`). Kur kthehet `true`, kompajluesi ngushtë argumentin në `T` në kodin që e thërret — duke të lejuar të përfshish kontrolat rutinore të përshtatura sipas përvojës.

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

Pa predikatën `pet is Cat`, `isCat` i cili kthen `boolean` *nuk do të* ngushtonte `pet` — kompajluesi do të shihte ende `Cat | Dog` brenda `if`. Predikata është ajo që ia mëson atë.

## Validimi i të dhënave të jashtme të panjohura

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

## Kautelë

Kompajluesi **i beson** predikatës tuaj — nëse logjika në trup është e gabuar, ju merrni një ngushtim jo të sigurt. Për forma komplekse, një validator i skemës (zod) gjeneron për ju mbrojtësa të saktë.

## Pse kjo ka rëndësi

Mbrojtësit e tipit ju lejojnë të shndërroni kontrolat arbitrare rutinore në funksione ngushtimi të ripërdorshme — thelbësorë për validimin e të dhënave `unknown` në kufijtë e API-t dhe për të dalluar anëtarët e një bashkimi kur një kontroll i thjeshtë `typeof`/`in` nuk është i mjaftueshëm në vetvete.