WisarWisar
Dasturlash kitobi/7-QISM — TypeScript19 daqiqa

7.2-bob: Asosiy turlar, interface, type alias, enum

7-QISM — TypeScript · 2-mavzu

1. Kirish va motivatsiya

7.1-bobda TypeScript'ni sozlashni bildik (tsconfig, strict). Endi uning yuragiga — turlar tizimiga — kiramiz. Bu — TypeScript bilan haqiqiy ishlashning boshlanishi. Asosiy turlar (string, number, array, tuple, object), interface (obyekt shaklini ta'riflash), type alias (turga nom berish), va enum (nomlangan konstantalar) — bu to'rttasi TS kodning 90% ini tashkil qiladi. Bularni mukammal bilsangiz — TS'ning qolgani oson.

TypeScript'da har narsa tur (type) bilan boshlanadi. JS'da o'zgaruvchi har qanday qiymatni saqlay olardi (dinamik — 2.1-JS); TS'da o'zgaruvchining turi belgilanadi (number, string), va u faqat shu turdagi qiymatni qabul qiladi. Bu — kompilyatorga (va IDE'ga) kodingiz haqida ma'lumot beradi: u xatolarni topadi, autocompletion beradi, kodni hujjatlaydi. Tur — "bu o'zgaruvchi qanday ma'lumotni saqlaydi" degan va'da/shartnoma.

Eng muhim ikki tushuncha — interface va type alias. Ikkalasi ham obyekt shaklini ta'riflaydi ({ ism: string, yosh: number }), lekin nozik farqlari bor (qaysi qachon — 2.10). Va enum — bir nechta nomlangan konstantani guruhlash (Role.ADMIN, Status.ACTIVE). Bu bob: asosiy turlar, interface, type alias, enum — chuqur, ko'p misol bilan. Bu — Prisma 6.12-bob, TypeORM 6.13-bob, NestJS (8), React (11) — hamma joyda ishlatiladi.

O'xshatish: tur — idishning yorlig'i. "Shakar" yozilgan idishga (number) faqat shakar (son) solasiz — tuz (string) solsangiz, yorliq bilan mos kelmaydi (xato). Interface — murakkab idishning to'liq tavsifi ("bu idishda: shakar bo'limi, tuz bo'limi, qalampir bo'limi bor" — obyekt shakli). Enum — ruxsat etilgan yorliqlar ro'yxati ("faqat: shakar, tuz, qalampir" — boshqa narsa bo'lmaydi). Yorliqlar — tartib va aniqlik.

Nega muhim?

  • TS yuragi — turlar TS kodning asosi (90%).
  • interface/type — obyekt shaklini ta'riflash (har joyda).
  • enum — nomlangan konstantalar (rol, holat — toza kod).
  • Stack — Prisma, TypeORM, NestJS, React — hammasi shu turlarda.

2. Nazariya — chuqur tushuntirish

2.1. Asosiy (primitiv) turlar

JS'ning primitiv turlari (2.1-JS) TS'da:

ts
let yosh: number = 25;             // son (butun, kasr — bitta number)
let ism: string = "Ali";           // matn
let faol: boolean = true;          // true/false
let hech: null = null;             // null
let aniqmas: undefined = undefined; // undefined
let katta: bigint = 100n;          // katta son (BigInt)
let belgi: symbol = Symbol("id");  // Symbol

Type inference (tur xulosa): ko'pincha turni yozmasa ham bo'ladi — TS uni o'zi xulosa qiladi: let yosh = 25 TS yosh: number deb biladi (qiymatdan). Ortiqcha yozmang (let yosh: number = 25 — keraksiz takror). Faqat noaniq holatda belgilang (parametr, bo'sh massiv).

2.2. Array va Tuple

ts
// Array — bir xil turdagi elementlar
let sonlar: number[] = [1, 2, 3];           // sonlar massivi
let ismlar: string[] = ["Ali", "Vali"];     // string massivi
let bayroqlar: Array<boolean> = [true];      // muqobil sintaksis (generic — 7.3)

// Tuple — aniq uzunlik, aniq turlar (har pozitsiya o'z turi)
let juftlik: [string, number] = ["Ali", 25];   // [ism, yosh] — tartib muhim
// juftlik = [25, "Ali"];   //  xato (tartib noto'g'ri)
let rgb: [number, number, number] = [255, 0, 0];

