Chapter 2 — Tip Xulosa Chiqarish va Annotatsiyalar

TypeScript har doim ham tip yozishni talab qilmaydi — u ko'p hollarda tipni o'zi "xulosa chiqaradi" (infer qiladi). Bu bob — qachon annotatsiya yozish, qachon xulosaga ishonish kerakligini chuqur yoritadi.

---

2.1 Type Inference Nima?

Simple Explanation

TypeScript compiler — o'zgaruvchiga berilgan boshlang'ich qiymatdan uning turini avtomatik aniqlaydi, bu "type inference" (tip xulosasi) deb ataladi.

Example

index.ts
TypeScriptNusxalash
01let name = "Abbosbek";  // TypeScript avtomatik: string deb "biladi"
02let age = 26;             // number
03let isActive = true;      // boolean
04 
05name = 42; // XATO: TypeScript name'ni string deb "eslab qolgan"

Nima uchun bu muhim?

Garchi : string yozilmagan bo'lsa ham, TypeScript namening turi haqida to'liq ma'lumotga ega — u faqat "ko'rinmas" annotatsiya, lekin baribir amal qiladi.

2.2 Qachon Annotatsiya Yozish Kerak?

Simple Explanation

Annotatsiya (: Type) — TypeScript xulosa chiqara olmaydigan yoki xulosasi yetarli aniq bo'lmagan holatlarda zarur bo'ladi: funksiya parametrlari, bo'sh massiv/obyektlar, va kelajakda qiymat beriladigan o'zgaruvchilar.

Example

index.ts
TypeScriptNusxalash
01// Funksiya parametrlari — HAR DOIM annotatsiya kerak (TS ularni xulosa chiqara olmaydi)
02function greet(name: string) {
03  return `Salom, ${name}`;
04}
05 
06// Bo'sh massiv — annotatsiyasiz "any[]" bo'lib qoladi
07let items: string[] = [];
08 
09// Kelajakda qiymat beriladigan o'zgaruvchi
10let result: number;
11result = calculateSomething();

⚠️ Common Mistake
Funksiya parametrlariga tip yozmaslik — ular avtomatik any bo'lib qoladi (agar noImplicitAny yoqilmagan bo'lsa), bu esa TypeScript'ning butun foydasini yo'qqa chiqaradi.

2.3 Return Type Annotation

Simple Explanation

Funksiyaning qaytish turini (: ReturnType) yozish ixtiyoriy (TypeScript uni funksiya tanasidan xulosa chiqaradi), lekin bu murakkab funksiyalarda kod niyatini aniq qilish va xatolarni erta aniqlash uchun juda foydali.

Example

index.ts
TypeScriptNusxalash
01// Annotatsiyasiz — TypeScript xulosa chiqaradi: number
02function add(a: number, b: number) {
03  return a + b;
04}
05 
06// Annotatsiya bilan — aniq, va agar tana noto'g'ri tur qaytarsa, XATO beradi
07function multiply(a: number, b: number): number {
08  return a * b;
09}
10 
11function processUser(user: { name: string }): string {
12  if (!user.name) {
13    return; // XATO: bu funksiya 'string' qaytarishi kerak, lekin 'undefined' qaytarilmoqda
14  }
15  return user.name;
16}

💡 Key Idea
Return type annotation — funksiya "shartnomasi" (contract) sifatida ishlaydi. U funksiya ichida qanday xato qilinganini erta ushlab qolishga yordam beradi, ayniqsa uzun yoki murakkab funksiyalarda.

2.4 const va Literal Type Inference

Simple Explanation

let bilan e'lon qilingan o'zgaruvchi uchun TypeScript kengroq tur (masalan string) xulosa chiqaradi, chunki qiymat keyinroq o'zgarishi mumkin. const bilan esa, qiymat o'zgarmasligi aniq bo'lgani uchun, TypeScript ko'pincha aniqroq "literal type" xulosa chiqaradi.

Example

index.ts
TypeScriptNusxalash
01let status1 = "active";        // tur: string (keng)
02const status2 = "active";      // tur: "active" (aniq literal type!)
03 
04function setStatus(status: "active" | "inactive") {}
05 
06setStatus(status1); // XATO: 'string' 'active' | 'inactive'ga mos kelmaydi
07setStatus(status2); // TO'G'RI: '"active"' — mos literal type

📝 Practice Exercises

🟢 Exercise 1 — Easy

Task: Annotatsiyasiz uchta o'zgaruvchi (string, number, boolean turlarida) yarating va TypeScript ularning turini to'g'ri xulosa chiqarganini tekshiring (IDE orqali hover qiling).

🟡 Exercise 2 — Medium

Task: Ikkita sonni qo'shuvchi funksiya yozing, parametr va return type annotatsiyalarini aniq belgilang.

🔮 Predict the Output (Type Error)

index.ts
TypeScriptNusxalash
01let colors = ["red", "green", "blue"];
02colors.push(42);

🧠 Think first! Bu compile vaqtida xato beradimi?

<details> <summary>Answer</summary> Ha, xato beradi: `Argument of type 'number' is not assignable to parameter of type 'string'`.

Why?
colors massivi ["red", "green", "blue"] boshlang'ich qiymatidan string[] deb xulosa chiqarilgan. 42 (number) qo'shishga urinish — bu xulosa chiqarilgan turga zid.

</details>

🐛 Debugging Challenge

index.ts
TypeScriptNusxalash
01function getUserName(id: number) {
02  if (id === 0) {
03    return null;
04  }
05  return "Abbosbek";
06}
07 
08const name = getUserName(1);
09console.log(name.toUpperCase());

Your Task: Bu kod compile vaqtida xato beradimi (strict rejimida)? Nega?

<details> <summary>Solution</summary> Ha. `getUserName` funksiyasining xulosa chiqarilgan qaytish turi — `string | null` (chunki u ham `null`, ham `string` qaytaradi). `name.toUpperCase()` chaqirilganda, TypeScript "agar `name` `null` bo'lsa, `toUpperCase` mavjud emas" deb xato beradi. Yechim — tekshiruv qo'shish: ```typescript if (name !== null) { console.log(name.toUpperCase()); } ``` </details>

📌 Chapter Summary

TypeScript — boshlang'ich qiymatdan tur xulosa chiqaradi (type inference), lekin funksiya parametrlari uchun annotatsiya har doim kerak. const — ko'pincha aniqroq literal type beradi. Return type annotatsiyasi — ixtiyoriy, lekin funksiya "kontraktini" aniq qiladi.

🎯 Key Takeaways

• TypeScript boshlang'ich qiymatdan turni avtomatik aniqlaydi
• Funksiya parametrlari — har doim aniq annotatsiya talab qiladi
• const — ko'pincha letga qaraganda aniqroq (literal) tur beradi
• Return type annotatsiyasi — funksiya "kontraktini" mustahkamlaydi

⚡ Quick Cheat Sheet

index.ts
TypeScriptNusxalash
01let x = 5;                    // inferred: number
02function f(a: number): number { return a; }  // parametrlar — majburiy annotatsiya
03const y = "fixed";             // inferred: "fixed" (literal)
04let arr: string[] = [];        // bo'sh massiv — annotatsiya kerak

---