Seriya: TypeScript Basics Dars 55

typeof type operator

TypeScript'da typeof type operatori: qiymatdan type olish, runtime typeof bilan farqi, literal kengayishi va as const, keyof typeof, massivdan union, funksiya type'i va as const unutilgan konstanta obyekt xatosi.

55-dars

typeof type operator

Ko'pincha avval qiymat yoziladi: konfiguratsiya obyekti, standart sozlamalar, konstantalar ro'yxati. Keyin xuddi shu shakl uchun type kerak bo'ladi. Uni qo'lda takrorlash vaqt o'tishi bilan qiymatdan ajralib qoladi:

// ❌ Qiymat va type alohida yozilgan
const STANDART_SOZLAMALAR = {
  mavzu: "yorug'",
  til: "uz",
  sahifaHajmi: 20,
  bildirishnomalar: true,
};

type Sozlamalar = {
  mavzu: string;
  til: string;
  sahifaHajmi: number;
  // bildirishnomalar unutilgan 🐛 — TS eslatmaydi
};

typeof type operatori qiymatdan uning type'ini oladi. Type qiymat bilan doim mos bo'lib qoladi:

// ✅ Type qiymatdan avtomatik olinadi
const STANDART_SOZLAMALAR = {
  mavzu: "yorug'",
  til: "uz",
  sahifaHajmi: 20,
  bildirishnomalar: true,
};

type Sozlamalar = typeof STANDART_SOZLAMALAR;
// { mavzu: string; til: string; sahifaHajmi: number; bildirishnomalar: boolean }

function saqla(s: Sozlamalar) { /* ... */ }
saqla({ mavzu: "qorong'i", til: "ru", sahifaHajmi: 50 });
// ❌ Property 'bildirishnomalar' is missing in type '{ mavzu: string; til: string; sahifaHajmi: number; }' but required in type '{ mavzu: string; til: string; sahifaHajmi: number; bildirishnomalar: boolean; }'.

Qanday ishlaydi?

1. Ikki xil typeof — qayerda yozilganiga qarab

So'z bir xil, lekin vazifasi butunlay boshqa:

const narx = 85_000;

// Runtime typeof — kod ichida, string qaytaradi
if (typeof narx === "number") { /* ... */ }

// Type typeof — type pozitsiyasida, type qaytaradi
type Narx = typeof narx; // number
Runtime typeof Type typeof
Qayerda ifodalarda (if, const x = ...) type yoziladigan joyda (type X = ..., : ...)
Natija "string", "number", "object"... to'liq TS type'i
Obyekt uchun "object" { mavzu: string; ... }
JS'ga kompilyatsiya qilinganda qoladi o'chib ketadi

2. Natija o'zgaruvchi qanday e'lon qilinganiga bog'liq

typeof TS chiqargan type'ni oladi. const primitive uchun literal type, obyekt maydonlari uchun esa kengaytirilgan type chiqariladi. Chunki maydonlarni keyin o'zgartirish mumkin:

const til = "uz";
let til2 = "uz";
const obj = { til: "uz" };

type A = typeof til;  // "uz"   — const, o'zgarmaydi
type B = typeof til2; // string — let, o'zgarishi mumkin
type C = typeof obj;  // { til: string } — maydon o'zgarishi mumkin

Literal'larni saqlash kerak bo'lsa, as const ishlatiladi. U "bu qiymatni o'zgarmas, aniq literal sifatida ol" deydi:

const obj2 = { til: "uz", versiya: 2 } as const;
type D = typeof obj2; // { readonly til: "uz"; readonly versiya: 2 }

3. keyof typeof — obyekt qiymatining kalitlari

keyof faqat type bilan ishlashini ko'rgan edik. Qiymatning kalitlari kerak bo'lsa, ikkalasi birga yoziladi:

const XABARLAR = {
  saqlandi: "Muvaffaqiyatli saqlandi",
  ochirildi: "O'chirildi",
  xato: "Xatolik yuz berdi",
};

type XabarKaliti = keyof typeof XABARLAR; // "saqlandi" | "ochirildi" | "xato"

function korsat(k: XabarKaliti) {
  alert(XABARLAR[k]); // ✅
}

