Series: TypeScript Basics Lesson 23

extends

TypeScript'da extends'ning to'rt xil ishlatilishi: interface, class merosi, generic constraint va conditional type — barchasi bitta 'mos keladi' ma'nosida.

23-dars

extends kalit so'zi

extendsni faqat interface'larni kengaytirish uchun ishlatdik. Lekin TypeScript'da bu kalit so'z to'rt xil joyda uchraydi va ko'pchilik ularni alohida-alohida, bir-biriga aloqasiz narsalar deb o'rganadi:

interface Admin extends User {}                    // 1. interface kengaytirish
class Dog extends Animal {}                        // 2. class merosi
function f<T extends string>(x: T) {}              // 3. generic constraint
type IsString<T> = T extends string ? 1 : 0;       // 4. conditional type

Aslida to'rttalasining ma'nosi bitta: A extends B — "A turini B kutilgan joyga qo'yish mumkin", ya'ni A B'ga mos keladi (assignable).

Qanday ishlaydi?

1. Asosiy ma'no: "A — B'ning kichik to'plami"

extendsni to'plamlar orqali tasavvur qiling. "admin" qiymatlari to'plami string to'plamining ichida joylashgan:

// "admin"  ⊂  string                              → "admin" extends string ✅
// string   ⊄  "admin"                             → string extends "admin" ❌
// { id: number; name: string }  ⊂  { id: number }  ✅

Oxirgi qator ko'pchilikni hayron qoldiradi: ko'proq maydonli obyekt kamroq maydonli obyektni "kengaytiradi". Sabab — talablar qancha ko'p bo'lsa, ularga mos qiymatlar shuncha kam bo'ladi. { id, name } qiymatlari { id } talabiga ham mos keladi.

2. Structural typing: extends yozish shart emas

TypeScript type'larni nomiga qarab emas, tuzilishiga qarab solishtiradi. Shuning uchun extendsni aniq yozmasangiz ham, mos tuzilishdagi type mos keladi:

interface Point2D {
  x: number;
  y: number;
}

interface Point3D {
  x: number;
  y: number;
  z: number;
} // extends Point2D yozilmagan!

function draw(p: Point2D) {}

const p3: Point3D = { x: 1, y: 2, z: 3 };
draw(p3); // ✅ Point3D tuzilishi Point2D'ga mos

Interface'dagi extends shunchaki shu munosabatni aniq e'lon qiladi va maydonlarni takrorlamaslikka yordam beradi.

3. Generic constraint: "T kamida shunday bo'lsin"

Generic'larda extends cheklov qo'yadi: T istalgan type bo'lishi mumkin, lekin B'ga mos bo'lishi shart:

function getLength<T extends { length: number }>(value: T): number {
  return value.length; // ✅ T'da length borligi kafolatlangan
}

getLength("salom");        // ✅ string'da length bor
getLength([1, 2, 3]);      // ✅ array'da length bor
getLength({ length: 10 }); // ✅
getLength(42);             // ❌ Argument of type 'number' is not assignable to parameter of type '{ length: number; }'.

4. Conditional type: "mos keladimi?" degan savol

Bu yerda extends buyruq emas, savol: "A B'ga mos keladimi?"

type IsString<T> = T extends string ? "ha" : "yo'q";

type A = IsString<"admin">; // "ha"   — "admin" ⊂ string
type B = IsString<string>;  // "ha"
type C = IsString<number>;  // "yo'q"

Yo'nalishga e'tibor bering — u ham to'plam qoidasiga bo'ysunadi:

type D = "admin" extends string ? true : false; // true
type E = string extends "admin" ? true : false; // false

5. Class extends

Class'larda extends type munosabatidan tashqari runtime meros ham beradi — metodlar va konstruktor ham o'tadi:

class Animal {
  constructor(public name: string) {}
  move() {
    return `${this.name} harakatlanmoqda`;
  }
}

class Dog extends Animal {
  bark() {
    return "Vov!";
  }
}

const d = new Dog("Rex");
d.move(); // ✅ Animal'dan meros
d.bark(); // ✅

Interface extends faqat compile-time'da mavjud, class extends esa JavaScript'ga ham o'tadi.

Eng ko'p uchraydigan xato

T extends Xni "T aynan X" deb o'ylash. Generic constraint'da T extends { name: string } yozilganda, ko'pchilik T aynan { name: string } deb hisoblaydi. Aslida T — bu shartga mos keladigan har qanday, ehtimol ancha kattaroq type:

function withDefaultName<T extends { name: string }>(obj: T): T {
  return { name: "Noma'lum" };
  // ❌ Type '{ name: string; }' is not assignable to type 'T'.
  //    '{ name: string; }' is assignable to the constraint of type 'T',
  //    but 'T' could be instantiated with a different subtype of constraint '{ name: string; }'.
}

Nega xato? Chunki chaqiruvchi T sifatida kattaroq type bera oladi:

const user = withDefaultName({ name: "Ali", age: 25, role: "admin" });
// T = { name: string; age: number; role: string }
// Funksiya T qaytarishga va'da bergan, lekin faqat { name } qaytarardi —
// user.age undefined bo'lib qolardi, holbuki type number deydi

To'g'ri yechimlar:

// ✅ 1-usul: kelgan obyektni saqlab, faqat kerakli maydonni almashtirish
function withDefaultName<T extends { name: string }>(obj: T): T {
  return { ...obj, name: obj.name || "Noma'lum" }; // ✅ qolgan maydonlar saqlanadi
}

// ✅ 2-usul: agar haqiqatan yangi obyekt qaytarsangiz — T'ni va'da qilmang
function createDefault(): { name: string } {
  return { name: "Noma'lum" }; // ✅
}

Xuddi shu mantiq primitive'larda ham ishlaydi:

function normalize<T extends string>(value: T): T {
  return value.trim();
  // ❌ Type 'string' is not assignable to type 'T'.
  //    'string' is assignable to the constraint of type 'T',
  //    but 'T' could be instantiated with a different subtype of constraint 'string'.
}

normalize(" admin "); // T = " admin ", lekin trim() "admin" qaytaradi — bu T emas

Esda tuting: T extends X — bu "T kamida X", "T aynan X" emas. Generic funksiya ichida T haqida faqat constraint'da yozilgan narsani bilasiz, qolgani noma'lum.