Array vs Tuple: Array — istalgan uzunlik, bir xil tur (number[]). Tuple — aniq uzunlik va har pozitsiyada aniq tur ([string, number]). Tuple — koordinata, RGB, React useState qaytishi ([value, setValue] — 11.4). Kamroq ishlatiladi, lekin aniq.

2.3. object, any, unknown, void, never

ts
let obj: object = { ism: "Ali" };   // umumiy obyekt (kam ishlatiladi — aniq shakl yaxshi)
let x: any = 5;                      // har narsa (TEKSHIRUVNI O'CHIRADI — 7.1: 2.9, qoch)
let y: unknown = 5;                  // noma'lum (xavfsiz any — tekshirish majbur)
function log(): void {}              // hech narsa qaytarmaydi (7.1: Misol 7)
function xato(): never { throw new Error(); }   // HECH QACHON qaytmaydi (xato/cheksiz)

Maxsus turlar: any (tekshiruvsiz — qoch — 7.1: 2.9); unknown (xavfsiz — tekshirish majbur — 7.5); void (qaytarmaydi — funksiya); never (hech qachon — xato tashlovchi yoki cheksiz). object — juda umumiy (aniq shakl — interface/type afzal — 2.5).

2.4. Union turlar (yoki)

Union (|) — o'zgaruvchi bir nechta turdan biri bo'lishi mumkin:

ts
let id: number | string;            // number YOKI string
id = 5;        // OK
id = "abc";    // OK
// id = true;  //  (boolean emas)

// Literal union (aniq qiymatlar — eng foydali)
let holat: "yangi" | "tasdiqlandi" | "bekor";   // faqat shu uch qiymat
holat = "yangi";    // OK
// holat = "boshqa"; //  (ro'yxatda yo'q)

Union — TS'ning kuchli xususiyati: string | null (null bo'lishi mumkin — 7.1: 2.10), "a" | "b" | "c" (faqat shu qiymatlar — enum'ga muqobil — 2.9). Literal union — holat, rol uchun a'lo (aniq, autocompletion). Ishlatishda narrowing (tekshirish — 7.5).

2.5. Interface — obyekt shakli

Interface — obyektning shaklini (qaysi maydon, qaysi tur) ta'riflaydi:

ts
interface User {
  id: number;
  ism: string;
  email: string;
  yosh?: number;              // ? — ixtiyoriy (bo'lmasligi mumkin)
  readonly created: Date;     // readonly — o'zgartirib bo'lmaydi
}

const user: User = {
  id: 1, ism: "Ali", email: "ali@a.uz", created: new Date(),
};
// user.created = new Date();   //  readonly
// const u2: User = { id: 1 };  //  ism, email, created yo'q

Interface — "shartnoma": obyekt aynan shu shaklda bo'lishi kerak (majburiy maydonlar, turlar). ? — ixtiyoriy; readonly — o'zgarmas. TS obyektni interface'ga solib tekshiradi (yetishmasa/ortiqcha — xato). Bu — obyektlar bilan ishlashning asosi.

2.6. Interface metodlari va funksiyalar

ts
interface Hisoblagich {
  qiymat: number;
  oshir(): void;                          // metod
  oshirBy(son: number): number;           // parametr + qaytish
}

// Funksiya turi (interface'da yoki alohida)
interface MatematikAmal {
  (a: number, b: number): number;         // funksiya signaturasi
}
const summa: MatematikAmal = (a, b) => a + b;

Interface nafaqat ma'lumot, balki metodlar va funksiya turlarini ham ta'riflaydi. Bu — class'lar 2.8-bob va funksiyalar uchun shartnoma. NestJS service'lari, repository'lar — interface bilan (8, 9: DIP).

2.7. Interface kengaytirish (extends)

Interface'lar bir-birini kengaytiradi (extends — meros — 2.10-JS):

ts
interface Hayvon {
  nom: string;
  ovqatlan(): void;
}

interface It extends Hayvon {     // Hayvon'ning hammasi + qo'shimcha
  zot: string;
  vovullash(): void;
}

const it: It = {
  nom: "Rex", zot: "Labrador",
  ovqatlan() {}, vovullash() {},   // Hayvon + It — hammasi
};

// Ko'p interface'dan (multiple)
interface Admin extends User, Loggable { /* ... */ }

extends — interface'ni kengaytiradi (asosiy + qo'shimcha). Kod takrorini kamaytiradi (umumiy maydonlar — bazaviy interface). Ko'p interface'dan kengaytirish mumkin. Bu — OOP (2.10-JS) va toza dizayn (9).

