Seriya: TypeScript Basics Dars 20

Type Aliases vs Interfaces

TypeScript'da type va interface farqi: declaration merging, extends vs intersection va qaysi birini tanlash.

20-dars

Type Aliases vs Interfaces

Obyekt shaklini tavsiflash uchun TS'da ikkita vosita bor: type va interface. Shu paytgacha ko'p misol type bilan yozildi. Bu interface yomon degani emas, shunchaki bir tanlov edi. Ko'p holatda ikkalasi bir xil ishlaydi, shuning uchun dasturchilar "qaysi birini yozsam bo'ladi?" deb adashadi. Lekin farqlar bor: birida declaration merging bor, ikkinchisida union, tuple va mapped type'lar bor. Noto'g'ri tanlov jimgina birlashib ketgan tiplarga, kutilmagan neverlarga yoki tushunarsiz xato xabarlariga olib keladi.

Qanday ishlaydi?

1. Sintaksis va asosiy o'xshashlik

type UserT = { id: number; name: string };      // "=" bor, oxirida ";" ixtiyoriy
interface UserI { id: number; name: string }    // "=" yo'q

const a: UserT = { id: 1, name: "Ali" };        // ✅
const b: UserI = a;                             // ✅ structural typing: nomi emas, shakli muhim

Obyekt shaklini tavsiflash uchun ikkalasi ham optional, readonly, index signature va ichma-ich tiplarni qo'llaydi. Funksiya tipini ham yozish mumkin:

type Fn1 = (x: number) => string;
interface Fn2 { (x: number): string }          // ✅ call signature

2. Faqat type qila oladigan narsalar

