Function overload
TypeScript'da function overload: imzolar va implementation, turli sondagi parametrlar, imzolar tartibi, overload yoki union tanlovi, arrow va method overload hamda union argument bilan chaqirish xatosi.
33-dars
Function overload
Ba'zi funksiyalar kirgan argument type'iga qarab boshqa type qaytaradi. Union bilan yozilsa, TS bu bog'liqlikni bilmaydi va chaqiruvchiga har doim keng type beradi.
// ❌ Muammo: kirish va chiqish o'rtasidagi bog'liqlik yo'qoladi
function double(value: string | number): string | number {
return typeof value === "string" ? value + value : value * 2;
}
const a = double(5);
a.toFixed(1);
// ❌ Property 'toFixed' does not exist on type 'string | number'.
// Property 'toFixed' does not exist on type 'string'.
Biz bilamizki, 5 berilsa number qaytadi. Lekin TS faqat imzoni ko'radi: "string | number qaytaradi". Natijada har chaqiruvdan keyin narrowing yoki as yozishga to'g'ri keladi.
// ✅ Yechim: har bir holat uchun alohida imzo — overload
function double(value: string): string;
function double(value: number): number;
function double(value: string | number): string | number {
return typeof value === "string" ? value + value : value * 2;
}
const a = double(5); // a: number
const b = double("ha"); // b: string
a.toFixed(1); // ✅
b.toUpperCase(); // ✅
Endi TS chaqiruvdagi argumentga qarab mos imzoni tanlaydi va aniq type qaytaradi.
Qanday ishlaydi?
1. Tuzilishi: imzolar + bitta tana
Overload ikki qismdan iborat:
// Overload imzolari — tanasiz, faqat "shartnoma"
function getLength(value: string): number;
function getLength(value: unknown[]): number;
// Implementation imzosi — bitta, tanasi bor
function getLength(value: string | unknown[]): number {
return value.length;
}
| Qism | Nechta | Tanasi bor? | Tashqaridan ko'rinadimi? |
|---|---|---|---|
| Overload imzolari | 1 yoki ko'p | ❌ | ✅ |
| Implementation imzosi | aynan 1 ta | ✅ | ❌ |
Imzolar va implementation ketma-ket, orada boshqa kod bo'lmasligi kerak. Implementation imzosi barcha overload'larni qamrab oladigan darajada keng bo'lishi shart.
2. Turli sondagi parametrlar
Overload faqat type uchun emas, argumentlar soni uchun ham ishlatiladi.
function makeDate(timestamp: number): Date;
function makeDate(year: number, month: number, day: number): Date;
function makeDate(yOrTs: number, m?: number, d?: number): Date {
if (m !== undefined && d !== undefined) {
return new Date(yOrTs, m, d);
}
return new Date(yOrTs);
}
makeDate(1700000000000); // ✅ 1-imzo
makeDate(2026, 9, 15); // ✅ 2-imzo
makeDate(2026, 9);
// ❌ No overload expects 2 arguments, but overloads do exist that expect either 1 or 3 arguments.
3. Tartib muhim: birinchi mos kelgani tanlanadi
TS imzolarni yuqoridan pastga tekshiradi va birinchi mos keluvchini oladi. Shuning uchun aniqroq imzo yuqorida bo'lishi kerak.
// 🐛 Noto'g'ri tartib — keng imzo birinchi
function parse(input: string): string;
function parse(input: "true" | "false"): boolean; // hech qachon tanlanmaydi
function parse(input: string): string | boolean {
if (input === "true") return true;
if (input === "false") return false;
return input;
}
const r = parse("true"); // r: string — 🐛 aslida true (boolean) qaytadi!
// ✅ To'g'ri tartib — aniq imzo yuqorida
function parse(input: "true" | "false"): boolean;
function parse(input: string): string;
function parse(input: string): string | boolean {
if (input === "true") return true;
if (input === "false") return false;
return input;
}
const r = parse("true"); // r: boolean ✅
const s = parse("salom"); // s: string ✅
4. TS implementation'ning "rost gapirishini" tekshirmaydi
TS implementation tanasini faqat uning o'z imzosiga qarab tekshiradi. Qaysi overload qaysi tarmoqqa mos kelishini bilmaydi.
function double(value: string): string;
function double(value: number): number;
function double(value: string | number): string | number {
return typeof value === "string" ? value.length : value + "!"; // 🐛 teskari!
}
const n = double(5); // TS: number, aslida "5!" (string)
n.toFixed(1); // 💥 runtime'da: n.toFixed is not a function
Implementation string | number qaytaradi, bu imzoga mos — TS indamaydi. Overload'lar va'da, uni bajarish dasturchining zimmasida.
5. Overload yoki union: qaysi birini tanlash?
Agar qaytariladigan type argumentga bog'liq bo'lmasa, overload ortiqcha. Union parametr soddaroq va qulayroq.
// ❌ Keraksiz overload
function len(x: string): number;
function len(x: unknown[]): number;
function len(x: string | unknown[]) {
return x.length;
}
const v = Math.random() > 0.5 ? "abc" : [1, 2];
len(v); // ❌ No overload matches this call. (pastda batafsil)
// ✅ Union — oddiy va hamma holatni qabul qiladi
function len2(x: string | unknown[]): number {
return x.length;
}
len2(v); // ✅
| Holat | Tanlov |
|---|---|
| Chiqish type'i kirishga bog'liq emas | Union parametr |
| Chiqish type'i kirishga bog'liq, holatlar kam | Overload |
| Turli argumentlar soni / tartibi | Overload |
| Bog'liqlik ko'p type'lar uchun umumiy qoida | Generic yoki conditional type |
6. Arrow funksiyalar va method'lar uchun overload
function kalit so'zisiz overload e'lon qilib bo'lmaydi. Arrow funksiya uchun bir nechta call signature'ga ega type yoziladi.
type Formatter = {
(value: number): string;
(value: Date): string;
};
const format: Formatter = (value: number | Date) =>
value instanceof Date ? value.toISOString() : value.toFixed(2);
format(3.14159); // ✅
format(new Date()); // ✅
Class method'larida esa oddiy function kabi yoziladi:
class Logger {
log(message: string): void;
log(code: number, message: string): void;
log(a: string | number, b?: string): void {
console.log(typeof a === "number" ? `[${a}] ${b}` : a);
}
}
Eslatma: ReturnType va Parameters utility type'lari overload'li funksiyada faqat oxirgi imzoni oladi.
Eng ko'p uchraydigan xato
Overload'li funksiyani union qiymat bilan chaqirish. Har bir overload alohida yaxshi ishlaydi. Lekin keyin boshqa funksiya uni "o'rab" chaqirsa, muammo chiqadi:
function double(value: string): string;
function double(value: number): number;
function double(value: string | number): string | number {
return typeof value === "string" ? value + value : value * 2;
}
function doubleAll(items: (string | number)[]) {
return items.map((item) => double(item));
// ❌ No overload matches this call.
// Overload 1 of 2, '(value: string): string', gave the following error.
// Argument of type 'string | number' is not assignable to parameter of type 'string'.
// Overload 2 of 2, '(value: number): number', gave the following error.
// Argument of type 'string | number' is not assignable to parameter of type 'number'.
}
Nega bunday bo'ladi? Dasturchi shunday o'ylaydi: "Implementation string | number qabul qiladi, demak union berish mumkin." Lekin implementation imzosi tashqaridan ko'rinmaydi. TS faqat overload imzolarini tekshiradi va string | number hech biriga to'liq mos kelmaydi: u string ham emas, number ham emas. TS union'ni avtomatik ravishda "bo'lib", har bir qismni alohida overload'ga moslamaydi.
// ✅ 1-yechim: union uchun ham overload qo'shamiz (eng pastga)
function double(value: string): string;
function double(value: number): number;
function double(value: string | number): string | number; // union holati
function double(value: string | number): string | number {
return typeof value === "string" ? value + value : value * 2;
}
// ✅ 2-yechim: chaqirishdan oldin narrowing
function doubleAll(items: (string | number)[]) {
return items.map((item) =>
typeof item === "string" ? double(item) : double(item)
);
}
Ko'pincha 1-yechim eng qulay: union imzo ro'yxatning oxirida turadi, shuning uchun aniq argumentlar uchun aniq type'lar saqlanib qoladi.
Esda tuting: tashqaridan faqat overload imzolari ko'rinadi — implementation imzosi qabul qiladigan narsani chaqiruvchi ham bera olishi uchun uni alohida overload sifatida yozish kerak.