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