Series: TypeScript Basics Lesson 19

Nested Object Types

TypeScript'da ichma-ich obyekt tiplari, indexed access, optional zanjirlar va spread'dagi chuqurlik xatosi.

19-dars

Nested Object Types

Real ma'lumotlar deyarli hech qachon yassi bo'lmaydi. Foydalanuvchining manzili bor, manzilning koordinatasi bor, buyurtmada mahsulotlar ro'yxati va har birida narx obyekti bor. API javoblari ham odatda shunday ichma-ich keladi. Bunday obyektni object yoki any deb yozsangiz, user.profile.adress.city kabi imloviy xato ham jimgina o'tadi va undefined.city faqat runtime'da portlaydi.

Nested object type shu muammoni hal qiladi: property'ning tipi o'zi ham obyekt tipi bo'lishi mumkin, va compiler har bir darajani alohida tekshiradi. Chuqur yozuv o'qishni qiyinlashtirsa, uni alias'larga bo'lib chiqasiz yoki indexed access bilan ichki qismni "kesib" olasiz.

Qanday ishlaydi?

1. Inline ichma-ich yozuv

type User = {
  id: number;
  profile: {
    name: string;
    address: {
      city: string;
      geo: { lat: number; lng: number };
    };
  };
};

const u: User = {
  id: 1,
  profile: {
    name: "Ali",
    address: { city: "Toshkent", geo: { lat: 41.3, lng: 69.2 } },
  },
};

u.profile.address.geo.lat;    // ✅ tip: number
u.profile.address.zip;        // ❌ Property 'zip' does not exist on type '{ city: string; geo: {...} }'.

const bad: User = {
  id: 1,
  profile: { name: "Ali", address: { city: "Toshkent" } },
};
// ❌ Property 'geo' is missing in type '{ city: string; }' but required in type '{ city: string; geo: {...} }'.

Xato xabari qaysi ichki darajada muammo borligini aniq ko'rsatadi.

2. Alias'larga ajratish

Chuqur inline yozuvni o'qib bo'lmaydi va ichki qismni alohida ishlatib bo'lmaydi. Har bir darajaga nom bering:

type Geo     = { lat: number; lng: number };
type Address = { city: string; geo: Geo };
type Profile = { name: string; address: Address };
type User    = { id: number; profile: Profile };

function distanceTo(g: Geo): number { /* ... */ return 0; }
distanceTo(u.profile.address.geo);   // ✅ ichki qism alohida tip sifatida ishlaydi

TS tiplarni strukturasi bo'yicha solishtiradi, shuning uchun inline va alias'li versiya to'liq bir xil. Bu faqat o'qish qulayligi va qayta ishlatish masalasi. Xato xabarlari ham qisqa chiqadi: Address deb yoziladi, butun struktura ochilmaydi.

3. Ichki tipni indexed access bilan olish

Alias yozilmagan, lekin ichki qism kerak bo'lsa:

type Addr = User["profile"]["address"];            // { city: string; geo: Geo }
type City = User["profile"]["address"]["city"];    // string

Bu qiymat emas, tip darajasidagi murojaat. User o'zgarsa, Addr avtomatik yangilanadi va sinxronlik buzilmaydi. Optional property'ga murojaat qilsangiz, natijaga undefined ham qo'shiladi.

4. Excess property check har bir darajada ishlaydi

Qoida ichki fresh literal'larga ham qo'llanadi:

const x: User = {
  id: 1,
  profile: {
    name: "Ali",
    address: { city: "Toshkent", geo: { lat: 41.3, lng: 69.2, alt: 450 } },
    //                                                        ~~~ ❌ 'alt' does not exist in type 'Geo'
  },
};

Oldindan o'zgaruvchiga saqlangan ichki obyekt esa bu tekshiruvdan o'tib ketadi.

5. Optional ichki obyektlar: har daraja alohida tekshiriladi

type Settings = {
  theme?: { color?: string; font?: { size: number } };
};

function color(s: Settings): string {
  return s.theme.color;
  // ❌ 's.theme' is possibly 'undefined'.
}

function color2(s: Settings): string {
  return s.theme?.color ?? "blue";   // ✅ optional chaining + nullish coalescing
}

function fontSize(s: Settings): number {
  return s.theme?.font?.size ?? 14;  // ✅ zanjirdagi har bir ? bitta darajani qoplaydi
}

Uchta daraja bo'lsa, uch xil "yo'q" holati bor. Ko'p ?. zanjiri kerak bo'layotgan bo'lsa, bu tip dizayni haqida signal: maydonlar haqiqatan ham shuncha ixtiyoriymi, yoki discriminated union to'g'riroqmi, deb o'ylab ko'ring.

6. Destructuring bilan ichki maydonlarni olish

function label({ profile: { name, address: { city } } }: User): string {
  return `${name}, ${city}`;   // ✅ name: string, city: string
}
// profile va address bu yerda o'zgaruvchi sifatida yaratilmaydi, faqat name va city

Tip annotation destructuring pattern'dan keyin yoziladi. Pattern ichida tip yozib bo'lmaydi, chunki { name: string } pattern'da nameni string nomli o'zgaruvchiga qayta nomlash degani.

7. Runtime'da tip yo'q

Tiplar compile vaqtida o'chadi (type erasure). JSON.parse any qaytargani uchun ichki qismlar yo'q bo'lsa ham compiler jim turadi:

const raw: User = JSON.parse('{"id": 1}');   // ✅ compile bo'ladi
raw.profile.address.city;                     // 💥 runtime: Cannot read properties of undefined (reading 'address')

Chuqur ma'lumotni tashqaridan olganda unknown sifatida qabul qilib, har bir daraja tekshirilishi kerak.

Eng ko'p uchraydigan xato

Spread (...) bilan "nusxa" olib, ichki obyektni o'zgartirish. Spread faqat bir darajani ko'chiradi, ichki obyektlar esa reference sifatida bo'lishib qoladi. { ...original } har bir own enumerable property'ning qiymatini yangi obyektga yozadi. Qiymat obyekt bo'lsa, heap'dagi o'sha bitta obyektga ishora nusxalanadi. TS buni tip darajasida ushlamaydi:

const original: User = {
  id: 1,
  profile: {
    name: "Ali",
    address: { city: "Toshkent", geo: { lat: 41.3, lng: 69.2 } },
  },
};

const copy: User = { ...original };

copy.id = 2;                  // ✅ original.id o'zgarmaydi (bu yangi obyektning property'si)
copy.profile.name = "Vali";   // ⚠️ compile bo'ladi, hech qanday ogohlantirish yo'q

console.log(original.profile.name);        // "Vali" — original buzildi
console.log(copy.profile === original.profile);   // true — bitta obyekt

To'g'ri yechim:

// ✅ o'zgargan yo'ldagi har bir darajani spread qilish
const updated: User = {
  ...original,
  profile: {
    ...original.profile,
    name: "Vali",
  },
};

console.log(original.profile.name);   // "Ali" — tegilmagan
console.log(updated.profile.address === original.profile.address);
// true — o'zgarmagan qismlar bo'lishib qoladi (structural sharing), bu xavfsiz va samarali