WisarWisar
Dasturlash kitobi/7-QISM — TypeScript17 daqiqa

7.1-bob: TypeScript kirish — nega TS, o'rnatish, tsconfig

7-QISM — TypeScript · 1-mavzu

1. Kirish va motivatsiya

JavaScript'ni (2-QISM) chuqur, backend (5) va DB (6) ni amalda o'rgandik. Yo'lda ko'p marta TypeScriptni ko'rdik: Prisma 6.12-bob type-safe, TypeORM 6.13-bob dekorator, NestJS (8) butunlay TS'da. Endi TypeScript'ni boshidan, chuqur, mustaqil o'rganamiz. Bu — zamonaviy backend (NestJS — 8) va frontend (React — 11) ning majburiy poydevori. 2026-yilda professional dasturchilarning 67% TypeScript ishlatadi; ko'p ish e'loni uni talab qiladi.

TypeScript (TS) — JavaScript'ning ustqurmasi (superset): JS'ning hammasi + statik tiplar (static typing). JS — dinamik (turlar runtime'da, ishlatishda aniqlanadi); TS — statik (turlar oldindan, kompilyatsiyada tekshiriladi). Bu degani: xatolarni foydalanuvchiga yetishidan oldin (yozish paytida, IDE'da) ushlaysiz. user.emial (typo) — JS'da runtime'da undefined (xato keyin bilinadi); TS'da — darrov qizil chiziq (kompilyatsiya xatosi).

TS to'g'ridan ishlamaydi — u JavaScript'ga kompilyatsiya (transpile) qilinadi (brauzer/Node faqat JS tushunadi). Yozasiz .ts tsc (TypeScript compiler) .js ishlaydi. Bu — qo'shimcha qadam, lekin foydasi katta: kam xato, yaxshi IDE yordami (autocompletion, refactoring), o'qiladigan kod (turlar — hujjat). Bu bob: nega TS, o'rnatish, tsc, va tsconfig (sozlama) — chuqur. 7-QISM poydevori.