2.8. Class interface'ni amalga oshirish (implements)

ts
interface Animal {
  nom: string;
  ovoz(): string;
}

class Mushuk implements Animal {    // interface'ni AMALGA OSHIRADI (shartnoma)
  constructor(public nom: string) {}
  ovoz(): string { return "Miyov"; }   // interface talab qiladi — majbur
}

implements — class interface'dagi hamma narsani ta'minlashi shart (shartnoma). Interface — "nima bo'lishi kerak" (shakl); class — "qanday qilinadi" (amalga oshirish). Bu — NestJS (8), SOLID (9: DIP) ning asosi. Class type alias'ni implements qila olmaydi (faqat interface — 2.10).

2.9. Enum — nomlangan konstantalar

Enum — bir nechta bog'liq nomlangan konstantani guruhlash:

ts
enum Rol {
  USER,        // 0 (default — avto raqam)
  ADMIN,       // 1
  MODERATOR,   // 2
}
let rol: Rol = Rol.ADMIN;       // Rol.ADMIN (qiymati 1)

// String enum (afzal — aniq qiymat)
enum Holat {
  YANGI = "yangi",
  TASDIQLANDI = "tasdiqlandi",
  BEKOR = "bekor",
}
let h: Holat = Holat.YANGI;     // "yangi"

// const enum — runtime obyekt yaratmaydi (qiymat joyiga inline qo'yiladi)
const enum Yon { CHAP, ONG }
let y: Yon = Yon.CHAP;          // kompilyatsiyada 0 ga aylanadi (obyekt yo'q)

Enum vs union literal: enum — nomlangan konstantalar to'plami (Rol.ADMIN); union literal ("user" | "admin" — 2.4) — soddaroq, kamroq kod. Zamonaviy tendentsiya: ko'p holatda union literal yoki as const 2.11-bob afzal (enum runtime kod yaratadi, union — yo'q). String enum — agar enum kerak bo'lsa (raqamli emas).

Enum narxi: oddiy enum runtime obyekt yaratadi (JS'ga qo'shimcha kod). const enum — obyekt yaratmaydi, qiymatni to'g'ridan-to'g'ri inline qo'yadi (tejamli), lekin ba'zi build sozlamalarida (isolatedModules — Babel/esbuild) ishlamaydi, shuning uchun ehtiyot bo'ling. Aksariyat loyihada: soddalik uchun union literal yoki as const 2.11-bob — enum'siz.

2.10. Interface vs Type alias (eng muhim farq)

Ikkalasi ham obyekt shaklini ta'riflaydi, lekin farqlari bor (logrocket/iloveblogs):

ts
// Interface
interface UserI { ism: string; yosh: number; }

// Type alias (xuddi shu)
type UserT = { ism: string; yosh: number; };
text
  ┌──────────────────────┬─────────────────┬─────────────────┐
  │                      │ interface       │ type alias      │
  ├──────────────────────┼─────────────────┼─────────────────┤
  │ Obyekt shakli        │               │               │
  │ Union/primitiv       │               │  (type X = A|B)│
  │ extends (kengaytir)  │  extends      │  & (intersect)│
  │ Declaration merging  │  (qayta ochish)│              │
  │ class implements     │               │  (obyekt bo'lsa)│
  │ Conditional/mapped   │               │  7.4-bob        │
  └──────────────────────┴─────────────────┴─────────────────┘

Asosiy farq: interface — faqat obyekt shakli, lekin kengaytiriladigan (extends, declaration merging); type — istalgan tur (union, primitiv, conditional — 7.4), lekin "yopiq" (qayta ochilmaydi). Tavsiya (typescriptlang): obyekt/class shakli interface; union/utility/murakkab tur type.

2.11. Type alias — har turga nom

Type alias — istalgan turga nom berish (faqat obyekt emas):

ts
type ID = number | string;                  // union'ga nom (2.4)
type Holat = "yangi" | "tasdiqlandi";       // literal union'ga nom
type Koordinata = [number, number];         // tuple'ga nom
type Callback = (xato: Error | null, natija?: string) => void;   // funksiya
type User = { ism: string; yosh: number };  // obyekt

// as const — obyektni o'zgarmas + tor tur (enum muqobili — 2.9)
const Rang = { QIZIL: "red", YASHIL: "green" } as const;
type Rang = typeof Rang[keyof typeof Rang];   // "red" | "green"

Type alias kuchi: istalgan turga nom (union, tuple, funksiya, primitiv) — interface qila olmaydi (faqat obyekt). as const — obyektni o'zgarmas qiladi va tor tur beradi (enum'siz nomlangan konstantalar — zamonaviy). typeof/keyof — turlardan tur olish 7.4-bob.

2.12. Intersection (kesishma — &)

Intersection (&) — bir nechta turni birlashtirish (hammasi birga):

ts
type Shaxs = { ism: string };
type Xodim = { lavozim: string };
type Ishchi = Shaxs & Xodim;        // ikkalasi BIRGA (ism + lavozim)

const x: Ishchi = { ism: "Ali", lavozim: "dasturchi" };   // ikkalasi shart

Intersection vs Union: Union (|) — "yoki" (biri); Intersection (&) — "va" (hammasi). A & B — A'ning ham, B'ning ham hamma maydonlari. Interface'ning extendsiga o'xshash (type uchun). Murakkab turlar yaratishda.

2.13. Literal turlar va const

ts
// Literal — aniq qiymat tur sifatida
let yon: "shimol" | "janub" | "sharq" | "g'arb";   // faqat shu 4 (2.4)

// const — qiymat o'zgarmas + tor tur
const x = "salom";    // turi: "salom" (literal — o'zgarmas)
let y = "salom";      // turi: string (o'zgaruvchan)

// Funksiya parametrida literal
function harakat(yon: "chap" | "o'ng") {}
harakat("chap");      // OK
// harakat("yuqori"); //

Literal tur — aniq qiymat tur sifatida ("chap" — faqat shu matn). const — o'zgarmas, tor tur (literal). Funksiya parametrida — ruxsat etilgan qiymatlarni cheklash (enum'siz). Bu — TS'ning aniqligi.

