Series: TypeScript Basics Lesson 29

Rest parameter

TypeScript'da rest parametrlar: massiv va tuple type'lar, union elementlar, generic rest bilan funksiyani o'rash, spread va massivni aniq sonli parametrlarga yoyish xatosi.

29-dars

Rest parameter

TypeScript argumentlar sonini qat'iy tekshirishini ko'rdik. Lekin ba'zi funksiyalar istalgan sondagi argument qabul qilishi kerak: sum(1, 2, 3, 4), log("a", "b", "c"), Math.max(...), classNames("btn", "active", "large").

❌ Eski JavaScript usuli — arguments obyekti:

function sum() {
  let total = 0;
  for (let i = 0; i < arguments.length; i++) {
    total += arguments[i]; // arguments[i]: any — tekshiruv yo'q
  }
  return total;
}

sum(1, 2, 3);       // ❌ Expected 0 arguments, but got 3.
sum(1, "2", null);  // ❌ xuddi shu xato — signature'da parametr yo'q, TS argumentlar haqida hech narsa bilmaydi

arguments — massiv emas (map, reduce yo'q), type'i IArguments, elementlari esa any. Arrow function'larda umuman mavjud emas.

✅ Rest parameter bilan:

function sum(...numbers: number[]) {
  return numbers.reduce((total, n) => total + n, 0); // numbers: number[] — haqiqiy massiv
}

sum();             // ✅ 0
sum(1, 2, 3);      // ✅ 6
sum(1, "2", 3);    // ❌ Argument of type 'string' is not assignable to parameter of type 'number'.

... qolgan barcha argumentlarni bitta massivga yig'adi, TypeScript esa har birining type'ini tekshiradi.

Qanday ishlaydi?

1. Type — massiv bo'lishi shart

Rest parametr doim massivga yig'iladi, shuning uchun annotation ham massiv type'i bo'ladi:

function log(...messages: string[]) {}       // ✅
function log2(...messages: Array<string>) {} // ✅ bir xil

function log3(...messages: string) {}
// ❌ A rest parameter must be of an array type.

Annotation'siz yozilsa — any[]. Strict rejimda bu ham xato: Rest parameter 'messages' implicitly has an 'any[]' type.

2. Faqat bitta va faqat oxirida

function tag(name: string, ...classes: string[]) {}  // ✅

function bad(...a: string[], last: string) {}
// ❌ A rest parameter must be last in a parameter list.

function bad2(...a: string[], ...b: number[]) {}
// ❌ A rest parameter must be last in a parameter list. — rest faqat bitta bo'ladi

Oddiy parametrlar oldin keladi, rest esa "qolgan hammasini" oladi:

function createElement(tag: string, ...children: (string | HTMLElement)[]) {
  // tag — birinchi argument
  // children — qolganlari
}

createElement("ul", "Birinchi", document.createElement("li"), "Uchinchi"); // ✅

3. Turli type'lar — union element

Elementlar har xil bo'lishi mumkin bo'lsa, union massiv ishlatiladi:

function classNames(...items: (string | false | null | undefined)[]) {
  return items.filter(Boolean).join(" ");
}

classNames("btn", isActive && "btn-active", isLarge ? "btn-lg" : null); // ✅

Qavslarga e'tibor bering: (string | null)[] — "string yoki null'lardan iborat massiv". string | null[] esa butunlay boshqa narsa: "string yoki null'lar massivi".

4. Tuple bilan aniq tuzilish

Rest type'i oddiy massiv emas, tuple ham bo'lishi mumkin. Bunda har bir pozitsiyaning o'z type'i bo'ladi:

function logEvent(...args: [name: string, timestamp: number, payload?: object]) {
  const [name, timestamp, payload] = args;
}

logEvent("click", Date.now());              // ✅
logEvent("submit", Date.now(), { id: 1 });  // ✅
logEvent("click");                          // ❌ Expected 2-3 arguments, but got 1.

Bu oddiy parametrlar yozish bilan bir xil natija beradi — nega kerak? Chunki tuple'ni type sifatida saqlash va qayta ishlatish mumkin. Bu variadic tuple'larning asosi.

5. Generic rest — funksiyani o'rash

Rest + generic'ning eng kuchli qo'llanishi — istalgan funksiyaning parametrlarini aynan saqlab, uni o'rash:

function withLogging<Args extends unknown[], R>(fn: (...args: Args) => R) {
  return (...args: Args): R => {
    console.log("Chaqirildi:", args);
    return fn(...args);
  };
}

function add(a: number, b: number) {
  return a + b;
}

const loggedAdd = withLogging(add);
loggedAdd(1, 2);    // ✅ (a: number, b: number) => number — to'liq saqlandi
loggedAdd(1, "2");  // ❌ Argument of type 'string' is not assignable to parameter of type 'number'.

6. Spread — rest'ning teskarisi

Rest argumentlarni massivga yig'adi, spread esa massivni argumentlarga yoyadi:

const prices = [12000, 45000, 8000];

Math.max(...prices); // ✅ Math.max'ning o'zi rest qabul qiladi: (...values: number[])
sum(...prices);      // ✅

Eng ko'p uchraydigan xato

Oddiy massivni aniq sonli parametrlarga spread qilish. Rest qabul qiladigan funksiyaga spread muammosiz ishlaydi. Lekin parametrlari aniq soni bor funksiyaga massivni yoysangiz:

function moveTo(x: number, y: number) {}

const point = [100, 200];
moveTo(...point);
// ❌ A spread argument must either have a tuple type or be passed to a rest parameter.

Nega? pointning type'i number[] — ya'ni "istalgan uzunlikdagi raqamlar massivi". U bo'sh ham, 1 ta, 50 ta elementli ham bo'lishi mumkin. TypeScript aynan 2 ta element borligiga kafolat bera olmaydi.

Ko'pchilik bu yerda as any bilan "tuzatadi" — va butun tekshiruvni o'chiradi.

✅ Yechimlar — TypeScript'ga uzunlikni aytish:

// 1-usul: tuple type'ni aniq yozish
const point: [number, number] = [100, 200];
moveTo(...point); // ✅

// 2-usul: as const — readonly tuple hosil qiladi
const point2 = [100, 200] as const; // readonly [100, 200]
moveTo(...point2); // ✅

// 3-usul: funksiyaning o'z parametrlaridan type olish
const point3: Parameters<typeof moveTo> = [100, 200];
moveTo(...point3); // ✅ moveTo o'zgarsa, bu ham avtomatik yangilanadi

Agar massiv haqiqatan dinamik bo'lsa (masalan, API'dan kelsa), spread o'rniga uzunlikni tekshirib, elementlarni aniq uzating:

function handle(coords: number[]) {
  if (coords.length !== 2) throw new Error("Koordinata noto'g'ri");
  moveTo(coords[0], coords[1]); // ✅
}

Esda tuting: number[] — "noma'lum sondagi raqamlar", [number, number] — "aynan ikkita raqam". Fiksirlangan parametrlarga faqat tuple'ni spread qilish mumkin.