Seriya: TypeScript Basics Dars 35

Implementation signature

TypeScript'da implementation imzosi: runtime'da faqat bitta tana, barcha overload'larni qamrash, rest + tuple union, tana ichida narrowing, qaytish type'i va any yozish xavfi.

35-dars

Implementation signature

Java yoki C# kabi tillarda overload — bir nechta alohida funksiya tanasi. TypeScript'da esa runtime'da baribir JavaScript ishlaydi, JavaScript'da bir nomli funksiya faqat bitta bo'ladi. Shuning uchun barcha overload'larni bitta tana bajaradi — uning imzosi implementation signature deyiladi.

// ❌ Muammo: boshqa tillardagidek har holat uchun alohida tana yozish
function area(radius: number): number {
  // ❌ Duplicate function implementation.
  return Math.PI * radius * radius;
}
function area(width: number, height: number): number {
  // ❌ Duplicate function implementation.
  return width * height;
}
// ✅ Yechim: overload imzolari + bitta umumiy implementation
function area(radius: number): number;
function area(width: number, height: number): number;
function area(a: number, b?: number): number {
  return b === undefined ? Math.PI * a * a : a * b;
}

area(5);    // ✅ doira
area(4, 6); // ✅ to'rtburchak

Implementation imzosi — barcha overload'larni bir joyda qabul qila oladigan "umumiy eshik".

Qanday ishlaydi?

1. Runtime'da faqat implementation qoladi

Kompilyatsiyadan keyin overload imzolari butunlay o'chib ketadi. JavaScript'ga faqat implementation tanasi tushadi.

// TypeScript
function area(radius: number): number;
function area(width: number, height: number): number;
function area(a: number, b?: number): number {
  return b === undefined ? Math.PI * a * a : a * b;
}
// Kompilyatsiyadan keyingi JavaScript
function area(a, b) {
  return b === undefined ? Math.PI * a * a : a * b;
}

Demak, overload'lar faqat compile-time'dagi tekshiruv uchun. "Qaysi holat chaqirildi?" degan savolga runtime'da faqat implementation ichidagi kod javob beradi.

2. Implementation imzosi barcha overload'larni qamrashi kerak

Overload'lar turli pozitsiyada turli type kutsa, implementation parametrlari ularning birlashmasi bo'ladi.

function send(message: string): void;
function send(to: string, message: string): void;
function send(id: number, message: string, urgent: boolean): void;
function send(
  first: string | number, // har bir overload'ning 1-parametri
  second?: string,        // 2-parametr ba'zi overload'larda yo'q
  urgent?: boolean        // 3-parametr faqat bittasida bor
): void {
  // ...
}
Overload'lardagi holat Implementation'da
Bir pozitsiyada turli type'lar Union: string | number
Parametr ba'zi overload'larda yo'q Optional: second?
Parametr nomi turlicha ma'noda Umumiy nom: first, second
Argumentlar soni juda farq qiladi Rest + tuple union

Implementation'dagi parametr nomlari tashqarida ko'rinmaydi, shuning uchun ular faqat tanani o'qish uchun qulay bo'lsa yetarli.

3. Rest parametr va tuple union bilan

Overload'lar ko'p va argumentlar soni turlicha bo'lsa, optional parametrlar chalkash bo'lib ketadi. Rest parametr va tuple'lar birlashmasi aniqroq ishlaydi.

function area(radius: number): number;
function area(width: number, height: number): number;
function area(...args: [number] | [number, number]): number {
  if (args.length === 1) {
    const [radius] = args;         // args: [number]
    return Math.PI * radius * radius;
  }
  const [width, height] = args;    // args: [number, number]
  return width * height;
}

args.length tekshiruvi tuple'ni narrowing qiladi: TS har bir tarmoqda aniq qaysi tuple ekanini biladi. Bu usul tuple'lar mavzusida chuqurroq ochiladi.

4. Tana ichida narrowing majburiy

Implementation ichida TS qaysi overload orqali chaqirilganini bilmaydi — u faqat implementation imzosini ko'radi. Shuning uchun har bir holat narrowing bilan ajratiladi.