2.14. Index signature (dinamik kalitlar)

ts
// Oldindan noma'lum kalitlar (dinamik obyekt)
interface Lugat {
  [kalit: string]: string;          // istalgan string kalit  string qiymat
}
const tarjima: Lugat = { salom: "hello", xayr: "bye" };
tarjima.yangi = "new";              // OK (istalgan kalit)

// Record — qisqaroq (utility type — 7.4)
type Lugat2 = Record<string, string>;

Index signature ([kalit: string]: T) — oldindan noma'lum kalitlar (dinamik obyekt — lug'at, kesh). Lekin ehtiyot — tur xavfsizligini kamaytiradi (har kalit bor deb hisoblaydi). Record<K, V> 7.4-bob — ko'pincha toza muqobil.

2.15. Best practices (interface/type/enum)

text
   Type inference'dan foydalaning (ortiqcha yozmang — 2.1)
   Obyekt/class shakli  interface; union/utility  type 2.10-bob
   Literal union yoki as const (enum o'rniga ko'pincha — 2.9, 2.11)
   ? (ixtiyoriy), readonly (o'zgarmas) — aniq 2.5-bob
   extends bilan kod takrorini kamaytiring 2.7-bob
   any o'rniga aniq tur/unknown (7.1: 2.9)
   Literal union — holat/rol (aniq, autocompletion — 2.4)
   Domen modellari — interface (o'qiladigan, kengaytiriladigan — 2.10)

3. Sintaksis — tez ma'lumotnoma

ts
// Asosiy (2.1, 2.2)
let n: number; let s: string; let b: boolean; let arr: number[]; let t: [string, number];

// Union (2.4)
let id: number | string;  let holat: "a" | "b" | "c";

// Interface (2.5)
interface User { id: number; ism: string; yosh?: number; readonly x: Date; }
interface Admin extends User { rol: string; }              // extends (2.7)

// Type (2.11)
type ID = number | string;  type User2 = { ism: string };
type Ishchi = A & B;                                        // intersection (2.12)

// Enum (2.9)
enum Holat { YANGI = "yangi", BEKOR = "bekor" }

4. Batafsil kod namunalari

Misol 1 — Asosiy turlar va inference (2.1, 2.2)

ts
// Type inference — TS o'zi xulosa qiladi (ortiqcha yozma — 2.1)
let yosh = 25;                    // TS: number
let ism = "Ali";                 // TS: string
const sonlar = [1, 2, 3];        // TS: number[]

// Aniq belgilash — noaniq holatda (parametr, bo'sh massiv)
let bahalar: number[] = [];      // bo'sh — TS bilmaydi, belgilash kerak
function ko'paytir(a: number, b: number): number {   // parametr — belgilash shart
  return a * b;
}

// Tuple 2.2-bob
const koordinata: [number, number] = [41.3, 69.2];   // [lat, lng]
const [lat, lng] = koordinata;   // destructuring (2.8-JS) — lat, lng number

Misol 2 — Interface (to'liq — 2.5, 2.6)

ts
interface Mahsulot {
  readonly id: number;            // o'zgarmas (2.5)
  nom: string;
  narx: number;
  tavsif?: string;                // ixtiyoriy (2.5)
  teglar: string[];
  kategoriya: { id: number; nom: string };   // ichma-ich obyekt
  chegirmaHisobla(foiz: number): number;       // metod (2.6)
}

const mahsulot: Mahsulot = {
  id: 1, nom: "Telefon", narx: 5000000, teglar: ["yangi"],
  kategoriya: { id: 1, nom: "Elektronika" },
  chegirmaHisobla(foiz) { return this.narx * (1 - foiz / 100); },
};
// mahsulot.id = 2;   //  readonly (2.5)

Misol 3 — Interface kengaytirish (extends — 2.7)

ts
// Bazaviy interface (umumiy maydonlar — DRY)
interface BazaEntity {
  id: number;
  createdAt: Date;
  updatedAt: Date;
}

interface User extends BazaEntity {        // BazaEntity + qo'shimcha (2.7)
  ism: string;
  email: string;
}

interface Order extends BazaEntity {       // BazaEntity'ni qayta ishlatish
  userId: number;
  summa: number;
}

// Ko'p interface'dan
interface AdminUser extends User {
  rol: "admin";
  ruxsatlar: string[];
}

Misol 4 — Type alias va union (2.4, 2.11)

ts
// Union literal (holat — 2.4)
type OrderStatus = "yangi" | "tasdiqlandi" | "yetkazildi" | "bekor";

// Type — istalgan tur (2.11)
type ID = number | string;
type Koordinata = [number, number];
type EventHandler = (event: string, data: unknown) => void;

// Murakkab union (turli obyektlar — discriminated union — 7.5)
type Javob =
  | { holat: "muvaffaqiyat"; data: unknown }
  | { holat: "xato"; xabar: string };

function ishla(j: Javob) {
  if (j.holat === "muvaffaqiyat") console.log(j.data);   // narrowing (7.5)
  else console.log(j.xabar);
}

Misol 5 — Interface vs Type (tanlov — 2.10)

ts
//  Obyekt/domen modeli  interface (kengaytiriladigan — 2.10)
interface User {
  id: number;
  ism: string;
}
interface User {                  // declaration merging (qayta ochish — 2.10)
  email: string;                  // qo'shiladi (interface — ochiq)
}
// User endi: id, ism, email (birlashdi)

//  Union/utility/funksiya  type (2.10)
type Status = "active" | "inactive";       // union — type
type Pair = [string, number];              // tuple — type
type Handler = () => void;                 // funksiya — type

Misol 6 — Enum vs union vs as const (2.9, 2.11)

ts
// 1. Enum (klassik)
enum Rol { USER = "user", ADMIN = "admin" }
let r1: Rol = Rol.ADMIN;

// 2. Union literal (soddaroq — zamonaviy tavsiya — 2.9)
type Rol2 = "user" | "admin";
let r2: Rol2 = "admin";

// 3. as const (obyekt — enum muqobili — 2.11)
const ROLLAR = { USER: "user", ADMIN: "admin" } as const;
type Rol3 = typeof ROLLAR[keyof typeof ROLLAR];   // "user" | "admin"
let r3: Rol3 = ROLLAR.ADMIN;

// Tanlov: oddiy  union literal (2); obyekt kerak  as const (3); klassik  enum (1)

Misol 7 — Class + interface (implements — 2.8)

ts
// Interface — shartnoma (9: DIP)
interface Repository<T> {           // generic (7.3)
  topId(id: number): Promise<T | null>;
  saqla(item: T): Promise<T>;
}

interface User { id: number; ism: string; }

// Class interface'ni amalga oshiradi (2.8)
class UserRepository implements Repository<User> {
  async topId(id: number): Promise<User | null> {
    return { id, ism: "Ali" };      // (DB — 6)
  }
  async saqla(user: User): Promise<User> {
    return user;
  }
}
// Interface — shartnoma; class — amalga oshirish (NestJS — 8, SOLID — 9)

Misol 8 — Real domen modellari (e-commerce — 2.5, 2.7)

ts
// To'liq domen modellari (interface — 2.10)
interface BazaEntity {
  id: number;
  createdAt: Date;
}

type OrderStatus = "yangi" | "tasdiqlandi" | "yetkazildi" | "bekor";   // (2.4)

interface User extends BazaEntity {
  ism: string;
  email: string;
  rol: "user" | "admin";          // literal union (2.4)
}

interface Product extends BazaEntity {
  nom: string;
  narx: number;
  zaxira: number;
}

interface OrderItem {
  product: Product;
  miqdor: number;
  narx: number;                   // snapshot (6.3)
}

interface Order extends BazaEntity {
  user: User;
  items: OrderItem[];
  status: OrderStatus;
  jamiSumma: number;
}
// Bu modellar — butun ilovada (API, DB, frontend — bir til)

5. To'g'ri va noto'g'ri holatlar

1) Ortiqcha tur yozish (inference bor)

ts
//  keraksiz (TS o'zi biladi — 2.1)
const ism: string = "Ali";

//  inference
const ism = "Ali";   // TS: string

2) any ishlatish

