Seriya: TypeScript Basics Dars 14

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.