Seriya: TypeScript Basics Dars 24

Intersection orqali composition

TypeScript'da & yordamida kichik bo'laklardan type yig'ish: union bilan composition, generic o'ramlar, extends bilan taqqoslash va Omit + & orqali maydonni almashtirish.

24-dars

Intersection orqali composition

Intersection (&) nima ekanini ko'rdik: ikki type'ni bitta qilib birlashtiradi. extends orqali ierarxiya qurdik. Lekin real loyihada type'lar ko'pincha "daraxt" emas, balki lego bo'laklari kabi tuziladi: bitta entity'da id bor, timestamp bor, soft-delete bor; boshqasida faqat id va timestamp.

❌ Ierarxiya bilan har bir kombinatsiya uchun alohida interface kerak bo'ladi:

interface WithId { id: number }
interface WithIdAndTimestamps extends WithId { createdAt: Date; updatedAt: Date }
interface WithIdTimestampsAndDelete extends WithIdAndTimestamps { deletedAt: Date | null }
// Faqat id + delete kerak bo'lsa? Yana bitta interface...

✅ Composition bilan kichik bo'laklar istalgan tartibda yig'iladi:

type WithId = { id: number };
type WithTimestamps = { createdAt: Date; updatedAt: Date };
type SoftDeletable = { deletedAt: Date | null };

type User = WithId & WithTimestamps & { name: string; email: string };
type Post = WithId & WithTimestamps & SoftDeletable & { title: string };
type Tag  = WithId & { label: string };

Har bir bo'lak bitta vazifani bajaradi va uni istalgan joyda qayta ishlatish mumkin. Bu "inheritance o'rniga composition" tamoyilining type darajasidagi ko'rinishi.

Qanday ishlaydi?

1. & — barcha talablarni birga bajarish

Intersection'dagi qiymat har bir qismning talabiga javob berishi kerak:

type Named = { name: string };
type Aged = { age: number };

type Person = Named & Aged;

const p: Person = { name: "Ali", age: 25 }; // ✅
const q: Person = { name: "Ali" };          // ❌ Property 'age' is missing

2. Union type'lar bilan composition — interface qila olmaydigan narsa

interface union type'ni kengaytira olmaydi. Intersection esa bemalol qiladi va har bir variantga taqsimlanadi:

type Success = { ok: true; data: string };
type Failure = { ok: false; error: string };

type ApiResult = (Success | Failure) & { requestId: string };
// = (Success & { requestId: string }) | (Failure & { requestId: string })

function handle(res: ApiResult) {
  res.requestId; // ✅ ikkala variantda ham bor
  if (res.ok) {
    res.data;    // ✅ narrowing ishlaydi
  } else {
    res.error;   // ✅
  }
}

Bu discriminated union'larga umumiy maydon qo'shishning eng qulay usuli.

3. Generic bilan qayta ishlatiladigan "o'ram"lar

Composition generic'lar bilan juda kuchli bo'ladi:

type WithMeta<T> = T & {
  meta: { fetchedAt: Date; source: "cache" | "network" };
};

type Product = { id: number; price: number };

const p: WithMeta<Product> = {
  id: 1,
  price: 50000,
  meta: { fetchedAt: new Date(), source: "network" },
}; // ✅

Istalgan type'ga bir xil qo'shimcha qatlam qo'shiladi — har biri uchun alohida interface yozish shart emas.

4. Runtime composition ham intersection qaytaradi

JavaScript'da obyektlarni birlashtirganda TypeScript natijani intersection deb biladi:

const base = { id: 1 };
const extra = { name: "Ali" };

const merged = Object.assign({}, base, extra);
// type: {} & { id: number } & { name: string }

function compose<A extends object, B extends object>(a: A, b: B): A & B {
  return { ...a, ...b };
}

const user = compose({ id: 1 }, { name: "Ali" });
user.id;   // ✅
user.name; // ✅

5. Ichki obyektlar ham chuqur birlashadi

Bir xil nomli maydon ikkalasida ham obyekt bo'lsa, ular ham intersection bo'ladi:

type A = { settings: { theme: string } };
type B = { settings: { lang: string } };

type C = A & B;
// C["settings"] = { theme: string } & { lang: string }

const c: C = { settings: { theme: "dark", lang: "uz" } }; // ✅

6. extends yoki & — qachon qaysi biri?

Holat Tanlov
Aniq ierarxiya: Admin — bu Userning turi interface extends
Mustaqil bo'laklardan yig'ish &
Union type'ga maydon qo'shish faqat &
Generic o'ram (WithMeta<T>) faqat &
Maydon ziddiyatini darhol ko'rish kerak interface extends
Kutubxona type'ini tashqaridan kengaytirish interface merging

Yana bir amaliy nuqta: juda katta loyihalarda TypeScript interface extendsni intersection'dan biroz tezroq tekshiradi, chunki natijani keshlaydi. Oddiy loyihalarda bu farq sezilmaydi, lekin chuqur ierarxiyalar uchun extends afzalroq.

Eng ko'p uchraydigan xato

& bilan maydonni "almashtirmoqchi" bo'lish. Ko'pchilik intersection'ni spread ({ ...a, ...b }) kabi ishlaydi deb o'ylaydi: keyingisi oldingisini ustidan yozadi. Aslida & hech narsani almashtirmaydi — ikkala talabni bir vaqtda qo'yadi:

type User = { id: number; name: string };

// "id'ni string qilib qo'yaman" degan niyat
type ExternalUser = User & { id: string };   // ⚠️ e'lon paytida xato yo'q

const u: ExternalUser = { id: "abc-123", name: "Ali" };
// ❌ Type 'string' is not assignable to type 'never'.

id bir vaqtda ham number, ham string bo'lishi kerak — bunday qiymat yo'q, shuning uchun never. Xato e'lon qilingan joyda emas, ishlatilgan joyda chiqadi.

Bundan ham yomonrog'i — ziddiyat literal discriminant maydonda bo'lsa, butun type neverga aylanadi:

type Guest = { role: "guest"; name: string };
type AdminGuest = Guest & { role: "admin" };
// AdminGuest = never  — butun type!

const a: AdminGuest = { role: "admin", name: "Ali" };
// ❌ Type '{ role: "admin"; name: string; }' is not assignable to type 'never'.
//    The intersection 'AdminGuest' was reduced to 'never' because property 'role'
//    has conflicting types in some constituents.

Xato xabarining oxirida sabab yozilgan, lekin editor'da type ustiga sichqonchani olib borsangiz, shunchaki never ko'rinadi — name maydoni ham, boshqa hamma narsa ham yo'qolgan.

✅ To'g'ri yechim — avval eski maydonni olib tashlash, keyin yangisini qo'shish:

// Omit bilan
type ExternalUser = Omit<User, "id"> & { id: string };

const u: ExternalUser = { id: "abc-123", name: "Ali" }; // ✅

Bu pattern shu qadar tez-tez kerak bo'ladiki, uni qayta ishlatiladigan utility type qilib olish foydali:

type Override<T, U> = Omit<T, keyof U> & U;

type ExternalUser = Override<User, { id: string }>;        // ✅
type AdminGuest   = Override<Guest, { role: "admin" }>;    // ✅

Esda tuting: & — bu "ham u, ham bu", "bunisi unisining o'rniga" emas. Maydonni almashtirish kerak bo'lsa — Omit + &.