Seriya: TypeScript Basics Dars 13

Intersection Types

TypeScript'dagi intersection type'lar (&), obyektlarni birlashtirish, distribyutivlik va union bilan farqi.

13-dars

Intersection Types

Ba'zan yangi tip noldan yozilmaydi, mavjud tiplarning birikmasi bo'ladi: foydalanuvchi ma'lumotlari va audit maydonlari (createdAt, updatedAt), asosiy komponent props'lari va qo'shimcha props'lar, obyekt va unga qo'shilgan metodlar. Har safar maydonlarni qo'lda nusxalash kodni ko'paytiradi va tiplar bir-biridan uzilib qoladi.

Intersection type shu muammoni hal qiladi: A & B degani "qiymat A va B talablarini bir vaqtda bajaradi". Union "yoki" desa, intersection "va" deydi.

Bu mavzu tiplarni birlashtirishning asosi. Type alias'lar, type va interface farqi, interface extension va intersection orqali composition unga bog'liq.

Qanday ishlaydi?

1. Obyekt tiplarini birlashtirish

type User = { id: number; name: string };
type Timestamps = { createdAt: Date; updatedAt: Date };

type UserRecord = User & Timestamps;

const ok: UserRecord = {
  id: 1,
  name: "Ali",
  createdAt: new Date(),
  updatedAt: new Date(),
};                                    // ✅ ikkala tipning barcha maydonlari bor

const bad: UserRecord = { id: 1, name: "Ali" };
// ❌ Type '{ id: number; name: string; }' is missing the following properties
//    from type 'Timestamps': createdAt, updatedAt

2. Mantiq: qiymatlar to'plamlarining kesishmasi

Union to'plamlarni birlashtirsa, intersection ularning kesishmasini oladi. Obyektlarda bu biroz teskari tuyuladi: ko'proq talab qo'yilgani sari mos qiymatlar kamayadi, shuning uchun User & Timestamps ko'proq maydonga ega, lekin kamroq qiymatga mos keladi. Primitive'larda kesishma to'g'ridan-to'g'ri ko'rinadi:

type X = string & number;              // never ← ikkala to'plamga tegishli qiymat yo'q
type Y = "a" & string;                 // "a"   ← literal string'ning ichida
type Z = ("a" | "b") & ("b" | "c");    // "b"   ← union'lar kesishmasi

3. Assignability: intersection — har bir a'zosining subtype'i

declare const rec: User & Timestamps;

const u: User = rec;                   // ✅ rec User talablarini ham bajaradi
const t: Timestamps = rec;             // ✅ Timestamps talablarini ham

declare const plain: User;
const back: UserRecord = plain;        // ❌ Timestamps maydonlari yetishmaydi

Yo'nalish: torroq tip kengroq tipga o'tadi, teskarisi o'tmaydi.

4. Union bilan birga: distribyutivlik

type Cat = { kind: "cat"; meow(): void };
type Dog = { kind: "dog"; bark(): void };
type WithId = { id: number };

type Pet = (Cat | Dog) & WithId;
// xuddi shunday: (Cat & WithId) | (Dog & WithId)

function show(p: Pet) {
  if (p.kind === "cat") p.meow();      // ✅ discriminated union ishlaydi, id ham mavjud
}

5. Runtime'da amaliy misol: Object.assign

Tiplar runtime'da o'chadi (type erasure), lekin ba'zi standart funksiyalar natijasini intersection deb tiplaydi:

const merged = Object.assign({ id: 1 }, { name: "Ali" });
// tip: { id: number } & { name: string }
merged.id;     // ✅
merged.name;   // ✅

6. Funksiya tiplarining intersection'i overload beradi

type Parse = ((x: string) => number) & ((x: number) => string);

declare const parse: Parse;
const a = parse("42");   // number
const b = parse(42);     // string

Bu function overload'ga teng ta'sir ko'rsatadi. Amalda overload'ni to'g'ridan-to'g'ri yozish ko'proq uchraydi, lekin intersection ekanini bilish murakkab tiplarni o'qishda yordam beradi.

Eng ko'p uchraydigan xato

Bir xil nomli, lekin mos kelmaydigan property'larni birlashtirish. Property jimgina never bo'lib qoladi.

type ApiUser = { id: string; name: string };
type DbUser  = { id: number; createdAt: Date };

type Merged = ApiUser & DbUser;

declare const m: Merged;
m.id;   // tip: never  ← string & number

const x: Merged = { id: 1, name: "Ali", createdAt: new Date() };
// ❌ Type 'number' is not assignable to type 'never'

Muammo shundaki, type Merged = ApiUser & DbUser qatorining o'zida xato chiqmaydi. Xato faqat tipni ishlatgan joyda paydo bo'ladi, va never xabari sababni aniq ko'rsatmaydi. Hech qanday qiymat string va number bo'la olmaydi, shuning uchun bu tipdagi obyektni yaratib bo'lmaydi.

Diskriminant sifatida ishlatiladigan literal property'larda TS buni yanada qattiqroq qiladi: { kind: "a" } & { kind: "b" } butun tipni neverga aylantiradi. Discriminated union bilan aralashtirsangiz, variantlar jimgina "yo'qolib" qolishi mumkin.

To'g'ri yechimlar:

// ✅ 1-yechim: to'qnashuvchi kalitni Omit bilan olib tashlab, keyin birlashtirish
type Merged2 = Omit<ApiUser, "id"> & DbUser;
// { name: string } & { id: number; createdAt: Date }

// ✅ 2-yechim: umumiy qismni ajratib, alohida nomlash
type Base   = { name: string };
type ApiDto = Base & { id: string };
type DbRow  = Base & { id: number; createdAt: Date };

interfaceda esa bunday to'qnashuv darhol xato beradi (Interface 'X' incorrectly extends interface 'Y'). Shu sababli kelishmovchilikni erta ushlash kerak bo'lsa, extends xavfsizroq.

& va | ni aralashtirib yuborish.

type ID = string & number;   // ⚠️ "string yoki number" demoqchi edingiz, lekin bu never

function find(id: ID) {}
find("abc");   // ❌ Argument of type 'string' is not assignable to parameter of type 'never'
find(123);     // ❌ number ham bo'lmaydi

type ID2 = string | number;  // ✅ to'g'ri: "yoki" uchun union

Oddiy qoida: obyektlarni birlashtirmoqchi bo'lsangiz &, qiymat variantlaridan biri bo'lishi kerak bo'lsa |.