O'xshatish: JavaScript — imlo tekshiruvisiz yozish (xatoni faqat keyin, kimdir o'qiganda topasiz). TypeScript — imlo va grammatika tekshiruvi yoqilgan muharrir (yozayotganda darrov "bu so'z xato", "bu gap noto'g'ri" deb ko'rsatadi). Yozish biroz sekinroq (qoidalarga rioya), lekin natija — xatosiz, ishonchli matn. Katta hujjat (loyiha) uchun — bebaho.

Nega muhim?

  • Xatolarni erta ushlash — kompilyatsiyada (runtime'da emas), foydalanuvchiga yetmasdan.
  • Stack majburiyati — NestJS (8), Prisma 6.12-bob, React (11) — TS bilan.
  • Sanoat standarti — 67% dasturchi; ko'p ish TS talab qiladi.
  • DX — autocompletion, refactoring, kod "o'zini hujjatlaydi".

2. Nazariya — chuqur tushuntirish

2.1. JS muammosi — dinamik tiplar

JavaScript dinamik tipli (2.1-JS) — o'zgaruvchining turi runtime'da, ishlatishda aniqlanadi:

js
// JavaScript — tur tekshiruvi yo'q (xato runtime'da)
function summa(a, b) { return a + b; }
summa(5, 3);          // 8 
summa("5", 3);        // "53"  (string konkatenatsiya — kutilmagan!)
summa(5);             // NaN  (b undefined)

const user = { ism: "Ali" };
console.log(user.emial);   // undefined  (typo — lekin xato bermaydi!)

JS muammosi: xato runtime'da (ishlatishda) bilinadi — ko'pincha foydalanuvchida (production'da). user.emial (typo) — JS jim undefined qaytaradi (keyin "nega ishlamayapti?" — soatlab debug). Katta loyihada bu — ko'p, qimmat xato.

2.2. TypeScript yechimi — statik tiplar

TypeScript turlarni oldindan (kompilyatsiyada) tekshiradi:

ts
// TypeScript — tur tekshiruvi (xato KOMPILYATSIYADA)
function summa(a: number, b: number): number { return a + b; }
summa(5, 3);          // 8 
summa("5", 3);        //  KOMPILYATSIYA xatosi (darrov, yozayotganda!)
summa(5);             //  xato (b kerak)

const user = { ism: "Ali" };
console.log(user.emial);   //  "Property 'emial' does not exist" (typo darrov!)

TS yechimi: turlar kompilyatsiyada (yozish paytida — IDE'da qizil chiziq) tekshiriladi. Xato foydalanuvchiga yetmaydi (oldin ushlanadi). Bu — eng katta afzallik: ishonchlilik. Ayniqsa katta, jamoaviy loyihada (NestJS — 8).

2.3. TS — JS ustqurmasi (superset)

TypeScript = JavaScript + tiplar:

text
  ┌─────────────────────────┐
  │      TypeScript          │
  │  ┌──────────────────┐    │
  │  │   JavaScript     │    │    TS JS'ni O'Z ICHIGA OLADI
  │  │  (hammasi)       │    │
  │  └──────────────────┘    │
  │  + tiplar, interface,    │    qo'shimcha (TS xususiyatlari)
  │    generics, enum...     │
  └─────────────────────────┘

   Har qanday JS kod — TO'G'RI TS kod ham (superset)
   JS bilimingiz (2-QISM) — TS'da to'liq ishlaydi

Superset mohiyati: TS — JS'ning "kengaytmasi" (ustiga qurilgan). Mavjud JS kod — TS'da ham ishlaydi (.js .ts o'zgartirsangiz, ishlaydi). TS faqat qo'shadi (tiplar), olib tashlamaydi. Shuning uchun JS'ni (2-QISM) bilsangiz — TS oson.

2.4. Kompilyatsiya (transpilatsiya)

TS to'g'ridan ishlamaydi — JS'ga kompilyatsiya qilinadi:

text
  app.ts  ──(tsc — TypeScript compiler)──▶  app.js  ──(Node/brauzer)──▶ ishlaydi

  - Brauzer/Node faqat JS tushunadi (TS emas)
  - tsc TS'ni JS'ga "tarjima" qiladi (transpile)
  - Tiplar — KOMPILYATSIYADA tekshiriladi, keyin OLIB TASHLANADI (JS'da tur yo'q)

Tiplar runtime'da yo'q (type erasure): TS tiplari faqat kompilyatsiyada (tekshirish uchun). Kompilyatsiyadan keyin — oddiy JS (tur yo'q). Demak, tur tekshiruvi — yozish vaqtida, runtime'da emas. (Runtime validatsiya uchun — Zod — 5.9.) Bu — muhim tushuncha.

2.5. O'rnatish

bash
npm install -D typescript          # TS compiler (dev dependency — 5.2)
npx tsc --version                  # versiyani tekshirish

# Ishga tushirish vositalari:
npm install -D tsx                 # TS'ni to'g'ridan ishga tushirish (dev — tez)
npm install -D ts-node             # muqobil (TS'ni Node'da)

typescript — compiler (tsc). tsx (yoki ts-node) — TS'ni to'g'ridan ishga tushirish (kompilyatsiya + ishga tushirish bir qadamda — dev uchun qulay). Production'da — tsc bilan build (JS) Node JS'ni ishga tushiradi.

2.6. Birinchi TS dasturi

ts
// hello.ts
function salomlash(ism: string): string {     // ism — string; qaytaradi string
  return `Salom, ${ism}!`;
}
console.log(salomlash("Ali"));
// salomlash(42);   //  kompilyatsiya xatosi (number, string emas)
bash
npx tsc hello.ts        #  hello.js (kompilyatsiya)
node hello.js           # ishga tushirish
# yoki bir qadamda:
npx tsx hello.ts        # to'g'ridan (dev)

2.7. tsconfig.json — TS sozlamasi

tsconfig.json — TypeScript loyihasining markaziy sozlama fayli:

bash
npx tsc --init          # tsconfig.json yaratadi (ko'p izoh bilan)
json
{
  "compilerOptions": {
    "target": "ES2022",            // qaysi JS versiyasiga kompilyatsiya
    "module": "NodeNext",          // modul tizimi (Node uchun)
    "outDir": "./dist",            // JS qayerga (chiqish)
    "rootDir": "./src",            // TS qayerda (kirish)
    "strict": true,                // QAT'IY rejim (eng muhim — 2.8)
    "esModuleInterop": true,       // import qulayligi
    "skipLibCheck": true           // kutubxona turlarini tekshirmaslik (tez)
  },
  "include": ["src/**/*"]          // qaysi fayllar
}

tsconfig — TS'ning xulqini boshqaradi (qanday kompilyatsiya, qanchalik qat'iy). Eng muhim — strict: true 2.8-bob. target (JS versiyasi), outDir/rootDir (papkalar), module (modul tizimi — 2.16-JS). Bu — har TS loyihaning yuragi.

2.8. strict rejim (eng muhim sozlama)

strict: true — TS'ning to'liq kuchi (bir nechta qat'iy tekshiruvni yoqadi):

text
  strict: true yoqadigan asosiy tekshiruvlar:
  - noImplicitAny: har narsa tipli bo'lsin (yashirin "any" yo'q — 2.9)
  - strictNullChecks: null/undefined alohida tekshiriladi (eng muhim! — 2.10)
  - strictFunctionTypes, strictBindCallApply, ...

   strict'siz TS — "yarim TS" (ko'p foyda yo'qoladi)
   DOIM strict: true (yangi loyiha)

strict: true DOIM yoq (yangi loyiha): u TS'ning asosiy foydasini beradi (null tekshiruv, any yo'q). strict: false — TS'ning yarmi (xatolar o'tib ketadi). Boshlovchilarga qiyinroq, lekin to'g'ri (xatolarni ushlaydi). Mavjud JS'ni migratsiya qilganda — bosqichma-bosqich yoqish mumkin.

2.9. any — TS'ning "qochish yo'li" (ehtiyot)

any — "har qanday tur" (tur tekshiruvini o'chiradi):

ts
let x: any = 5;
x = "matn";       // OK (any — har narsa)
x.foo.bar.baz;    // OK (tekshirilmaydi — xavfli!)

// any — TS'ni "o'chiradi" (JS'ga qaytaradi)

anydan qoch (eng muhim qoida): any — tur tekshiruvini o'chiradi (TS'ning foydasi yo'qoladi — "any-script"). Vaqtincha (migratsiya) yoki haqiqatan noma'lum (kamdan-kam). O'rniga — aniq tur yoki unknown (xavfsizroq — 2.10-bob: type narrowing). noImplicitAny (strict) — yashirin any'ni taqiqlaydi.

2.10. strictNullChecks — null xavfsizligi

strictNullChecks (strict ichida) — null/undefinedni alohida tekshiradi:

ts
function uzunlik(matn: string): number {
  return matn.length;
}
uzunlik(null);    //  kompilyatsiya xatosi (null — string emas)

// null bo'lishi mumkin bo'lsa — aniq belgilash (union — 2.11-bob)
function xavfsiz(matn: string | null): number {
  if (matn === null) return 0;   // tekshirish MAJBURIY (narrowing)
  return matn.length;             // bu yerda matn — string (null emas)
}

strictNullChecks — TS'ning eng qimmat tekshiruvi: "null/undefined xatolari" (JS'da "Cannot read property of null" — eng ko'p xato) ni kompilyatsiyada ushlaydi. string | null — null bo'lishi mumkinligini aniq belgilaysiz, va ishlatishdan oldin tekshirasiz. Bu — "billion dollar mistake" (null) ni hal qiladi.

2.11. Build jarayoni (production)

text
  Development:
  tsx/ts-node — TS'ni to'g'ridan (kompilyatsiya + ishga tushirish — tez)

  Production:
  1. tsc — TS  JS (dist/ papkaga build)
  2. node dist/index.js — JS'ni ishga tushirish

  package.json 5.2-bob:
  "scripts": {
    "dev": "tsx watch src/index.ts",
    "build": "tsc",
    "start": "node dist/index.js"
  }

Dev vs production: dev'da tsx/ts-node (tez, to'g'ridan). Production'da — tsc build (JS — dist/) node (JS). Sababi: production'da kompilyatsiya bir marta (build), keyin tez JS. Zamonaviy: tsx, esbuild, swc (tez compilerlar).

2.12. TS Node/Express loyihasida (7.7 ko'prik)

text
  TS backend loyiha tuzilishi:
  src/
    index.ts       — entry
    routes/, services/, models/   — TS fayllar
  tsconfig.json    — sozlama 2.7-bob
  dist/            — build natija (JS — git'da emas)
  package.json     — scripts 2.11-bob

  @types/* paketlar — kutubxona turlari (2.13)

TS bilan Node/Express 5.6-bob — 7.7-bobda chuqur. Asosiy: tsconfig, @types 2.13-bob, build/dev scriptlar. NestJS (8) — TS'ni o'rnatib beradi (sozlash kerak emas).

2.13. @types — kutubxona turlari (DefinitelyTyped)

bash
npm install express
npm install -D @types/express      # Express turlari (alohida)
npm install -D @types/node          # Node turlari

Ko'p JS kutubxona (Express) o'zida tur bermaydi @types/X (DefinitelyTyped — jamoa yozgan turlar). Zamonaviy kutubxonalar (Prisma, Zod) — turlarni o'zida beradi (@types kerak emas). @types/node — Node API turlari (har TS Node loyihada).

2.14. TS afzalliklari va kamchiliklari

text
   Afzallik:
  - Xatolarni erta ushlash (kompilyatsiya — 2.2)
  - IDE yordami (autocompletion, refactoring, navigatsiya)
  - Kod "o'zini hujjatlaydi" (turlar — niyat aniq)
  - Katta/jamoaviy loyihada xavfsiz (refactoring)

   Kamchilik:
  - Qo'shimcha sozlash (tsconfig, build — 2.7, 2.11)
  - Yozish biroz sekinroq (turlar)
  - O'rganish (tiplar tizimi)
  - Kichik/qisqa loyihada ortiqcha bo'lishi mumkin

Qachon TS: katta, uzoq muddatli, jamoaviy loyiha — TS (afzalligi katta). Kichik skript, tez prototip — JS yetishi mumkin. Lekin zamonaviy trend — TS default (NestJS, React loyihalar). Sizning stack'ingiz TS talab qiladi.

2.15. Migratsiya (JS TS)

text
  Mavjud JS loyihani TS'ga o'tkazish (bosqichma-bosqich):
  1. typescript o'rnat, tsconfig (allowJs: true — JS va TS birga)
  2. Fayllarni birma-bir .js  .ts
  3. Turlarni qo'sh (any'dan aniq tur'ga)
  4. strict'ni bosqichma-bosqich yoq

   allowJs: true — JS va TS birga ishlaydi (gradual — contentful)

allowJs: true — JS va TS bir loyihada birga (migratsiya uchun). Birma-bir .js .ts, tur qo'shish. Bir martada hammasi emas — bosqichma-bosqich (katta loyihada).

2.16. Best practices (kirish darajasida)

text
   strict: true DOIM 2.8-bob — TS'ning to'liq foydasi
   any'dan qoch (unknown yoki aniq tur — 2.9)
   strictNullChecks (null xavfsizligi — 2.10)
   @types/* kutubxona turlari 2.13-bob
   Dev: tsx; production: tsc build 2.11-bob
   tsconfig'ni loyihaga sozla (target, module — 2.7)
   Turlar — hujjat (kod o'zini tushuntiradi — 2.14)

3. Sintaksis — tez ma'lumotnoma

ts
// Asosiy tur belgilash
let yosh: number = 25;
let ism: string = "Ali";
function summa(a: number, b: number): number { return a + b; }

// null xavfsizligi (2.10)
let matn: string | null = null;
if (matn) matn.length;            // tekshir (narrowing)
bash
npm install -D typescript tsx     # o'rnatish (2.5)
npx tsc --init                    # tsconfig (2.7)
npx tsc                           # build (TS  JS)
npx tsx src/index.ts              # dev (to'g'ridan — 2.11)
json
// tsconfig.json 2.7-bob: { "compilerOptions": { "strict": true, "target": "ES2022", "outDir": "./dist" } }

4. Batafsil kod namunalari

Misol 1 — JS vs TS (xato ushlash — 2.1, 2.2)

ts
// JavaScript'da (xato runtime'da — 2.1):
// function narx(soni, narxi) { return soni * narxi; }
// narx("5", 10);   // "5" * 10 = 50 (tasodifan ishladi), narx(5)  NaN (jim xato)

// TypeScript'da (xato kompilyatsiyada — 2.2):
function narx(soni: number, narxi: number): number {
  return soni * narxi;
}
narx(5, 10);        // 50 
// narx("5", 10);   //  Argument 'string' is not assignable to 'number'
// narx(5);         //  Expected 2 arguments, but got 1

Misol 2 — tsconfig.json (to'liq — 2.7)

json
{
  "compilerOptions": {
    "target": "ES2022",                // zamonaviy JS (2.7)
    "module": "NodeNext",              // Node modul tizimi
    "moduleResolution": "NodeNext",
    "outDir": "./dist",                // build natija (2.11)
    "rootDir": "./src",                // manba
    "strict": true,                    // QAT'IY 2.8-bob — eng muhim
    "esModuleInterop": true,           // import qulaylik
    "forceConsistentCasingInFileNames": true,
    "skipLibCheck": true,              // kutubxona turlarini tekshirmaslik (tez)
    "resolveJsonModule": true,         // JSON import
    "declaration": true,               // .d.ts yaratish (kutubxona — 7.6)
    "sourceMap": true                  // debug uchun (TS  JS xarita)
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules", "dist"]
}

Misol 3 — null xavfsizligi (strictNullChecks — 2.10)

ts
// Foydalanuvchini topish (bo'lmasligi mumkin — null)
function userTop(id: number): { ism: string } | null {
  const users = [{ id: 1, ism: "Ali" }];
  return users.find((u) => u.id === id) ?? null;   // topilmasa null
}

const user = userTop(5);
// console.log(user.ism);   //  "Object is possibly 'null'" (TS ushlaydi! — 2.10)

if (user) {                                          // tekshirish (narrowing)
  console.log(user.ism);                             //  bu yerda user — null emas
}
// yoki: console.log(user?.ism);                     // optional chaining (2.1-JS)

Misol 4 — any vs unknown (2.9)

ts
//  any — tekshiruvni o'chiradi (xavfli — 2.9)
function yomon(data: any) {
  return data.foo.bar;   // OK (lekin runtime'da xato bo'lishi mumkin)
}

//  unknown — tekshirishni MAJBUR qiladi (xavfsiz)
function yaxshi(data: unknown) {
  // return data.foo;   //  "Object is of type 'unknown'"
  if (typeof data === "object" && data !== null && "foo" in data) {
    // bu yerda data tekshirilgan (xavfsiz)
  }
}

Misol 5 — package.json scripts (2.11)

json
{
  "name": "ts-backend",
  "type": "module",
  "scripts": {
    "dev": "tsx watch src/index.ts",        // dev — to'g'ridan, o'zgarishni kuzatadi (2.11)
    "build": "tsc",                          // production build (TS  dist/)
    "start": "node dist/index.js",           // production ishga tushirish
    "typecheck": "tsc --noEmit"              // faqat tur tekshirish (build'siz — CI)
  },
  "devDependencies": {
    "typescript": "^5.7.0",
    "tsx": "^4.19.0",
    "@types/node": "^22.0.0"
  }
}

Misol 6 — TS Express (kirish — 7.7 ga — 2.12)

ts
// src/index.ts (TS + Express — 5.6)
import express, { Request, Response } from "express";   // @types/express (2.13)

const app = express();
app.use(express.json());

// req, res — tipli (autocompletion, tur tekshiruvi)
app.get("/api/users/:id", (req: Request, res: Response) => {
  const id: number = Number(req.params.id);             // tur aniq
  res.json({ id, ism: "Ali" });
});

const PORT: number = Number(process.env.PORT) || 3000;
app.listen(PORT, () => console.log(`Server ${PORT}-portda`));

Misol 7 — Funksiya turlari (2.6)

ts
// Parametr va qaytish turi
function kvadrat(n: number): number { return n * n; }

// Arrow function (2.3-JS)
const kub = (n: number): number => n ** 3;

// Ixtiyoriy parametr (?) va default
function salom(ism: string, familiya?: string): string {   // familiya ixtiyoriy
  return familiya ? `${ism} ${familiya}` : ism;
}

// void — hech narsa qaytarmaydi
function log(xabar: string): void {
  console.log(xabar);
}

Misol 8 — Migratsiya (allowJs — 2.15)

json
// tsconfig.json — JS va TS birga (migratsiya — 2.15)
{
  "compilerOptions": {
    "allowJs": true,                   // .js fayllar ham (JS + TS birga)
    "checkJs": false,                  // JS'ni tekshirmaslik (boshda)
    "strict": true,
    "outDir": "./dist"
  },
  "include": ["src/**/*"]
}
// Birma-bir .js  .ts; tur qo'sh; keyin checkJs: true

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

1) strict: false (TS'ning yarmi)

json
//  strict o'chiq (ko'p xato o'tib ketadi — 2.8)
{ "compilerOptions": { "strict": false } }

//  strict: true
{ "compilerOptions": { "strict": true } }

2) any'ni ishlatish

ts
//  any (tekshiruv o'chadi — 2.9)
function f(data: any) { return data.x; }

//  aniq tur yoki unknown
function f(data: { x: number }) { return data.x; }

3) null'ni tekshirmaslik

ts
//  null bo'lishi mumkin (2.10)
const user = userTop(5);
console.log(user.ism);   // crash agar null

//  tekshir
if (user) console.log(user.ism);

4) Production'da tsx/ts-node

text
 production'da tsx (har safar kompilyatsiya — sekin)
 tsc build (JS)  node (2.11)

5) @types unutish

ts
//  @types yo'q  "Could not find declaration file" (2.13)
import express from "express";

//  npm i -D @types/express

6. Keng tarqalgan xatolar va yechimlari

Xato 1 — Cannot find module ... or its type declarations

Sababi: @types/X o'rnatilmagan 2.13-bob. Yechimi: npm i -D @types/X; zamonaviy kutubxona — o'zida tur.

Xato 2 — Object is possibly 'null'/'undefined'

Sababi: strictNullChecks — null tekshirilmagan 2.10-bob. Yechimi: if (x), x?., x ?? default (narrowing).

Xato 3 — Parameter implicitly has an 'any' type

Sababi: noImplicitAny — tur belgilanmagan (2.8, 2.9). Yechimi: aniq tur belgila (a: number).

Xato 4 — Type 'string' is not assignable to type 'number'

Sababi: tur mos emas 2.2-bob. Yechimi: to'g'ri tur; yoki aylantirish (Number(x)).

Xato 5 — TS kod ishlamaydi (node app.ts)

Sababi: Node TS tushunmaydi 2.4-bob. Yechimi: tsx app.ts (dev) yoki tsc node app.js.

Xato 6 — tsconfig topilmadi/ishlamaydi

Sababi: tsconfig.json yo'q yoki noto'g'ri joyda. Yechimi: npx tsc --init; loyiha ildizida.

7. Integratsiya — bu mavzu stack'ning qayerida uchraydi

  • JavaScript (2-QISM): TS — JS ustqurmasi.
  • npm/package.json 5.2-bob: typescript, @types, scripts.
  • Modullar (2.16-JS): TS module (NodeNext).
  • Prisma/TypeORM (6.12, 6.13): TS — type-safety.
  • NestJS (8): butunlay TS (dekorator).
  • React (11): TS bilan 11.14-bob.
  • Zod 5.9-bob: runtime validatsiya (TS — kompilyatsiya).
  • Keyingi TS boblar (7.2-7.7): turlar, generics, decorators.
  • CI/CD (10): typecheck (tsc --noEmit).

8. Eng yaxshi amaliyotlar (best practices)

  • strict: true DOIM (TS to'liq foydasi — 2.8).
  • anydan qoching (unknown yoki aniq tur — 2.9).
  • null'ni tekshiring (strictNullChecks — narrowing — 2.10).
  • @types/* kutubxona turlari 2.13-bob.
  • Dev: tsx; production: tsc build 2.11-bob.
  • tsconfig'ni loyihaga sozlang (target, module, outDir — 2.7).
  • Turlardan hujjat sifatida foydalaning (kod o'zini tushuntiradi — 2.14).
  • typecheck CI'da (tsc --noEmit — 10).
  • Migratsiya bosqichma-bosqich (allowJs — 2.15).
  • Zamonaviy compiler (tsx/esbuild — tez — 2.11).

9. Amaliy loyiha: "TypeScript Loyiha Sozlash"

TypeScript asoslarini va sozlashni mustahkamlash.

Maqsad

TypeScript loyihasini noldan to'g'ri sozlash: tsconfig (strict), build/dev oqimi, va oddiy tipli dastur.

Talablar (requirements)

  1. O'rnatish: typescript, tsx, @types/node (Misol 5, 2.5).
  2. tsconfig: strict: true, target, outDir, rootDir (Misol 2, 2.7, 2.8).
  3. package.json scripts: dev (tsx watch), build (tsc), start, typecheck (Misol 5, 2.11).
  4. Tipli funksiyalar: parametr/qaytish turlari; ixtiyoriy parametr (Misol 7, 2.6).
  5. null xavfsizligi: topish funksiyasi (null qaytaradi) + tekshirish (Misol 3, 2.10).
  6. any o'rniga unknown: noma'lum ma'lumotni xavfsiz ishlash (Misol 4, 2.9).
  7. Oddiy TS Express (bonus): tipli req/res (Misol 6, 2.12).
  8. Build test: tsc dist/ node (production oqimi — 2.11).
  9. Xato test: ataylab tur xatosi qil, TS ushlashini ko'r 2.2-bob.

Maslahatlar (hint)

  • tsc --init strict: true (2.7, 2.8, 1-xato).
  • Dev: tsx watch (2.11, 4-xato).
  • null: | null + if (x) (2.10, 2-xato).
  • any o'rniga unknown (2.9, 2-holat).
  • @types/node, @types/express (2.13, 5-xato).
  • Production: tsc build node dist 2.11-bob.

"Tayyor" mezonlari (acceptance criteria)

  • typescript + tsx o'rnatilgan.
  • tsconfig (strict: true).
  • scripts (dev/build/start/typecheck).
  • Tipli funksiyalar (parametr/qaytish).
  • null xavfsizligi (tekshirish bilan).
  • unknown (any o'rniga).
  • (Bonus) tipli Express.
  • Build (tsc node) ishlaydi.
  • Tur xatosi kompilyatsiyada ushlanadi.

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

10. Xulosa va keyingi bobga ko'prik

Bu bobda TypeScript poydevorini o'rgandik:

  • JS muammosi (dinamik — xato runtime'da — 2.1) TS yechimi (statik — xato kompilyatsiyada — 2.2).
  • TS = JS + tiplar (superset — 2.3); kompilyatsiya (TS JS, tiplar erase — 2.4); o'rnatish 2.5-bob.
  • tsconfig (markaziy sozlama — 2.7); strict: true (eng muhim — 2.8); anydan qoch 2.9-bob; strictNullChecks (null xavfsizligi — 2.10).
  • Build (dev: tsx; prod: tsc — 2.11); @types (kutubxona turlari — 2.13); migratsiya (allowJs — 2.15).

Keyingi bob — 7.2-bob: Asosiy turlar, interface, type alias, enum. TS'ni sozlashni bildik; endi uning yuragiga — turlar tizimiga — kiramiz. Asosiy turlar (string, number, array, tuple, object), interface (obyekt shakli), type alias, va enum (nomlangan konstantalar) — chuqur. Bu — TS bilan haqiqiy ishlashning boshlanishi.

Foydalanilgan rasmiy/ishonchli manbalar

  • typescriptlang.org — TypeScript (tsconfig, compiler options, strict); Contentful — TS vs JS
  • Sencha / Technource — TypeScript vs JavaScript 2026 (statik tiplar, kompilyatsiya)
  • tech-insider — TypeScript adoption 2026 (67% dasturchi)

Izohlar (0)

Izoh yozish uchun kiring.

  • Hozircha izoh yo'q. Birinchi bo'ling!
7.1-bob: TypeScript kirish — nega TS, o'rnatish, tsconfig — Wisar