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 + &.