Series: TypeScript Basics Lesson 15

Object Types

TypeScript'dagi object type'lar, structural typing, excess property check va {} / Object xatarlari haqida.

15-dars

Object Types

JavaScript'da obyekt bu property'lar to'plami, lekin kod yozayotganda "bu obyektda qanday property'lar bor?" degan savolga javobni faqat kodni o'qib topasiz. user.nmae deb yozsangiz JS jimgina undefined qaytaradi, xato esa bir necha qatordan keyin, masalan undefined.toUpperCase() da chiqadi. Funksiyaga noto'g'ri shakldagi obyekt uzatish ham shunday.

Object type obyektning shaklini (qaysi property, qanday tip) tavsiflaydi. Compiler imloviy xatolarni, yetishmayotgan property'larni va noto'g'ri tiplarni yozayotgan paytingizda ushlaydi. Avvalgi mavzudagi object "biror obyekt" degan juda keng tip edi, bu mavzu esa aniq shaklni beradi.

Qanday ishlaydi?

1. Sintaksis: inline va alias bilan

// Inline: shu joyning o'zida
function printUser(user: { name: string; age: number }): void {
  console.log(`${user.name}, ${user.age} yosh`);
}

// Alias bilan: qayta ishlatiladi
type User = { name: string; age: number };

const ali: User = { name: "Ali", age: 25 };     // ✅
const bad: User = { name: "Vali" };
// ❌ Property 'age' is missing in type '{ name: string; }' but required in type 'User'.

ali.email;
// ❌ Property 'email' does not exist on type 'User'.

Property'larni ; yoki , bilan ajratish mumkin, ikkalasi bir xil ishlaydi. Jamoada odatda bittasi tanlanadi (ko'pincha ;).

2. Inference: TS obyekt shaklini o'zi chiqaradi

const config = { host: "localhost", port: 3000, debug: true };
// tip: { host: string; port: number; debug: boolean }

Diqqat qiling: property'lar string, number va booleanga kengaytirilgan. Sabab [[typescript-basics-11|literal types]] mavzusidagi bilan bir xil: obyekt property'lari keyin o'zgarishi mumkin. Literal tip kerak bo'lsa, as const ishlatiladi.

3. Structural typing: muhim bo'ladigan faqat shakl

TS obyektlarni nomi bo'yicha emas, shakli bo'yicha solishtiradi. Talab qilingan property'lar bor bo'lsa yetarli, ortiqcha property'lar to'sqinlik qilmaydi:

type Point = { x: number; y: number };

function distance(p: Point): number {
  return Math.sqrt(p.x ** 2 + p.y ** 2);
}

const point3d = { x: 1, y: 2, z: 3 };
distance(point3d);   // ✅ x va y bor, z e'tiborga olinmaydi

Bu JS'ning "duck typing" yondashuvini tiplarga ko'chirilgan ko'rinishi. Lekin bu yerda bitta istisno bor, uni keyingi qadamda ko'ramiz.

4. Excess property check: faqat "yangi" literal'larga

const p1: Point = { x: 1, y: 2, z: 3 };
// ❌ Object literal may only specify known properties, and 'z' does not exist in type 'Point'.

distance({ x: 1, y: 2, z: 3 });
// ❌ xuddi shu xato, chunki literal to'g'ridan-to'g'ri yozilgan

const tmp = { x: 1, y: 2, z: 3 };
const p2: Point = tmp;   // ✅ o'zgaruvchi orqali o'tsa, tekshiruv yo'q

Qoida: compiler ortiqcha property'ni faqat obyekt literal'i shu joyning o'zida yozilgan paytda (fresh literal) xato deb hisoblaydi. Bunda ehtimol imloviy xato bo'lgan deb taxmin qiladi. Obyekt oldindan o'zgaruvchiga saqlangan bo'lsa, bu tekshiruv ishlamaydi. Quyidagi xato aynan shu haqda.

5. Method yozuvining ikki shakli

type Logger = {
  log(msg: string): void;            // method syntax
  warn: (msg: string) => void;       // property syntax
};

Ikkalasi ko'p holatda bir xil ishlaydi. Farqi strictFunctionTypes (strict ichida) yoqilganda parametr tiplari qanchalik qat'iy tekshirilishida: property syntax qat'iyroq, method syntax yumshoqroq tekshiriladi. Bu funksiya tiplari bilan birga chuqurroq ko'riladi.

6. Runtime'da obyekt tipi yo'q

type User = { name: string; age: number };

const raw: User = JSON.parse('{"name": 42}');   // ✅ compile bo'ladi (JSON.parse any qaytaradi)
raw.name.toUpperCase();                          // 💥 runtime: toUpperCase is not a function

Tiplar compile vaqtida o'chib ketadi (type erasure), V8 hech qanday tekshiruv qilmaydi. Tashqaridan kelgan ma'lumotni unknown sifatida olib, runtime'da tekshirish kerak.

Eng ko'p uchraydigan xato

Object type'ni "yopiq" (aniq shakldagi) deb o'ylash. Dasturchi { id: number; name: string } tipini ko'rib, shu obyektda faqat shu ikkita property bor deb hisoblaydi. Aslida tip "kamida shular bor" degani, ortiqchasi ham bo'lishi mumkin:

type PublicUser = { id: number; name: string };

function toResponse(user: PublicUser): string {
  return JSON.stringify(user);   // hamma property'ni serialize qiladi
}

const dbUser = { id: 1, name: "Ali", passwordHash: "x9f3a..." };

toResponse(dbUser);
// ⚠️ compile bo'ladi! Runtime'da: {"id":1,"name":"Ali","passwordHash":"x9f3a..."}

toResponse({ id: 1, name: "Ali", passwordHash: "x9f3a..." });
// ❌ 'passwordHash' does not exist in type 'PublicUser'  ← faqat fresh literal'da

Ikki chaqiruv orasidagi nomuvofiqlikka e'tibor bering. Bir xil ma'lumot, lekin biri xato beradi, ikkinchisi yo'q. Excess property check himoya emas, faqat imloviy xatolarni ushlash uchun yordamchi. Real loyihada esa parol hash'i API javobiga chiqib ketishi jiddiy xavfsizlik muammosi.

To'g'ri yechim: kerakli maydonlarni runtime'da aniq tanlash.

type DbUser = { id: number; name: string; passwordHash: string };
type PublicUser = { id: number; name: string };

// ✅ Tip yordamida chegara aniq, runtime'da esa faqat kerakli maydonlar olinadi
function toPublic(u: DbUser): PublicUser {
  return { id: u.id, name: u.name };
}

const dbUser: DbUser = { id: 1, name: "Ali", passwordHash: "x9f3a..." };
JSON.stringify(toPublic(dbUser));   // ✅ {"id":1,"name":"Ali"}

{} va Objectni "istalgan obyekt" deb ishlatish.

const a: {} = 5;            // ✅ ⚠️ bo'sh obyekt tipi primitive'larni ham qabul qiladi
const b: {} = "salom";      // ✅ ⚠️
const c: {} = null;         // ❌ null va undefined mumkin emas

const d: object = 5;        // ❌ Type 'number' is not assignable to type 'object'
const e: object = { a: 1 }; // ✅ faqat non-primitive

{} "bo'sh shakldagi obyekt" emas, "null/undefined'dan boshqa har qanday qiymat" degani. Object (bosh harf bilan) ham shunga yaqin va undan qochish tavsiya etiladi. "Istalgan obyekt" kerak bo'lsa object yoki aniqroq Record<string, unknown> ishlating.