Chapter 6 — Funksiyalar

TypeScript'da funksiyalarni tiplashning ko'plab qirralari bor — parametr turlaridan tortib, funksiya overload'lari va this tipigacha. Bu bob — ularning barchasini keng va chuqur yoritadi.

---

6.1 Parametr va Qaytish Turlari

Example

index.ts
TypeScriptNusxalash
01function add(a: number, b: number): number {
02  return a + b;
03}
04 
05// Arrow function
06const multiply = (a: number, b: number): number => a * b;
07 
08// Funksiya turi (type alias sifatida)
09type MathOperation = (a: number, b: number) => number;
10const subtract: MathOperation = (a, b) => a - b;

6.2 Optional va Default Parametrlar

Example

index.ts
TypeScriptNusxalash
01function greet(name: string, greeting?: string): string {
02  return `${greeting ?? "Salom"}, ${name}!`;
03}
04 
05greet("Abbosbek");                  // "Salom, Abbosbek!"
06greet("Abbosbek", "Xayrli tong");   // "Xayrli tong, Abbosbek!"
07 
08function createUser(name: string, role: string = "user"): object {
09  return { name, role };
10}
11 
12createUser("Vali"); // role — avtomatik "user"

⚠️ Common Mistake
Optional parametrlarni majburiy parametrlardan OLDIN joylashtirish — bu xato beradi:

index.ts
TypeScriptNusxalash
01function invalid(a?: number, b: number) {} // XATO: majburiy parametr ixtiyoriydan keyin kelmasligi kerak

6.3 Rest Parametrlar

Example

index.ts
TypeScriptNusxalash
01function sum(...numbers: number[]): number {
02  return numbers.reduce((total, n) => total + n, 0);
03}
04 
05sum(1, 2, 3, 4); // 10
06 
07function logInfo(message: string, ...details: string[]): void {
08  console.log(message, details.join(", "));
09}

6.4 Function Overloads

Simple Explanation

Function overload — bitta funksiya nomiga, turli parametr kombinatsiyalari uchun bir nechta "imzo" (signature) berish imkonini beradi. Bu funksiya turli argument turlari bilan chaqirilganda, qaytish turi ham mos ravishda o'zgarishi kerak bo'lgan holatlarda foydali.

Example

index.ts
TypeScriptNusxalash
01function getLength(value: string): number;
02function getLength(value: unknown[]): number;
03function getLength(value: string | unknown[]): number {
04  return value.length;
05}
06 
07getLength("salom");        // 5 — string overload
08getLength([1, 2, 3]);      // 3 — array overload
09getLength(42);              // XATO: 42 hech qanday overload'ga mos kelmaydi

💡 Key Idea
Birinchi ikki qator — "overload signatures" (faqat e'lon, implementatsiyasiz). Uchinchi qator — "implementation signature", u ikkalasini ham qamrab oluvchi union type bilan yoziladi va haqiqiy kod mantig'ini o'z ichiga oladi.

📝 Practice Exercises

🟢 Exercise 1 — Easy

Task: Ikki sonni qo'shuvchi, ixtiyoriy uchinchi sonni ham qabul qiladigan (default qiymat bilan) funksiya yozing.

🟡 Exercise 2 — Medium

Task: Istalgan sonli argumentlarni qabul qilib, ularning o'rtachasini hisoblovchi average(...numbers: number[]) funksiyasini yozing.

🔴 Exercise 3 — Hard

Task: parseValue funksiyasi uchun overload'lar yozing: agar string berilsa number qaytarsin (parse qilib), agar number berilsa uni o'zgarishsiz qaytarsin.

🔮 Predict the Output (Type Error)

index.ts
TypeScriptNusxalash
01function createPair(a: number, b?: number) {
02  return [a, b];
03}
04 
05const pair = createPair(5);
06console.log(pair[1].toFixed(2));

🧠 Think first! Bu compile vaqtida xato beradimi?

<details> <summary>Answer</summary> Ha, xato beradi: `Object is possibly 'undefined'`.

Why?
b — optional parametr, uning turi number | undefined. pair[1] — shuning uchun number | undefined turida, va undefinedda .toFixed() metodi mavjud emas. Bu — optional parametrlarning "yashirin" xavfini ko'rsatadi: ular butun kod zanjiri bo'ylab | undefinedni "tarqatadi".

</details>

🐛 Debugging Challenge

index.ts
TypeScriptNusxalash
01function processItems(items: string[], callback: (item: string) => void) {
02  for (const item of items) {
03    callback(item);
04  }
05}
06 
07processItems(["a", "b"], (item: number) => console.log(item));

Your Task: Bu kod nega xato beradi?

<details> <summary>Solution</summary> `callback` parametri — `(item: string) => void` turida kutilmoqda, lekin uzatilgan funksiya `(item: number) => void` turida. TypeScript funksiya turlarini "moslikni" tekshiradi — parametr turlari mos kelmasa, xato beriladi: ``` Argument of type '(item: number) => void' is not assignable to parameter of type '(item: string) => void'. ``` Yechim — callback parametrining turini `string` qilish yoki umuman tur yozmaslik (TypeScript kontekstdan xulosa chiqaradi): ```typescript processItems(["a", "b"], (item) => console.log(item)); // TO'G'RI — 'item' avtomatik 'string' deb xulosa chiqariladi ``` </details>

📌 Chapter Summary

Funksiyalar — parametr va qaytish turlari, optional/default parametrlar, rest parametrlar va overload'lar orqali chuqur tiplanishi mumkin. Contextual typing — TypeScript'ga kontekstdan kelib chiqib parametr turlarini xulosa chiqarish imkonini beradi.

🎯 Key Takeaways

• Optional parametrlar (?) — majburiylardan keyin joylashadi va | undefined qo'shadi
• Default qiymatli parametrlar — berilmaganda standart qiymatni oladi, undefined bo'lmaydi
• Rest parametrlar (...) — cheksiz sondagi bir xil turdagi argumentlar uchun
• Function overload — bir xil nomga, turli aniq signaturalar berish uchun
• Contextual typing — kontekstdan kelib chiqib parametr turlarini avtomatik aniqlaydi

⚡ Quick Cheat Sheet

index.ts
TypeScriptNusxalash
01function f(a: number, b?: string): void {}
02function g(a: number, b: string = "x"): void {}
03function h(...rest: number[]): number { return rest.length; }
04 
05function parse(v: string): number;
06function parse(v: number): number;
07function parse(v: string | number): number { return Number(v); }

---