ts
//  tur tekshiruvi yo'q (7.1: 2.9)
function f(data: any) {}

//  aniq tur / interface / unknown
function f(data: User) {}

3) Union literal o'rniga string

ts
//  har qanday string (xato qiymat o'tadi)
function holat(s: string) {}

//  literal union (aniq — 2.4)
function holat(s: "yangi" | "bekor") {}

4) Type'ni obyekt uchun, kengaytirish kerak bo'lganda

ts
// Domen modeli kengaytiriladigan bo'lsa  interface (2.10)
interface User { ism: string }   // extends, merging mumkin
// type User = { ism: string }   // yopiq (kamroq moslashuvchan domen uchun)

5) Enum'ni ortiqcha ishlatish

ts
// Oddiy holat uchun union literal yetadi (2.9)
type Status = "a" | "b";   // enum'dan sodda (runtime kod yo'q)

6. Keng tarqalgan xatolar va yechimlari

Xato 1 — Property 'x' does not exist on type

Sababi: interface'da yo'q maydonga murojaat, yoki typo 2.5-bob. Yechimi: interface'ga qo'shing; typo'ni to'g'irlang; optional (?) bo'lsa tekshiring.

Xato 2 — Type 'X' is not assignable to type 'Y'

Sababi: tur mos emas 2.4-bob. Yechimi: to'g'ri tur; union bo'lsa narrowing 7.5-bob; aylantirish.

