Series: TypeScript Basics Lesson 11

Literal Types

TypeScript'dagi literal type'lar, literal widening, union bilan qo'llanilishi va as const yechimi.

11-dars

Literal Types

string tipi juda keng: "admin", "salom" va "asdf123" hammasi unga mos keladi. Lekin real kodda ko'p qiymatlar cheklangan to'plamdan keladi: HTTP metodlari ("GET", "POST"), foydalanuvchi rollari, yo'nalishlar, status kodlari va hokazo. Buni string bilan yozsangiz, compiler "GETT" kabi xatoni ham o'tkazib yuboradi va xato faqat runtime'da, ehtimol production'da chiqadi.

Literal type shu muammoni hal qiladi: tip sifatida stringning o'zini emas, aniq bitta qiymatni ko'rsatasiz. Shunda compiler qiymatning kengroq toifasini emas, aynan o'sha qiymatni talab qiladi. Bu API'ni o'z-o'zini hujjatlaydigan qiladi, IDE autocomplete beradi va imloviy xatolarni compile vaqtida ushlaydi.

Literal type'lar bilan keyingi mavzularning ko'pi bog'liq: union type'lar bilan birga ishlatilganda ular eng katta kuchini ko'rsatadi, as const, template literal type'lar va narrowing ham shularga tayanadi.

Qanday ishlaydi?

1. Literal type'ning to'rt turi

string, number, boolean va bigint (primitive'lar) uchun literal tip yozish mumkin:

let greeting: "salom" = "salom";   // ✅
greeting = "salom";                // ✅ faqat shu qiymat mumkin
greeting = "assalomu alaykum";     // ❌ Type '"assalomu alaykum"' is not assignable to type '"salom"'

let port: 3000 = 3000;             // ✅ number literal
let offset: -1 = -1;               // ✅ manfiy son ham literal bo'ladi
let big: 100n = 100n;              // ✅ bigint literal

let flag: true = true;             // ✅ boolean literal
flag = false;                      // ❌ Type 'false' is not assignable to type 'true'

E'tibor bering: boolean aslida true | false union'ining qisqa nomi, ya'ni u ham ikkita literal'dan iborat.

2. const va let farqi: inference qanday ishlaydi

const method = "GET";   // tip: "GET"    ← const o'zgarmaydi, shuning uchun aniq literal
let method2 = "GET";    // tip: string    ← let o'zgarishi mumkin, shuning uchun kengayadi (widening)

const qayta yozilmasligi kafolatlangan, shuning uchun TS eng aniq tipni beradi. letda esa qiymat keyin o'zgarishi mumkin, shuning uchun TS tipni stringgacha kengaytiradi. Bu literal widening deb ataladi va quyidagi eng ko'p uchraydigan xatoning ildizi.

3. Union bilan birga: amaliy qo'llanilishi

Bitta literal alohida kamdan-kam foydali. Haqiqiy kuch bir nechta literal'ni | bilan birlashtirganda paydo bo'ladi (union type'lar alohida mavzuda batafsil ko'riladi):

type Direction = "up" | "down" | "left" | "right";
type DiceRoll = 1 | 2 | 3 | 4 | 5 | 6;

function move(dir: Direction, steps: 1 | 2 | 3): void {
  console.log(`${dir} tomonga ${steps} qadam`);
}

move("up", 2);      // ✅
move("upp", 2);     // ❌ Argument of type '"upp"' is not assignable to parameter of type 'Direction'
move("left", 5);    // ❌ 5 — 1 | 2 | 3 ichida yo'q

4. Literal — primitive'ning subtype'i

const a: "GET" = "GET";
const b: string = a;      // ✅ "GET" har doim string'ga mos keladi (torroq → kengroq)

declare const s: string;
const c: "GET" = s;       // ❌ string har doim ham "GET" emas (kengroq → torroq)

Yo'nalish shunday: literal → primitive mumkin, primitive → literal mumkin emas. Bunga never ham bog'liq: ikkita mos kelmaydigan literal kesishmasi bo'sh to'plam beradi:

type Impossible = "a" & "b";   // tip: never ← bunday qiymat mavjud emas

5. Runtime'da literal type yo'q

Tiplar compile vaqtida o'chib ketadi (type erasure), V8 ularni ko'rmaydi. Shuning uchun tashqaridan kelgan ma'lumotni (JSON.parse, fetch javobi, form input) literal tipga TS o'zi kafolatlay olmaydi:

type Method = "GET" | "POST";

const raw = JSON.parse('{"method":"DELETE"}');   // tip: any
const m: Method = raw.method;                      // ✅ compile bo'ladi, lekin runtime'da "DELETE"!

Bunday ma'lumotni unknown sifatida qabul qilib, runtime'da tekshirib, keyin literal tipga o'tkazish to'g'ri yo'l. Buning uchun type guard'lar kerak bo'ladi, ular keyingi mavzularda ko'riladi.

Eng ko'p uchraydigan xato

Object ichidagi literal'ning stringga kengayib ketishi.

type Method = "GET" | "POST";

function request(url: string, method: Method): void {
  // ...
}

const req = { url: "/api/users", method: "GET" };

request(req.url, req.method);
// ❌ Argument of type 'string' is not assignable to parameter of type 'Method'

Dasturchi "men "GET" yozdim-ku, nega string deydi?" deb hayron bo'ladi. Sabab: const req o'zgaruvchining o'zi o'zgarmas, lekin object'ning property'lari o'zgaruvchan. Ya'ni keyin req.method = "POST" yoki req.method = "salom" deyish mumkin. Shuning uchun TS methodni stringga kengaytiradi (yuqoridagi let holati bilan bir xil mantiq).

To'g'ri yechimlar:

// ✅ 1-yechim (tavsiya): as const — butun object readonly va aniq literal bo'ladi
const req1 = { url: "/api/users", method: "GET" } as const;
// tip: { readonly url: "/api/users"; readonly method: "GET" }
request(req1.url, req1.method);   // ✅

// ✅ 2-yechim: aniq annotation
const req2: { url: string; method: Method } = { url: "/api/users", method: "GET" };
request(req2.url, req2.method);   // ✅

// ✅ 3-yechim: faqat kerakli property'ga as const
const req3 = { url: "/api/users", method: "GET" as const };
request(req3.url, req3.method);   // ✅

Yana bir xavfli "yechim" — as Method bilan majburlash:

declare const userInput: string;

request("/api", userInput as Method);   // ⚠️ compile bo'ladi, lekin xavfsizlik yo'q

Bu compiler'ni jim qiladi, lekin userInput aslida "DELETE" bo'lsa ham hech kim ogohlantirmaydi. as faqat siz qiymatning to'g'riligiga haqiqatan ishonch hosil qilgan joyda ishlatilishi kerak.