Seriya: TypeScript Basics Dars 30

Function type

TypeScript'da funksiyaning o'z type'i: arrow sintaksis, type alias, kamroq parametrli funksiyalar mosligi, call signature, property va method sintaksisi, typeof va Function type'i xavfi.

30-dars

Function type

Funksiya e'lonini type qildik: parametrlar va return type. Lekin JavaScript'da funksiya — oddiy qiymat. Uni o'zgaruvchiga saqlaymiz, obyekt maydoniga qo'yamiz, boshqa funksiyaga uzatamiz. Bunday joylarda "bu yerda qanday funksiya bo'lishi kerak?" degan savolga javob kerak — ya'ni funksiyaning o'zining type'i.

❌ Ko'pchilik birinchi bo'lib Function type'ini topadi:

type Button = {
  label: string;
  onClick: Function;
};

const btn: Button = {
  label: "Saqlash",
  onClick: (a: number, b: string) => a * 2, // ✅ istalgan funksiya o'tadi
};

btn.onClick();                // ✅ argumentlar tekshirilmaydi
btn.onClick(1, 2, 3, "x");    // ✅ bu ham
const result = btn.onClick(); // result: any

Function — funksiyalar uchun any: "bu chaqirsa bo'ladigan narsa" deydi, xolos. Parametrlar ham, natija ham tekshirilmaydi.

✅ Function type bilan:

type Button = {
  label: string;
  onClick: (event: MouseEvent) => void;
};

const btn: Button = {
  label: "Saqlash",
  onClick: (e) => console.log(e.clientX), // ✅ e: MouseEvent — avtomatik
};

btn.onClick();         // ❌ Expected 1 arguments, but got 0.
btn.onClick("click");  // ❌ Argument of type 'string' is not assignable to parameter of type 'MouseEvent'.

Qanday ishlaydi?

1. Arrow sintaksis

Function type arrow function'ga o'xshaydi, lekin tanasi o'rnida return type turadi:

let add: (a: number, b: number) => number;

add = (x, y) => x + y;      // ✅ x, y: number — type'dan olinadi
add = (x, y) => `${x + y}`; // ❌ Type 'string' is not assignable to type 'number'.

Type'dagi parametr nomlari (a, b) faqat hujjat uchun — haqiqiy funksiyada boshqa nom ishlatish mumkin (x, y). Muhimi — tartib va type'lar.

2. Type alias bilan qayta ishlatish

Function type'ni nom bilan saqlash kodni ancha tozalaydi:

type Validator = (value: string) => boolean;

const isEmail: Validator = (v) => v.includes("@");
const isNotEmpty: Validator = (v) => v.trim().length > 0;
const minLength: (n: number) => Validator = (n) => (v) => v.length >= n;

const rules: Validator[] = [isEmail, isNotEmpty, minLength(6)];
rules.every((rule) => rule("[email protected]")); // ✅

Barcha validator'lar bir xil shartnomaga bo'ysunadi — yangi qoida qo'shish oson, xato qilish qiyin.

3. Kamroq parametrli funksiya mos keladi

Function type'ga kamroq parametr qabul qiluvchi funksiya berish mumkin, ko'proq — mumkin emas:

type Handler = (value: string, index: number) => void;

const h1: Handler = (value, index) => {}; // ✅
const h2: Handler = (value) => {};        // ✅ index kerak emas — e'tiborsiz qoldirish xavfsiz
const h3: Handler = () => {};             // ✅
const h4: Handler = (value, index, extra: boolean) => {};
// ❌ Target signature provides too few arguments. Expected 3 or more, but got 2.

Mantiq oddiy: chaqiruvchi 2 ta argument beradi. Ulardan birini ishlatmaslik — muammo emas. Uchinchisini kutish esa — muammo, u hech qachon kelmaydi. Shuning uchun [1, 2, 3].map((n) => n * 2) ishlaydi, garchi map callback'ga 3 ta argument bersa ham.

4. Call signature — xususiyatlari bor funksiya