Xato 3 — Object literal may only specify known properties

Sababi: interface'da yo'q ortiqcha maydon 2.5-bob. Yechimi: maydonni interface'ga qo'shing yoki olib tashlang.

Xato 4 — Enum qiymati kutilmagan

Sababi: raqamli enum (default 0,1,2 — 2.9). Yechimi: string enum (= "value") yoki union literal.

Xato 5 — Cannot use 'extends' on type alias

Sababi: type alias extends ishlatmaydi 2.10-bob. Yechimi: interface uchun extends; type uchun & (intersection — 2.12).

Xato 6 — readonly o'zgartirishga urinish

Sababi: readonly maydonni o'zgartirish 2.5-bob. Yechimi: o'zgartirmang; kerak bo'lsa readonly olib tashlang.

7. Integratsiya — bu mavzu stack'ning qayerida uchraydi

  • JS turlari (2.1-JS): TS turlar — JS ustida.
  • TS kirish 7.1-bob: strict, null xavfsizligi.
  • Generics 7.3-bob: turlarni parametrlash.
  • Ilg'or turlar 7.4-bob: utility, mapped (type asosida).
  • Type guards 7.5-bob: union narrowing.
  • Prisma/TypeORM (6.12, 6.13): generatsiya/dekorator turlari.
  • Zod 5.9-bob: schema'dan tur (infer).
  • NestJS 8.5-bob: DTO (class + interface).
  • React 11.14-bob: props (interface).
  • SOLID (9): interface — DIP.

