Type Aliases
TypeScript'dagi type alias'lar, structural typing, rekursiv va generic alias'lar, branded type'lar haqida.
14-dars
Type Aliases
Oldingi mavzularda tiplarni bevosita yozdik: "GET" | "POST", User & Timestamps. Bunday ifodalar bir marta yozilsa yaxshi, lekin bir nechta joyda takrorlansa muammo boshlanadi. Tip o'zgarganda hamma nusxani qidirib topish kerak, bittasini unutsangiz kod jimgina tarqalib ketadi. Uzun tipni o'qish ham qiyinlashadi: (string | number)[] | Map<string, User | null> ma'nosini yashirib turadi.
Type alias shu muammoni hal qiladi: istalgan tipga nom beradi. Bir joyda e'lon qilasiz, hamma joyda nomi bilan ishlatasiz, o'zgartirish ham bir joyda bo'ladi. Nom esa kodni hujjatlashtiradi: type UserId = string o'qiyotgan odamga stringning nima uchun ishlatilayotganini aytadi.
Bu mavzu keyingi ko'p narsaning poydevori. Obyekt tiplari, type va interface farqi, generic alias'lar, mapped va conditional type'lar hammasi type sintaksisi ustiga quriladi.
Qanday ishlaydi?
1. Sintaksis: type Nom = Tip
Alias'ga istalgan tip berish mumkin, faqat obyekt tiplari bilan cheklanmagan:
type ID = string | number; // union
type Method = "GET" | "POST" | "PUT" | "DELETE"; // literal union
type Point = { x: number; y: number }; // obyekt tipi
type Pair = [string, number]; // tuple
type Handler = (event: Event) => void; // funksiya tipi
type UserRecord = User & Timestamps; // intersection
type Names = string[]; // massiv
2. Alias yangi tip yaratmaydi, u faqat nom
TS tiplarni strukturasi bo'yicha solishtiradi (structural typing). Alias esa strukturaga hech narsa qo'shmaydi, shuning uchun alias va uning asl tipi to'liq almashinadi:
type Meters = number;
const distance: Meters = 100;
const plain: number = distance; // ✅ Meters aynan number
const back: Meters = plain; // ✅ teskarisi ham ishlaydi
type A = { id: number };
type B = { id: number };
declare const a: A;
const b: B = a; // ✅ nomlari boshqa, lekin strukturasi bir xil
3. Alias faqat compile vaqtida mavjud
Tiplar runtime'da o'chib ketadi (type erasure). Alias tayyor JS'da hech qanday iz qoldirmaydi va V8 uni ko'rmaydi. Shuning uchun alias'ni qiymat sifatida ishlatib bo'lmaydi:
type User = { name: string };
const u = User;
// ❌ 'User' only refers to a type, but is being used as a value here.
console.log(typeof User); // ❌ xuddi shu xato
TS'da tip va qiymat alohida nomlar maydonida yashaydi. Shu sababli bir xil nomli type va const birga turishi mumkin, va bu keng tarqalgan pattern:
const Status = { Idle: "idle", Loading: "loading" } as const; // qiymat
type Status = typeof Status[keyof typeof Status]; // tip: "idle" | "loading"
// ✅ ikkalasi ham "Status" nomi bilan, lekin turli maydonlarda
typeof tip operatori, keyof, indexed access ko'riladi. Hozircha shuni bilib qo'ying: alias mavjud qiymatning tipidan ham "olinishi" mumkin.
4. Rekursiv alias
Alias o'ziga murojaat qilishi mumkin, agar bu murojaat obyekt, massiv yoki tuple ichida bo'lsa:
type TreeNode = {
value: number;
children: TreeNode[]; // ✅ obyekt ichida o'ziga murojaat
};
type Json =
| string
| number
| boolean
| null
| Json[]
| { [key: string]: Json }; // ✅ JSON'ning to'liq tavsifi
type Bad = Bad;
// ❌ Type alias 'Bad' circularly references itself.
5. Generic alias
Alias parametr qabul qilib, "tip funksiyasi"ga aylanishi mumkin:
type Nullable<T> = T | null;
type ApiResult<T> = { data: T; error: null } | { data: null; error: string };
const name: Nullable<string> = null; // ✅
const res: ApiResult<User[]> = { data: [], error: null }; // ✅
6. Scope va eksport
Alias oddiy o'zgaruvchi kabi scope'ga ega. Uni funksiya ichida ham e'lon qilish mumkin, modullararo ishlatish uchun esa eksport qilinadi:
export type UserId = string; // modul darajasida
function process() {
type Temp = { raw: string }; // ✅ faqat shu funksiya ichida ko'rinadi
const t: Temp = { raw: "x" };
}
type Temp2 = string;
type Temp2 = number;
// ❌ Duplicate identifier 'Temp2'.
Oxirgi qatorga e'tibor bering: type qayta e'lon qilinmaydi, interface esa qayta e'lon qilinsa birlashadi (declaration merging).
Eng ko'p uchraydigan xato
Alias'ni "alohida tip" deb o'ylash. Dasturchi type UserId = number va type OrderId = number yozib, endi ularni aralashtirib bo'lmaydi deb hisoblaydi:
type UserId = number;
type OrderId = number;
function getUser(id: UserId): void {
console.log(`user ${id} yuklanmoqda`);
}
const orderId: OrderId = 9001;
getUser(orderId); // ⚠️ compile bo'ladi! Hech qanday xato yo'q
Buning sababi: alias faqat nom, UserId ham, OrderId ham baribir number. Compiler ularni bir xil deb biladi. Natijada buyurtma ID'si foydalanuvchi qidiruviga tushib ketadi, xato hech qayerda ko'rinmaydi va faqat noto'g'ri ma'lumot qaytganda seziladi.
Yana bir xavfli holat: type Str = string kabi "shunchaki qisqa nom" berish. U hech narsani himoya qilmaydi, faqat o'qishni qiyinlashtiradi. Alias'ning qiymati ma'no berishda, tekshiruv esa alohida narsa.
To'g'ri yechim: branded type. Alias'ni strukturasi bo'yicha farqlanadigan qilish uchun intersection bilan "belgi" qo'shiladi:
type UserId = number & { readonly __brand: "UserId" };
type OrderId = number & { readonly __brand: "OrderId" };
// Yagona joy, qiymatga brend beriladi. Aynan shu yerda as ishlatish oqlanadi
const toUserId = (n: number) => n as UserId;
const toOrderId = (n: number) => n as OrderId;
function getUser(id: UserId): void {
console.log(`user ${id} yuklanmoqda`);
}
const userId = toUserId(42);
const orderId = toOrderId(9001);
getUser(userId); // ✅
getUser(orderId); // ❌ Type 'OrderId' is not assignable to type 'UserId'.
getUser(42); // ❌ Type 'number' is not assignable to type 'UserId'.
__brand faqat compile vaqtidagi belgi, runtime'da bu property yo'q, qiymat oddiy number bo'lib qoladi. Shu sababli ortiqcha xotira yoki tezlik xarajati yo'q.
Xulosa: alias nom beradi, lekin tip identifikatsiyasini o'zgartirmaydi.
Xato xabarlarida alias'ning "yo'qolib qolishi":
type Score = number;
function record(s: Score) {}
record("100");
// ❌ Argument of type 'string' is not assignable to parameter of type 'number'.
Xabarda Score emas, number chiqadi, chunki primitive alias'lar hover va xatolarda ko'pincha ochilib ketadi. Alias'lar obyekt va union tiplarda nom sifatida ko'rinishga ko'proq moyil. Shuning uchun primitive alias'ni "tip xavfsizligi" uchun emas, faqat hujjat sifatida qarang.