Seriya: TypeScript Basics Dars 27

Optional parameter

TypeScript'da ixtiyoriy parametrlar: ? belgisi, T | undefined, parametrlar tartibi, x?: T va x: T | undefined farqi, optional yoki default va || o'rniga ?? ishlatish.

27-dars

Optional parameter

TypeScript argumentlar sonini qat'iy tekshiradi. Lekin real hayotda ko'p funksiyalarning ba'zi parametrlari ixtiyoriy bo'ladi: sahifalash funksiyasida limit, log funksiyasida level, formatlashda locale.

❌ Hamma parametr majburiy bo'lsa:

function formatPrice(amount: number, currency: string) {
  return `${amount.toLocaleString()} ${currency}`;
}

formatPrice(50000);         // ❌ Expected 2 arguments, but got 1.
formatPrice(50000, "so'm"); // har safar "so'm" yozishga majbur

Chaqiruvchi har safar bir xil qiymatni takrorlaydi yoki undefined yozib yuboradi.

✅ Optional parameter bilan:

function formatPrice(amount: number, currency?: string) {
  return `${amount.toLocaleString()} ${currency ?? "so'm"}`;
}

formatPrice(50000);        // ✅ "50,000 so'm"
formatPrice(50000, "USD"); // ✅ "50,000 USD"

? belgisi TypeScript'ga aytadi: "bu argumentni berish shart emas".

Qanday ishlaydi?

1. Ichkarida type T | undefined bo'ladi

currency?: string yozsangiz, funksiya ichida currencyning type'i string | undefined bo'ladi. Ishlatishdan oldin tekshirish kerak:

function greet(name: string, title?: string) {
  title.toUpperCase();
  // ❌ 'title' is possibly 'undefined'.

  if (title) {
    return `Salom, ${title.toUpperCase()} ${name}`; // ✅ bu yerda title: string
  }
  return `Salom, ${name}`;
}

2. Optional parametr majburiylardan keyin turadi

Argumentlar pozitsiya bo'yicha uzatiladi, shuning uchun optional parametr o'rtada bo'la olmaydi:

function createUser(name?: string, email: string) {}
// ❌ A required parameter cannot follow an optional parameter.
function createUser(email: string, name?: string) {} // ✅

Agar o'rtadagi parametrni o'tkazib yuborish kerak bo'lsa — obyekt parametr ishlatish yaxshiroq:

type Options = { email: string; name?: string; age?: number };

function createUser({ email, name, age }: Options) {}

createUser({ email: "[email protected]", age: 25 }); // ✅ name o'tkazib yuborildi

3. x?: T va x: T | undefined — bir xil emas

Ichkarida ikkalasi ham T | undefined, lekin chaqiruvchi uchun farq bor:

function a(value?: string) {}
function b(value: string | undefined) {}

a();          // ✅ argumentni berish shart emas
b();          // ❌ Expected 1 arguments, but got 0.

a(undefined); // ✅
b(undefined); // ✅ undefined'ni aniq yozish shart

b ko'rinishi kamdan-kam kerak bo'ladi: chaqiruvchini "men bu qiymat haqida o'yladim va ataylab undefined beryapman" deb yozishga majburlash kerak bo'lgan holatlarda.

4. Optional yoki default?

Agar parametr berilmaganda doim bir xil qiymat ishlatilsa, default parameter qulayroq — ichkarida undefined umuman qolmaydi:

// Optional — har safar ichkarida tekshirish kerak
function paginate(page: number, limit?: number) {
  const size = limit ?? 20;
  // limit: number | undefined
}

// Default — type o'zi toraytiriladi
function paginate2(page: number, limit = 20) {
  // limit: number ✅
}

Qoida: berilmaganda boshqacha xatti-harakat kerak bo'lsa — optional; shunchaki standart qiymat kerak bo'lsa — default.

5. Optional parametrlar ko'payib ketsa

Uch-to'rtta optional parametr ketma-ket kelsa, bu kod "hidi":

function search(query: string, page?: number, limit?: number, sort?: string, desc?: boolean) {}

search("telefon", undefined, undefined, "price"); // ❌ o'qib bo'lmaydi

✅ Obyektga yig'ing:

type SearchOptions = { page?: number; limit?: number; sort?: string; desc?: boolean };

function search(query: string, options: SearchOptions = {}) {}

search("telefon", { sort: "price" }); // ✅

Agar parametrlar bir-biriga bog'liq bo'lsa (bittasi berilsa, ikkinchisi ham shart), optional emas, overload kerak bo'ladi.

Eng ko'p uchraydigan xato

Optional parametrni || yoki !x bilan tekshirish. undefinedni tekshirish uchun ko'pchilik qisqa yo'lni tanlaydi:

function setVolume(level?: number) {
  const volume = level || 50;
  player.setVolume(volume);
}

setVolume(80); // ✅ 80
setVolume();   // ✅ 50
setVolume(0);  // 🐛 50 — ovozni o'chirmoqchi edik!

|| faqat undefinedni emas, barcha falsy qiymatlarni almashtiradi: 0, "", false, NaN. TypeScript bu yerda xato bermaydi — type nuqtai nazaridan hammasi to'g'ri, bu mantiqiy xato.

Xuddi shu muammo if bilan:

function rename(user: User, newName?: string) {
  if (!newName) {
    return user; // 🐛 newName === "" bo'lsa ham shu yerga tushadi
  }
  return { ...user, name: newName };
}

✅ To'g'ri — aynan undefinedni tekshirish:

function setVolume(level?: number) {
  const volume = level ?? 50; // ✅ faqat null/undefined almashtiriladi
  player.setVolume(volume);
}

setVolume(0); // ✅ 0

function rename(user: User, newName?: string) {
  if (newName === undefined) {
    return user;
  }
  return { ...user, name: newName }; // ✅ "" ham qabul qilinadi
}

Yoki default parameter bilan muammo umuman tug'ilmaydi — default faqat undefinedda ishlaydi:

function setVolume(level = 50) {
  player.setVolume(level); // ✅ setVolume(0) → 0
}

Esda tuting: ? "qiymat yo'q bo'lishi mumkin" degani, "qiymat falsy bo'lishi mumkin" emas. number, string, boolean optional parametrlarda || o'rniga doim ?? yoki === undefined ishlating.