JavaScript'da funksiyaga maydon ham qo'shish mumkin. Buni arrow sintaksis bilan ifodalab bo'lmaydi — obyekt type ichida call signature kerak:

type Formatter = {
  (value: number): string;   // ← call signature: `=>` emas, `:`
  locale: string;
};

const formatPrice: Formatter = Object.assign(
  (value: number) => value.toLocaleString("uz-UZ"),
  { locale: "uz-UZ" }
);

formatPrice(50000);  // ✅ chaqirsa bo'ladi
formatPrice.locale;  // ✅ maydoni ham bor

Interface bilan ham xuddi shunday:

interface Formatter {
  (value: number): string;
  locale: string;
}

Bir nechta call signature yozilsa — overload hosil bo'ladi. new bilan chaqiriladigan funksiyalar uchun esa construct signature (new (...args): T) ishlatiladi.

5. Property va method sintaksisi

Interface yoki type ichida funksiya maydonini ikki xil yozish mumkin:

interface Api {
  get: (url: string) => Promise<unknown>;             // property sintaksisi
  post(url: string, body: unknown): Promise<unknown>; // method sintaksisi
}

Ikkalasi deyarli bir xil ishlaydi. Nozik farq: strictFunctionTypes parametrlarni faqat property sintaksisida to'liq qat'iy tekshiradi, method sintaksisi esa tarixiy sabablarga ko'ra yumshoqroq. Shuning uchun callback va handler'lar uchun property sintaksisi xavfsizroq tanlov.

6. Mavjud funksiyadan type olish

Type'ni qo'lda yozish shart emas — mavjud funksiyadan typeof bilan olish mumkin:

function calculateTax(amount: number, rate: number): number {
  return amount * rate;
}

type TaxFn = typeof calculateTax;
// (amount: number, rate: number) => number

const mockTax: TaxFn = () => 0; // ✅ test uchun

Undan alohida qismlarni ajratib olish uchun ReturnType va Parameters utility type'lari bor — ularni keyingi darslarda ko'ramiz.

Eng ko'p uchraydigan xato

Function type'da parametr nomini tushirib qoldirish. Boshqa tillarda (C#, Java, Kotlin) function type faqat type'lardan iborat: (string) -> Unit. TypeScript'da shunday yozsangiz:

type OnChange = (string) => void;

const handle: OnChange = (value) => {
  value.toUpperCase();
};

handle(42);    // strict o'chiq bo'lsa — ✅ xato yo'q!
handle(null);  // ✅ bu ham

Nima bo'ldi? TypeScript'da function type'da parametr nomi majburiy. (string) => void degani "type'i ko'rsatilmagan, string degan nomli parametr". Type yo'q — demak any. Ya'ni siz aslida shuni yozdingiz:

type OnChange = (string: any) => void;

Bir nechta parametr bilan holat yanada chalkash:

type Compare = (number, number) => number;
// ❌ Duplicate identifier 'number'.

Strict rejimda (noImplicitAny) TypeScript birinchi holatni ham ushlaydi va hatto maslahat beradi:

type OnChange = (string) => void;
// ❌ Parameter has a name but no type. Did you mean 'arg0: string'?

Lekin strict o'chiq loyihalarda (eski kodbazalar, JS'dan migratsiya) bu xato jim o'tib ketadi va any butun handler zanjiri bo'ylab tarqaladi.

✅ To'g'ri — har doim nom: Type:

type OnChange = (value: string) => void;
type Compare = (a: number, b: number) => number;

const handle: OnChange = (value) => {
  value.toUpperCase(); // ✅ value: string
};

handle(42); // ❌ Argument of type 'number' is not assignable to parameter of type 'string'.

Editor autocomplete'da (value: string) ko'rsatadi, (arg0: string) emas — bu tayyor hujjat.

Esda tuting: TypeScript function type’ida nom ixtiyoriy emas, type ixtiyoriy. (string) => void — bu string type emas, string nomli any.