function len(value: string): number;
function len(value: unknown[]): number;
function len(value: { size: number }): number;
function len(value: string | unknown[] | { size: number }): number {
  if (typeof value === "string") return value.length; // typeof
  if (Array.isArray(value)) return value.length;      // massiv tekshiruvi
  return value.size;                                  // qolgani — { size: number }
}

Narrowing'siz to'g'ridan-to'g'ri ishlatish xato beradi:

function len2(value: string | unknown[] | { size: number }): number {
  return value.length;
  // ❌ Property 'length' does not exist on type 'string | unknown[] | { size: number; }'.
  //      Property 'length' does not exist on type '{ size: number; }'.
}

5. Qaytish type'i: aniq yozish yaxshiroq

Implementation qaytish type'i barcha overload qaytish type'larini qamrashi kerak. Uni aniq yozsangiz, TS overload'lar bilan mosligini tekshiradi.

function parseNum(input: string): number;
function parseNum(input: string[]): number[];
// ❌ This overload signature is not compatible with its implementation signature.
function parseNum(input: string | string[]): number {
  return Array.isArray(input) ? 0 : Number(input);
}
// ✅ Qaytish type'i — overload'lar qaytishlarining birlashmasi
function parseNum(input: string): number;
function parseNum(input: string[]): number[];
function parseNum(input: string | string[]): number | number[] {
  return Array.isArray(input) ? input.map(Number) : Number(input);
}

🐛 Mantiqiy xato: TS faqat number | number[] qaytarilishini tekshiradi, qaysi tarmoq qaysini qaytarishini emas.

function parseNumBad(input: string | string[]): number | number[] {
  return Array.isArray(input) ? Number(input[0]) : [Number(input)]; // 🐛 teskari
}
// TS jim: ikkala tarmoq ham number | number[] ichida

Overload'lar va'da, implementation esa uni rostdan bajarishi kerak.

6. Overload imzosi va implementation imzosi taqqoslanganda

Overload imzosi Implementation imzosi
Soni 1 yoki ko'p aynan 1 ta
Tanasi yo'q bor
Chaqiruvchi ko'radimi ✅ ❌
JS'ga tushadimi ❌ ✅
Type'lari aniq, tor umumiy, keng
Kim uchun chaqiruvchi uchun shartnoma tanani yozish uchun

Eng ko'p uchraydigan xato

Implementation imzosini any bilan yozish. Overload'lar ko'p, implementation imzosini to'g'ri birlashtirish erinarli — dasturchi "baribir tashqaridan ko'rinmaydi" deb any yozadi:

function double(value: string): string;
function double(value: number): number;
function double(value: any): any {
  return value.toUpperCase() + value.toUpperCase(); // 🐛 number holati unutildi
}

double("ha"); // "HAHA" ✅
double(5);    // 💥 runtime: value.toUpperCase is not a function

Nega bunday bo'ladi? Fikr qisman to'g'ri: implementation imzosi chaqiruvchiga ko'rinmaydi, shuning uchun tashqi API buzilmaydi. Lekin any tana ichidagi barcha tekshiruvlarni o'chiradi. TS hech narsa demaydi: na unutilgan holat haqida, na noto'g'ri qaytgan qiymat haqida. Overload'lar va implementation o'rtasidagi moslik tekshiruvi ham yo'qoladi, chunki any har qanday imzoga "sig'adi".

Aniq union bilan yozilganda TS darhol xatoni topadi:

function double(value: string): string;
function double(value: number): number;
function double(value: string | number): string | number {
  return value.toUpperCase() + value.toUpperCase();
  // ❌ Property 'toUpperCase' does not exist on type 'string | number'.
  //      Property 'toUpperCase' does not exist on type 'number'.
}
// ✅ Yechim: union parametr + union qaytish + narrowing
function double(value: string): string;
function double(value: number): number;
function double(value: string | number): string | number {
  if (typeof value === "string") {
    return value + value;
  }
  return value * 2;
}

Implementation parametri haqiqatan ham har xil bo'lsa va union yozish qiyin bo'lsa, any o'rniga unknown ishlating — u har bir holatni narrowing qilishga majbur qiladi.

Esda tuting: implementation imzosi tashqaridan yashirin bo'lsa ham, tana uchun u TS'ning yagona ko'zi — any yozish shu ko'zni yumib qo'yish demak.