TypeScript'da funksiyalarni qanday tiplash kerak?

Savol

Funksiya parametrlari va qaytariladigan qiymatini qanday tiplash kerak, ixtiyoriy/standart qiymatlarni qanday belgilash kerak va funksiya overload'lari nima?

Qisqa javob

Parametr tiplari nomdan keyin ikki nuqta orqali ko'rsatiladi, qaytariladigan tip esa parametrlar ro'yxatidan keyin. Ixtiyoriy parametrlar ? bilan belgilanadi, standart qiymatga ega parametrlar tipini o'zi chiqarib oladi. Overload'lar (function overloads) argumentlar tipiga qarab har xil xatti-harakatga ega bo'lgan bitta funksiya uchun bir nechta signatura tasvirlash imkonini beradi.

Batafsil javob

Funksiyaning asosiy tiplashi:

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

Qaytariladigan qiymat tipini odatda aniq ko'rsatmasa ham bo'ladi — TypeScript uni o'zi chiqarib oladi, lekin ochiq API'larda (eksport qilinadigan funksiyalarda) uni aniq ko'rsatish yaxshi amaliyot hisoblanadi, shunda funksiya tanasining tasodifiy o'zgarishi kontraktni sezilmasdan o'zgartirib qo'ymaydi.

Ixtiyoriy parametrlar (?) uzatilmasligi mumkin — bunda ularning qiymati undefined bo'ladi. Ular majburiy parametrlardan keyin kelishi shart:

function createUser(name: string, age?: number) {
  // age: number | undefined
}

Standart qiymatli parametrlar chaqiruvda parametrni ixtiyoriy qiladi, TypeScript esa tip aniq ko'rsatilmagan bo'lsa, uning tipini standart qiymatdan chiqarib oladi:

function createUser(name: string, role = 'user') {
  // role: string, chaqiruvda ixtiyoriy
}

Funksiya overload'lari funksiyaning xatti-harakati va qaytariladigan tipi kirish argumentlari shakliga bog'liq bo'lib, kirish → chiqish bog'liqligini aniq tasvirlash uchun union tipi yetarli bo'lmaganda kerak bo'ladi. Ketma-ket bir nechta signatura yoziladi, so'ng — barcha signaturalarga mos bo'lishi shart bo'lgan bitta amalga oshirish (bu amalga oshirishning o'zi chaqiruvchi kodga ko'rinmaydi):

function makeDate(timestamp: number): Date
function makeDate(day: number, month: number, year: number): Date
function makeDate(a: number, b?: number, c?: number): Date {
  if (b !== undefined && c !== undefined) return new Date(c, b - 1, a)
  return new Date(a)
}

makeDate(2026)               // OK — birinchi signatura
makeDate(7, 9, 2026)         // OK — ikkinchi signatura
makeDate(7, 9)                // Xato — ikkita argumentli signatura yo'q

Overload'larsiz (a: number, b?: number, c?: number) => Date deb yozishga to'g'ri kelardi, va bu holda makeDate(7, 9) chaqiruvi kompilyator tomonidan rad etilmasdi.

Misol

interface FetchOptions {
  method?: 'GET' | 'POST'
  retries?: number
}

// ochiq funksiyada aniq qaytariladigan tip
async function fetchData<T>(url: string, options: FetchOptions = {}): Promise<T> {
  const { method = 'GET', retries = 3 } = options
  const res = await fetch(url, { method })
  if (!res.ok) throw new Error(`Failed: ${res.status}`)
  return res.json() as Promise<T>
}

// konfiguratsiya parseri uchun overload'lar
function parseConfig(input: string): Record<string, string>
function parseConfig(input: string[]): Record<string, string>[]
function parseConfig(input: string | string[]): Record<string, string> | Record<string, string>[] {
  const parseOne = (s: string) => JSON.parse(s) as Record<string, string>
  return Array.isArray(input) ? input.map(parseOne) : parseOne(input)
}

Qo'shimcha savollar

• Union-parametrli funksiya signaturasi overload'lardan nimasi bilan farq qiladi va qachon qaysi birini tanlash kerak?
• Ixtiyoriy sondagi argumentlarni qabul qiladigan funksiyani (rest parameters) qanday tiplash kerak?
• Funksiyalarni tiplashda this parametri nima va u nima uchun kerak?