რა არის მომხმარებელმა განსაზღვრული ტიპის გარდი?

Question

Accepted Answer

**მომხმარებელმა განსაზღვრული ტიპის გარდი** არის ფუნქცია, რომლის დაბრუნების ტიპი არის **ტიპის პრედიკატი** (`x is T`). როდესაც ის `true`-ს აბრუნებს, კომპილერი ვიწროვდის არგუმენტს `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
  }
}
```

`pet is Cat` პრედიკატის გარეშე, `isCat` `boolean`-ის დაბრუნება *არ* ვიწროვდებს `pet`-ს — კომპილერი `if`-ის შიგნით კვლავ `Cat | Dog`-ს ხედავდა. პრედიკატი ის არის, რაც ამას ასწავლის.

## უცნობი გარე მონაცემების ვალიდირება

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

## გაფრთხოვება

კომპილერი **უჯდის** თქვენს პრედიკატს — თუ სხეულის ლოგიკა არასწორია, თქვენ უსაფრთხო ვიწროვებას მიიღებთ. რთული ფორმებისთვის, სქემის ვალიდატორი (zod) სწორი გარდებს ქმნის თქვენთვის.

## რატომ მნიშვნელოვანია

ტიპის გარდებმა შეგძლიათ თვითნებური რანტაიმის შემოწმებები გადაიყვანოთ ხელმეორედ გამოყენებადი ვიწროვების ფუნქციებად — აუცილებელი უცნობი მონაცემების `unknown` ვალიდირებისთვის API/საზღვრებზე და იმისთვის, რომ განასხვავოთ კავშირის წევრები, როდესაც მარტივი `typeof`/`in` შემოწმება საკუთარი არ არის საკმარი.