korsat("saqlandi"); // ✅
korsat("yuklandi");
// ❌ Argument of type '"yuklandi"' is not assignable to parameter of type '"saqlandi" | "ochirildi" | "xato"'.

O'qish tartibi o'ngdan chapga: avval typeof XABARLAR (qiymat → type), keyin keyof (type → kalitlar).

4. Massivdan union — "yagona manba"

Rollar uchun ham type, ham massiv yozgan edik (44-dars). Ular bir-biridan ajralib qolishi mumkin edi. as const + typeof bilan type massivdan olinadi:

const ROLLAR = ["admin", "muharrir", "oquvchi"] as const;
// readonly ["admin", "muharrir", "oquvchi"]

type Rol = (typeof ROLLAR)[number]; // "admin" | "muharrir" | "oquvchi"

[number] — "istalgan indeksdagi element type'i". Bu indexed access type. Endi yangi rol faqat massivga qo'shiladi, Rol type'i avtomatik yangilanadi.

5. Funksiyaning type'i

typeof funksiyaning to'liq imzosini ham oladi:

function narxHisobla(summa: number, chegirma: number): number {
  return summa * (1 - chegirma / 100);
}

type Hisoblovchi = typeof narxHisobla; // (summa: number, chegirma: number) => number

const testUchun: Hisoblovchi = (s, c) => s - c; // ✅ parametr type'lari avtomatik

typeof faqat nomga (o'zgaruvchi, funksiya, obj.maydon) qo'llanadi, chaqiruvga emas. Funksiya qaytaradigan type kerak bo'lsa, ReturnType<typeof narxHisobla> yoziladi.

Eng ko'p uchraydigan xato

"Enum o'rnini bosuvchi" obyektdan type olish — as const unutilgan. Holatlarni bir joyda saqlash uchun konstanta obyekt yaratiladi va type undan olinadi:

const HOLAT = {
  YANGI: "yangi",
  TOLANGAN: "tolangan",
  YUBORILDI: "yuborildi",
};

type Holat = (typeof HOLAT)[keyof typeof HOLAT];
// Kutilgan: "yangi" | "tolangan" | "yuborildi"
// Aslida:   string 🐛

function holatniOrnat(h: Holat) { /* ... */ }

holatniOrnat(HOLAT.TOLANGAN); // ✅
holatniOrnat("tolangn");      // ✅ TS indamaydi — xato yozilgan holat bazaga ketdi

Bu yerda TS hech qanday xato bermaydi. Muammo boshqa joyda paydo bo'ladi: assertNever bilan switch yozilganda Argument of type 'string' is not assignable to parameter of type 'never' chiqadi va sababi tushunarsiz bo'ladi.

Nega bunday bo'ladi? 2-bo'limdagi qoida: obyekt maydonlarini keyin o'zgartirish mumkin (HOLAT.YANGI = "boshqa"). Shuning uchun TS "yangi"'ni literal emas, string deb chiqaradi. typeof HOLAT = { YANGI: string; TOLANGAN: string; YUBORILDI: string }. Undan olingan union ham shunchaki string | string | string = string. Type xavfsiz ko'rinadi, aslida esa har qanday matnni qabul qiladi.

✅ Yechim: obyektga as const qo'shing

const HOLAT = {
  YANGI: "yangi",
  TOLANGAN: "tolangan",
  YUBORILDI: "yuborildi",
} as const;

type Holat = (typeof HOLAT)[keyof typeof HOLAT];
// "yangi" | "tolangan" | "yuborildi" ✅

holatniOrnat("tolangn");
// ❌ Argument of type '"tolangn"' is not assignable to parameter of type '"yangi" | "tolangan" | "yuborildi"'.

HOLAT.YANGI = "boshqa";
// ❌ Cannot assign to 'YANGI' because it is a read-only property.

as const ikki narsa beradi: literal type'lar saqlanadi va obyektni tasodifan o'zgartirib bo'lmaydi. Tekshirish oson: Holat ustiga kursorni olib boring. string ko'rinsa, as const yetishmayapti.

Esda tuting: typeof qiymatdan TS chiqargan type'ni oladi, obyekt maydonlari esa string'ga kengayadi, shuning uchun type sifatida ishlatiladigan konstanta obyekt va massivlarga as const qo'shing.