Seriya: TypeScript Basics Dars 25

Funksiya parametrlarini type'lash

TypeScript'da funksiya parametrlariga type berish: annotation, argumentlar soni, union va obyekt parametrlar, destructuring, readonly va contextual typing.

25-dars

Funksiya parametrlarini type'lash

TypeScript o'zgaruvchi type'ini qiymatdan o'zi aniqlaydi. Lekin funksiya parametrlarida bu ishlamaydi — e'lon paytida parametrga hech qanday qiymat berilmaydi, TypeScript uning nima bo'lishini bila olmaydi:

function greet(name) {
  // ❌ Parameter 'name' implicitly has an 'any' type. (strict rejimda)
  return "Salom, " + name.toUpperCase();
}

greet(42);        // strict bo'lmasa — xato yo'q, runtime'da esa:
                  // TypeError: name.toUpperCase is not a function

Type ko'rsatilmagan parametr any bo'lib qoladi va funksiya ichidagi barcha tekshiruvlar o'chadi. noImplicitAny aynan shu holatni xato deb belgilaydi.

✅ Type bilan:

function greet(name: string) {
  return "Salom, " + name.toUpperCase();
}

greet("Ali"); // ✅
greet(42);    // ❌ Argument of type 'number' is not assignable to parameter of type 'string'.

Parametr type'i — bu funksiyaning shartnomasi: chaqiruvchi nima berishi kerakligini, funksiya ichida esa nima kelishiga ishonish mumkinligini belgilaydi.

Qanday ishlaydi?

1. Oddiy annotation

Har bir parametrdan keyin : Type yoziladi:

function createUser(name: string, age: number, isAdmin: boolean) {
  return { name, age, isAdmin };
}

createUser("Ali", 25, false);   // ✅
createUser("Ali", "25", false); // ❌ Argument of type 'string' is not assignable to parameter of type 'number'.

2. Argumentlar soni ham tekshiriladi

JavaScript ortiqcha yoki yetishmaydigan argumentlarga indamaydi. TypeScript esa sonini ham qat'iy tekshiradi:

createUser("Ali", 25);              // ❌ Expected 3 arguments, but got 2.
createUser("Ali", 25, false, "x");  // ❌ Expected 3 arguments, but got 4.

Ixtiyoriy parametr, standart qiymat yoki cheksiz sondagi argument kerak bo'lsa, buning uchun alohida sintaksis bor: optional, default va rest parametrlar. Ularni keyingi darslarda ko'ramiz.

3. Union va literal parametrlar

Parametr bir nechta type'dan birini qabul qilishi mumkin:

function setTheme(theme: "light" | "dark" | "system") {}

setTheme("dark");  // ✅
setTheme("blue");  // ❌ Argument of type '"blue"' is not assignable to parameter of type '"light" | "dark" | "system"'.

function formatId(id: number | string) {
  // id bu yerda number | string — ishlatishdan oldin narrowing kerak
  return typeof id === "number" ? id.toFixed(0) : id.trim();
}

4. Obyekt parametrlar

Parametrlar ko'payganda (3–4 tadan ortiq) ularni bitta obyektga yig'ish yaxshi amaliyot — tartibni eslab qolish shart emas:

type CreateUserParams = {
  name: string;
  email: string;
  age?: number;
  role: "admin" | "user";
};

function createUser(params: CreateUserParams) {
  params.name; // ✅
}

createUser({ name: "Ali", email: "[email protected]", role: "user" }); // ✅

Obyekt literal to'g'ridan-to'g'ri uzatilganda ortiqcha maydonlar ham tekshiriladi (excess property check):

createUser({ name: "Ali", email: "[email protected]", role: "user", agee: 25 });
// ❌ Object literal may only specify known properties, but 'agee' does not exist in type 'CreateUserParams'.
//    Did you mean to write 'age'?

Bu imlo xatolarini tutishda juda foydali.

5. Destructuring bilan

Obyektni parametrdayoq yoyish mumkin. Type butun pattern'dan keyin yoziladi:

function createUser({ name, email, role }: CreateUserParams) {
  return `${name} <${email}> — ${role}`;
}

// Inline type bilan ham bo'ladi:
function move({ x, y }: { x: number; y: number }) {}

6. readonly parametrlar

Funksiya kelgan massivni o'zgartirmasligini kafolatlash uchun:

function sum(numbers: readonly number[]) {
  numbers.push(0); // ❌ Property 'push' does not exist on type 'readonly number[]'.
  return numbers.reduce((a, b) => a + b, 0); // ✅
}

Bu chaqiruvchiga ham signal: "massivingizni buzmayman".

7. Contextual typing — type yozish shart bo'lmagan joy

Funksiya biror joyga callback sifatida uzatilsa, TypeScript parametr type'ini kontekstdan oladi:

const names = ["Ali", "Vali", "Gani"];

names.map((name) => name.toUpperCase());
//         ^ name: string — map'ning o'zi aytib turibdi

document.addEventListener("click", (e) => {
  e.clientX; // ✅ e: MouseEvent — avtomatik
});

Bu holatlarda annotation ortiqcha.

Eng ko'p uchraydigan xato

Destructuring ichida type yozish. Boshqa tillardan kelganlar (va hatto tajribali JS dasturchilar) ko'pincha shunday yozadi:

function createUser({ name: string, age: number }) {
  // ❌ Binding element 'string' implicitly has an 'any' type.
  // ❌ Binding element 'number' implicitly has an 'any' type.
  console.log(age);
  // ❌ Cannot find name 'age'.
}

Bu yerda : type annotation emas — bu JavaScript'ning qayta nomlash sintaksisi! { name: string } degani "name maydonini olib, uni string degan o'zgaruvchiga sol" degani. Ya'ni:

// Siz yozgan narsa aslida shu:
function createUser(arg) {
  const string = arg.name;  // o'zgaruvchi nomi — "string"
  const number = arg.age;   // o'zgaruvchi nomi — "number"
}

Natijada name va age degan o'zgaruvchilar umuman mavjud emas, parametr esa implicit any. Strict rejimda xato bor, lekin xabar chalkash; strict o'chiq bo'lsa, kod "ishlaydi" va xato faqat runtime'da chiqadi.

⚠️ name bilan esa bundan ham yomonroq: brauzer muhitida (lib.dom) global name o'zgaruvchisi mavjud (window.name), shuning uchun console.log(name) hech qanday "Cannot find name" xatosini bermaydi — jimgina boshqa qiymatni o'qiydi.

✅ To'g'ri — type butun pattern'dan keyin:

function createUser({ name, age }: { name: string; age: number }) {
  console.log(name); // ✅ name: string
}

// Yoki alohida type bilan — o'qishga qulayroq:
type UserInput = { name: string; age: number };

function createUser({ name, age }: UserInput) {}

Default qiymat bilan birga ham xuddi shu qoida:

function connect({ host = "localhost", port = 5432 }: { host?: string; port?: number } = {}) {}
//               ^ qiymatlar pattern ichida           ^ type pattern'dan keyin         ^ butun obyekt uchun default

Esda tuting: destructuring ichida : — bu doim qayta nomlash. Type esa har doim yopiluvchi }dan keyin keladi.