8. Eng yaxshi amaliyotlar (best practices)

  • Type inference'dan foydalaning (ortiqcha yozmang — 2.1).
  • Obyekt/domen interface; union/utility type 2.10-bob.
  • Literal union yoki as const (enum o'rniga ko'pincha — 2.9).
  • ? (ixtiyoriy), readonly (aniq — 2.5).
  • extends bilan kod takrorini kamaytiring (bazaviy interface — 2.7).
  • anydan qoching (aniq tur/unknown — 7.1: 2.9).
  • Literal union — holat/rol (aniq, autocompletion — 2.4).
  • Domen modellarini bir joyda (types/ — qayta ishlatish — 2.10).
  • class implements interface (shartnoma — 2.8, 9: DIP).
  • Index signature ehtiyot (Record afzal — 2.14).

9. Amaliy loyiha: "Tipli Domen Modellari"

TS turlarini mustahkamlash.

Maqsad

E-commerce (yoki ijtimoiy tarmoq) uchun to'liq, tipli domen modellarini yaratish: interface, type, enum, union — to'g'ri tanlangan.

Talablar (requirements)

  1. Asosiy turlar: primitiv, array, tuple ishlatilgan misollar (2.1, 2.2).
  2. Domen interface'lari: User, Product, Order, OrderItem — interface, extends (BazaEntity — Misol 8, 2.5, 2.7).
  3. Union literal: OrderStatus, Rol 2.4-bob.
  4. Type alias: ID (union), funksiya turi, tuple 2.11-bob.
  5. Intersection: ikki turni birlashtirish (Misol, 2.12).
  6. Enum vs union vs as const: uchchovini ko'rsating, tanlovni asoslang (Misol 6, 2.9).
  7. Class + interface: Repository interface, class implements (Misol 7, 2.8).
  8. Interface vs type: har birini to'g'ri joyda 2.10-bob.
  9. Discriminated union: API javob (muvaffaqiyat/xato — Misol 4).
  10. strict mode: any'siz, null xavfsiz 7.1-bob.

Maslahatlar (hint)

  • Inference (ortiqcha yozma — 2.1, 1-xato).
  • Obyekt interface; union type (2.10, 4-xato).
  • Literal union (holat — 2.4, 3-xato).
  • extends (DRY — bazaviy — 2.7).
  • as const (enum muqobili — 2.11).
  • implements (shartnoma — 2.8).

"Tayyor" mezonlari (acceptance criteria)

  • Asosiy turlar (array, tuple).
  • Domen interface'lari (extends bilan).
  • Union literal (status/rol).
  • Type alias (union, funksiya, tuple).
  • Intersection.
  • Enum/union/as const taqqoslangan.
  • Class implements interface.
  • interface vs type to'g'ri tanlangan.
  • Discriminated union.
  • strict (any'siz, null xavfsiz).

Yechim kodi ataylab berilmagan — bu loyihani o'zingiz yozib ko'ring.

10. Xulosa va keyingi bobga ko'prik

Bu bobda TS turlar tizimining asosini o'rgandik:

  • Asosiy turlar (primitiv, array, tuple — 2.1, 2.2); inference; maxsus (any/unknown/void/never — 2.3); union (| — 2.4).
  • Interface (obyekt shakli — 2.5; metod — 2.6; extends — 2.7; class implements — 2.8).
  • Enum (nomlangan konstantalar — 2.9; union literal/as const muqobil); Type alias (istalgan tur — 2.11); intersection (& — 2.12); literal 2.13-bob.
  • Interface vs type (obyektinterface, union/utilitytype — 2.10); index signature 2.14-bob.

Keyingi bob — 7.3-bob: Funksiyalar va Generics (chuqur). Turlar asosini bildik; endi funksiya turlarini (parametr, qaytish, overload) va TS'ning eng kuchli xususiyatini — generics (turlarni parametrlash — qayta ishlatiladigan, tur-xavfsiz kod) — chuqur o'rganamiz. Generics — ORM (Repository), React (useState), utility'lar — hamma joyda.

Foydalanilgan rasmiy/ishonchli manbalar

  • typescriptlang.org — Everyday Types, Interfaces, Type Aliases, Enums
  • LogRocket / iloveblogs — Interface vs Type (2026 best practices); W3Schools — TS types
  • GeeksforGeeks — type aliases vs interfaces; typescriptlang — types vs interfaces

Izohlar (0)

Izoh yozish uchun kiring.

  • Hozircha izoh yo'q. Birinchi bo'ling!
7.2-bob: Asosiy turlar, interface, type alias, enum — Wisar