યુઝર-ડિફાઇન્ડ ટાઇપ ગાર્ડ શું છે?

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` ચેક એકલા પર્યાપ્ત નથી તે સમયે યુનિયનના સભ્યોને અલગ કરવા માટે આવશ્યક છે.