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.