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.