interface faqat obyekt shaklini (yoki call/constructor signature'ni) tavsiflaydi. Boshqa hamma narsa uchun type kerak:

type ID = string | number;                          // ✅ union
type Pair = [string, number];                       // ✅ tuple
type Method = "GET" | "POST";                       // ✅ literal union
type Keys = keyof UserT;                            // ✅ keyof
type Flags = { [K in "a" | "b"]: boolean };         // ✅ mapped type

interface ID2 = string | number;                    // ❌ sintaksis xato: interface faqat obyekt shaklini tavsiflaydi

Conditional type'lar va template literal type'lar ham faqat type bilan yoziladi.

3. Declaration merging: faqat interfaceda

Bir xil nomli interface qayta e'lon qilinsa, TS ularni birlashtiradi. type esa xato beradi:

interface Config { host: string }
interface Config { port: number }

const c: Config = { host: "localhost", port: 3000 };   // ✅ Config = { host, port }

type T = { a: number };
type T = { b: string };
// ❌ Duplicate identifier 'T'.

Bu xususiyat kutubxona tiplarini kengaytirish uchun ataylab yaratilgan.

4. Kengaytirish: extends va &

interface Animal { name: string }
interface Dog extends Animal { bark(): void }     // ✅

type Animal2 = { name: string };
type Dog2 = Animal2 & { bark(): void };           // ✅ intersection

Ko'rinishda bir xil, lekin ikki farq bor. Birinchisi, to'qnashuv paytida xatti-harakat:

interface A { id: string }
interface B extends A { id: number }
// ❌ Interface 'B' incorrectly extends interface 'A'.  ← xato e'lon qilingan joyning o'zida

type C = { id: string } & { id: number };            // ⚠️ e'lon paytida xato yo'q
declare const c: C;
c.id;                                                // tip: never — xato ishlatilganda chiqadi

extends kelishmovchilikni erta ushlaydi. & esa uni neverga aylantirib yashiradi.

Ikkinchisi, interface union tipni kengaytira olmaydi:

type Shape = { kind: "circle" } | { kind: "rect" };

interface Bad extends Shape {}
// ❌ An interface can only extend an object type or intersection of object types with statically known members.

type Ok = Shape & { id: number };                    // ✅ type & union bilan ishlaydi

5. Class bilan: ikkalasi ham implements ga mos

interface Serializable { serialize(): string }
type Printable = { print(): void };

class Doc implements Serializable, Printable {   // ✅ obyekt shaklidagi type ham bo'ladi
  serialize() { return "{}"; }
  print() { console.log("doc"); }
}

Farqi shuki, union tipga implements ishlamaydi.

6. Runtime'da ikkalasi ham yo'q

Ikkalasi ham compile vaqtida o'chadi (type erasure). Tayyor JS'da interface uchun bitta qator ham chiqmaydi, shuning uchun uni qiymat sifatida ishlatib bo'lmaydi. Tanlov bundle hajmiga yoki tezligiga ta'sir qilmaydi, faqat compiler va sizning kodingizga ta'sir qiladi.

7. Yashirin index signature: kam ma'lum, lekin amaliy farq

type T = { a: number };
interface I { a: number }

const t: T = { a: 1 };
const i: I = { a: 1 };

const r1: Record<string, unknown> = t;   // ✅ type alias'ning yashirin index signature'i bor
const r2: Record<string, unknown> = i;   // ❌ Index signature for type 'string' is missing in type 'I'.

8. Qaysi birini tanlash

  • Union, tuple, primitive alias, mapped/conditional type kerak bo'lsa: type (majburiy).
  • Kutubxona tipini kengaytirish (Window, Express Request) yoki ataylab merging kerak bo'lsa: interface.
  • Oddiy obyekt shakli, class kontrakti: ikkalasi ham to'g'ri. Rasmiy Handbook "avval interface, type imkoniyati kerak bo'lganda unga o'ting" degan yo'nalish beradi. Ko'p jamoalar esa hamma narsa uchun type ishlatadi.
  • Katta kodbazada interface extends odatda intersectiondan tezroq tekshiriladi (TS'ning rasmiy performance tavsiyalaridan biri). Kichik loyihada bu sezilmaydi.

Asosiy qoida: jamoada bitta konventsiya tanlang va unga rioya qiling. Aralash ishlatish uslub farqidan ko'ra xavfliroq, chunki tasodifiy merging va yashirin index signature farqi aynan aralashganda chiqib qoladi.

Eng ko'p uchraydigan xato

interface nomi boshqa joydagi bir xil nom bilan jimgina birlashib ketishi. Ayniqsa import/export bo'lmagan fayllarda (TS ularni script, ya'ni global scope deb hisoblaydi) yoki DOM tiplari bilan bir xil nom tanlaganda shunday bo'ladi:

// models/user.ts   ← import/export yo'q → global scope
interface User { id: number; name: string }

// admin/user.ts    ← import/export yo'q → global scope
interface User { role: "admin" | "root" }   // ⚠️ xato yo'q, ikkalasi bitta User'ga birlashdi

// app.ts
const u: User = { id: 1, name: "Ali" };
// ❌ Property 'role' is missing in type '{ id: number; name: string; }' but required in type 'User'.

Xato app.ts da chiqadi, lekin sababi butunlay boshqa faylda. Compiler User ikki joyda e'lon qilinganini aytmaydi, chunki bu xato emas, merging xususiyati. Xuddi shunday, lib.dom yoqilgan bo'lsa (lib sozlamasi):

interface Event { title: string; date: Date }   // ⚠️ brauzerning DOM Event tipi bilan birlashdi!

const e: Event = new Event("click");
// ❌ Property 'title' is missing in type 'Event' — kutilmagan joyda xato chiqadi

To'g'ri yechimlar:

// ✅ 1-yechim: faylni modulga aylantiring, e'lonlar shu faylga xos bo'ladi
export interface User { id: number; name: string }
// yoki e'lon eksport qilinmasa ham: fayl oxirida  export {};

// ✅ 2-yechim: birlashish kerak bo'lmasa, type ishlating — takroriy nom darhol xato beradi
type Product = { id: number; title: string };
type Product = { sku: string };
// ❌ Duplicate identifier 'Product'.

// ✅ 3-yechim: domenga xos nom bering, DOM va global nomlar bilan to'qnashmaydi
interface CalendarEvent { title: string; date: Date }   // Event emas

Modul faylda e'lon qilingan interface faqat shu modul ichida birlashadi. Boshqa modulning User tipi bilan to'qnashmaydi. Hozirgi loyihalarda deyarli barcha fayl import/export ishlatadi, shuning uchun bu xato asosan eski loyihalarda, .d.ts fayllarda va tez yozilgan skriptlarda uchraydi.