Menene janyar iri da mai bugi ya bayyana?

Question

Accepted Answer

**Janyar iri da mai bugi ya bayyana** shine aiki wanda girkin koma shine **janyar iri** (`x is T`). Lokacin da ya dawo `true`, compiler ya kurkura gardama zuwa `T` a cikin lamarin kira — ba ka da bugi da ka kurkura janyar gudu na asali na kai tsaye.

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

Ba tare da janyar `pet is Cat` ba, `isCat` din koma `boolean` ba zai kurkura `pet` ba — compiler zai dage ganin `Cat | Dog` a cikin `if`. Janyar shine abin da ya koya wa shi.

## Tabbatar da bayanan waje da ba a sani

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

## Gargadi

Compiler ya **sadatsa** janyarinka — idan ilimin jiki ba daidai ba ne, sai ka sami tabbatar ba tsatsar jiya ba. Don natstsewa masu rikitarwa, mai amfani da schema (zod) ya tsara abubuwan gida daidai da gida gare ka.

## Menene wajase

Janyar iri ta ba ka damar juya duk wani bincike na jiya na gudu zuwa ayyuka na tabbatar mai amfani — dole ne don tabbatar da bayanan `unknown` a iyakin API da kuma don bambanta iyalai na haɗin lokacin da bincike mai sauuki `typeof`/`in` bai isa karai ba.