Series: TypeScript Basics Lesson 21

Interface Extension

TypeScript'da interface'ni extends bilan kengaytirish: bir nechta bazadan meros, zanjirli extension, maydonni toraytirish va Omit bilan qayta e'lon qilish.

21-dars

Interface Extension

Real loyihalarda ko'p obyektlar umumiy maydonlarga ega bo'ladi. Masalan, User, Admin, Moderator hammasida id, name, email bor. Har birida bu maydonlarni qayta yozish kodni takrorlaydi, va bittasini o'zgartirsangiz qolganlarini unutib qo'yish xavfi paydo bo'ladi.

❌ Takrorlanish:

interface User {
  id: number;
  name: string;
  email: string;
}

interface Admin {
  id: number;       // takror
  name: string;     // takror
  email: string;    // takror
  permissions: string[];
}

✅ Extension bilan:

interface User {
  id: number;
  name: string;
  email: string;
}

interface Admin extends User {
  permissions: string[];
}

const admin: Admin = {
  id: 1,
  name: "Ali",
  email: "[email protected]",
  permissions: ["users:delete"],
};

Endi Userga yangi maydon qo'shsangiz, u avtomatik ravishda Adminga ham o'tadi. Bu interfacening asosiy afzalliklaridan biri: ierarxik, "bu — o'shaning kengaytirilgan turi" degan munosabatni aniq ifodalash.

Qanday ishlaydi?

1. Oddiy extension

extends kalit so'zi bazaviy interface'ning barcha maydonlarini yangi interface'ga ko'chiradi, siz esa ustiga yangilarini qo'shasiz.

interface Animal {
  name: string;
}

interface Dog extends Animal {
  breed: string;
}

const dog: Dog = { name: "Rex", breed: "Ovcharka" }; // ✅
const bad: Dog = { breed: "Ovcharka" };              // ❌ Property 'name' is missing

2. Bir nechta interface'dan kengaytirish

Interface bir vaqtda bir nechta interface'ni kengaytira oladi (vergul bilan):

interface HasId {
  id: number;
}

interface Timestamps {
  createdAt: Date;
  updatedAt: Date;
}

interface Post extends HasId, Timestamps {
  title: string;
  body: string;
}

const post: Post = {
  id: 1,
  createdAt: new Date(),
  updatedAt: new Date(),
  title: "TS darslari",
  body: "...",
}; // ✅

Bu mixin'ga o'xshash yondashuv: kichik "qurilish bloklari"dan katta type yig'iladi.

3. Zanjirli extension

interface Entity {
  id: number;
}

interface Person extends Entity {
  name: string;
}

interface Employee extends Person {
  salary: number;
}

// Employee = { id, name, salary }

4. Maydonni toraytirish (narrowing)

Bola interface bazaviy maydonning type'ini toraytirishi mumkin, ya'ni unga mos (assignable) bo'lgan aniqroq type berishi mumkin:

interface Shape {
  kind: string;
  color?: string;
}

interface Circle extends Shape {
  kind: "circle";   // ✅ "circle" — string'ning kichik to'plami (literal type)
  color: string;    // ✅ optional'dan majburiyga o'tkazish ham mumkin
  radius: number;
}

5. Type alias'ni kengaytirish

Interface obyekt ko'rinishidagi type alias'ni ham kengaytira oladi:

type Base = {
  id: number;
};

interface Product extends Base {
  price: number;
} // ✅

Lekin union type'ni kengaytirib bo'lmaydi:

type Status = { ok: true } | { ok: false };

interface ApiResponse extends Status {}
// ❌ An interface can only extend an object type or intersection of object types with statically known members.

6. readonly va optional merosi

Modifikatorlar ham meros qilib o'tadi:

interface Config {
  readonly apiUrl: string;
  timeout?: number;
}

interface AppConfig extends Config {
  appName: string;
}

const cfg: AppConfig = { apiUrl: "https://api.uz", appName: "Shop" }; // ✅ timeout ixtiyoriy
cfg.apiUrl = "x"; // ❌ Cannot assign to 'apiUrl' because it is a read-only property.

Eng ko'p uchraydigan xato

Maydonni mos kelmaydigan type bilan "qayta yozish". Ko'pchilik extends bilan bazaviy maydonni butunlay boshqa type'ga almashtirish mumkin deb o'ylaydi:

interface User {
  id: number;
}

interface LegacyUser extends User {
  id: string; // ❌ Interface 'LegacyUser' incorrectly extends interface 'User'.
              //    Types of property 'id' are incompatible.
}

Sabab: LegacyUser baribir User bo'lishi kerak, ya'ni User kutilgan joyda LegacyUser ishlatilsa, id number bo'lishi shart. Toraytirish mumkin, butunlay boshqa type'ga almashtirish mumkin emas.

To'g'ri yechimlar:

// ✅ 1-usul: bazani umumiyroq qilish
interface User {
  id: number | string;
}
interface LegacyUser extends User {
  id: string; // ✅ string ⊂ number | string
}

// ✅ 2-usul: Omit bilan maydonni olib tashlab, qayta e'lon qilish
interface User2 {
  id: number;
  name: string;
}
interface LegacyUser2 extends Omit<User2, "id"> {
  id: string; // ✅
}

Nega bu intersection'dan yaxshiroq?

Xuddi shu holatni intersection bilan qilsangiz, TypeScript darhol xato bermaydi, balki jimgina never hosil qiladi:

type A = { id: number };
type B = A & { id: string };   // ⚠️ e'lon paytida xato yo'q

const b: B = { id: 1 };   // ❌ Type 'number' is not assignable to type 'never'.
const c: B = { id: "1" }; // ❌ bu ham

Xato e'lon qilingan joyda emas, balki ishlatilgan joyda chiqadi, shuning uchun sababini topish qiyinroq. interface extends esa ziddiyatni e'lon qilishning o'zidayoq ko'rsatadi. Shu sababli obyekt ierarxiyasi uchun extends odatda xavfsizroq tanlov hisoblanadi.