Series: TypeScript Basics Lesson 78

tsconfig.json: asosiy sozlamalar

tsconfig.json'ning asosiy sozlamalari batafsil: include, exclude, rootDir, outDir, target, module, moduleResolution, lib, strict oilasi, noUnusedLocals/Parameters va Node hamda Vite uchun tayyor shablonlar.

78-dars

tsconfig.json: asosiy sozlamalar

Barcha sozlamalar tsconfig.json faylida turadi (77-dars). Ular uch guruhga bo'linadi:

{
  "include": ["src"],              // QAYSI fayllar
  "exclude": ["node_modules"],
  "compilerOptions": {
    "rootDir": "src",              // QAYERDAN → QAYERGA
    "outDir": "dist",
    "target": "ES2022",            // QANDAY JS chiqadi
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "lib": ["ES2022"],
    "strict": true,                // QANCHALIK qattiq tekshiradi
    "noUnusedLocals": true,
    "noUnusedParameters": true
  }
}

1-qism: Qaysi fayllar va qayerga

include

TypeScript qaysi fayllarni kompilyatsiya qilishini belgilaydi. Glob pattern bilan yoziladi:

  • * — istalgan fayl nomi (/'siz)
  • **/ — istalgan chuqurlikdagi papka
  • ? — bitta belgi
"include": ["src/**/*", "types/**/*.d.ts"]

Agar include yozilmasa, default qiymat ["**/*"] bo'ladi, ya'ni loyihadagi hamma .ts fayllar olinadi.

exclude

include topgan fayllardan qaysilarini chiqarib tashlashni belgilaydi.

"exclude": ["node_modules", "dist", "**/*.test.ts"]

Default holatda node_modules, bower_components, jspm_packages va outDir chiqarib tashlanadi.

⚠️ Muhim nuqta: exclude faqat include ro'yxatini filtrlaydi. Agar chiqarib tashlangan faylni boshqa fayl import qilsa, u baribir kompilyatsiyaga kiradi. exclude "bu faylni umuman ishlatma" degani emas.

rootDir

Manba (source) fayllarning ildiz papkasi. TypeScript chiqadigan fayllarda papka tuzilmasini shu papkaga nisbatan saqlaydi.

outDir

Kompilyatsiya qilingan .js fayllar yoziladigan papka.

rootDir va outDir birga ishlaydi. rootDir: "src", outDir: "dist" bo'lsa:

src/index.ts          →  dist/index.js
src/utils/math.ts     →  dist/utils/math.js

rootDir yozilmasa, TS uni barcha fayllarning umumiy papkasidan o'zi hisoblaydi. Shunda kutilmagan natija bo'lishi mumkin: masalan, ildizda config.ts bo'lsa, natija dist/src/index.js ko'rinishida chiqadi. Shuning uchun rootDir'ni aniq yozib qo'yish yaxshi odat. rootDir'dan tashqaridagi fayl import qilinsa, TS xato beradi.

2-qism: Qanday JavaScript chiqadi

target

Chiqadigan JS sintaksisining versiyasi: ES5, ES2015 (ES6), ES2016 … ES2024, ESNext.

// Manba
const greet = async (name?: string) => name ?? "mehmon";
  • target: "ES2022" bo'lsa, kod deyarli o'zgarishsiz chiqadi.
  • target: "ES5" bo'lsa, arrow function function'ga, const esa var'ga aylanadi, async va ?? uzun yordamchi kodga o'giriladi.

target faqat sintaksisni pastga tushiradi. U polyfill qo'shmaydi. Masalan, Array.prototype.includes ES5'da yo'q, lekin TS uni qo'shib bermaydi.

Qoida: kodingiz ishlaydigan muhit qo'llaydigan eng yangi versiyani tanlang. Zamonaviy Node va brauzerlar uchun odatda ES2022 yetarli.

module

Nima uchun kerak: import/export yozgan kodingiz chiqishda qaysi modul tizimiga o'giriladi. JavaScript tarixida bir nechta modul tizimi bo'lgan, shuning uchun bu sozlama mavjud.

Bir xil manba turli module qiymatlarida qanday chiqishini ko'ramiz:

import { sum } from "./math";
export const total = sum(1, 2);

CommonJS — Node.js'ning eski, klassik tizimi:

const math_1 = require("./math");
exports.total = (0, math_1.sum)(1, 2);

Eski Node loyihalarida va package.json'da "type": "module" bo'lmagan paketlarda ishlatiladi.

ES2015 / ES2020 / ES2022 / ESNext — standart ES modullar. import/export o'zgarishsiz qoladi:

import { sum } from "./math";
export const total = sum(1, 2);

Ular orasidagi farq qo'llanadigan imkoniyatlarda:

Qiymat Nimani qo'shadi
ES2015 oddiy import/export
ES2020 dinamik import(), import.meta
ES2022 top-level await
ESNext eng so'nggi imkoniyatlar

Bular brauzer va bundler (Vite, webpack) bilan ishlaydigan frontend loyihalar uchun.

Node16 / Node18 / Node20 / NodeNext — zamonaviy Node.js uchun. Bu tur aralash ishlaydi: har bir fayl uchun alohida qaror qiladi.

  • package.json'da "type": "module" bo'lsa yoki fayl .mts bo'lsa, ESM chiqadi.
  • Aks holda yoki fayl .cts bo'lsa, CommonJS chiqadi.

Node.js'ning o'zi ham aynan shu qoida bo'yicha ishlaydi, shuning uchun backend/Node loyihalar uchun eng to'g'ri tanlov shu. NodeNext doim eng so'nggi Node xatti-harakatini kuzatadi.

Preserve (TS 5.4+) — import/export'ni yozganingizdek qoldiradi va hech narsani o'zgartirmaydi. Kodni keyin bundler (Vite, esbuild, Bun) qayta ishlaydigan holatlar uchun mo'ljallangan.

AMD, UMD, System — eski brauzer modul yuklagichlari (RequireJS, SystemJS). Hozir deyarli ishlatilmaydi, yangi TS versiyalarida eskirgan (deprecated) deb belgilangan.

None — modul tizimi yo'q.

Qisqa qoida:

  • Node backend uchun: NodeNext
  • Vite/webpack bilan frontend uchun: ESNext yoki Preserve
  • Eski Node/CJS kutubxona uchun: CommonJS

moduleResolution

Nima uchun kerak: module chiqish formatini belgilasa, moduleResolution TS'ning import yo'lidagi faylni qanday topishini belgilaydi (75-dars).

import express from "express"; // qaysi fayl? node_modules/express/... ichidan qayeri?
import { sum } from "./math";  // math.ts? math/index.ts? .js kengaytmasi kerakmi?

classic — TS'ning eng birinchi algoritmi. node_modules'ni to'g'ri qidirmaydi. Bugun ishlatilmaydi.

node10 (eski nomi node) — eski Node.js'ning CommonJS algoritmi:

  • ./math yozsangiz, ketma-ket math.ts, math.d.ts, math/index.ts qidiriladi.
  • node_modules ichida package.json'dagi main/types maydonlariga qaraydi.
  • ❌ package.json'dagi exports maydonini tushunmaydi. Zamonaviy paketlar esa aynan shu maydondan foydalanadi, shuning uchun bu variant eskirgan.

node16 / nodenext — zamonaviy Node.js algoritmi:

  • ✅ package.json'dagi exports va imports maydonlarini tushunadi.
  • ESM fayllarda kengaytma majburiy, xuddi Node.js'ning o'zidagidek:
import { sum } from "./math.js"; // ✅ (ha, .ts emas, .js yoziladi!)
import { sum } from "./math";    // ❌ ESM'da xato

module: "NodeNext" bilan birga ishlatiladi. Aslida TS shu juftlikni majburiy qiladi.

bundler (TS 5.0+) — bundler (Vite, webpack, esbuild) qanday qidirsa, shunday ishlaydi:

  • ✅ exports maydonini tushunadi.
  • ✅ Kengaytma shart emas: import "./math" ishlaydi.

Frontend loyihalar uchun mo'ljallangan. module: "ESNext" yoki "Preserve" bilan juftlanadi.

To'g'ri juftliklar:

Loyiha turi module moduleResolution
Node.js backend NodeNext NodeNext
Vite / webpack / frontend ESNext yoki Preserve bundler
Eski CJS loyiha CommonJS node10 (eskirgan)

lib

Nima uchun kerak: TS kodingizdagi tayyor (built-in) API'larning type'larini qayerdan bilishini belgilaydi. Promise, Map, Array.prototype.at, document, window, fetch kabi narsalar shular jumlasiga kiradi.

document.getElementById("app"); // "DOM" lib bo'lmasa: Cannot find name 'document'.
[1, 2, 3].at(-1);                // "ES2022" lib bo'lmasa: Property 'at' does not exist on type 'number[]'.

⚠️ lib faqat type'larni beradi va hech qanday kod qo'shmaydi. U TS'ga "bu muhitda shu narsalar mavjud deb hisobla" deydi.

Turlari:

ECMAScript versiyalari: ES5, ES2015, ES2016 … ES2024, ESNext. Har biri o'zidan oldingilarni ham o'z ichiga oladi (ES2020'ga ES2015 ham kiradi).

Muhit (environment) lib'lari:

Lib Nima beradi Qachon kerak
DOM document, window, HTMLElement, fetch Brauzer kodi
DOM.Iterable NodeList'ni for...of bilan aylanish Brauzer kodi
WebWorker Web Worker API Worker fayllar
ScriptHost Windows Script Host Deyarli hech qachon

Mayda (granular) lib'lar: faqat bitta imkoniyatni yoqadi. Masalan, ES2017.String (padStart), ES2020.Promise (Promise.allSettled), ES2022.Array (.at()).

Default qiymati: lib yozilmasa, TS uni target'ga qarab tanlaydi: target versiyasining ES lib'i va DOM.

Amaliy misollar:

// Brauzer (React, Vue)
"lib": ["ES2022", "DOM", "DOM.Iterable"]
// Node.js: DOM KERAK EMAS, Node type'lari @types/node paketidan keladi
"lib": ["ES2022"]

target va lib farqi:

  • target — chiqadigan kod sintaksisi (=>, class, ?.).
  • lib — qaysi API'lar mavjud deb hisoblanadi (Promise, Map, document).

Masalan, target: "ES5" va lib: ["ES2020"] desangiz, TS Promise.allSettled'ni ishlatishga ruxsat beradi. Lekin eski brauzerda u yo'q bo'lsa, polyfill qo'shishni o'zingiz hal qilishingiz kerak.

3-qism: Tekshiruvlar qanchalik qattiq

strict

Bitta bayroq bilan butun bir qattiq tekshiruvlar oilasini yoqadi:

  • noImplicitAny
  • strictNullChecks
  • strictFunctionTypes
  • strictBindCallApply
  • strictPropertyInitialization
  • strictBuiltinIteratorReturn (TS 5.6+)
  • noImplicitThis
  • alwaysStrict
  • useUnknownInCatchVariables

Ulardan birini alohida o'chirish mumkin:

"strict": true,
"strictPropertyInitialization": false

Yangi loyihada doim strict: true qiling. TS'ning asosiy foydasi shu.

noImplicitAny

TS type'ni aniqlay olmasa, jimgina any qo'yib yubormaydi, aksincha xato beradi.

function add(a, b) { return a + b; }
// ❌ Parameter 'a' implicitly has an 'any' type.
function add(a: number, b: number) { return a + b; } // ✅

Bu sozlamasiz type'siz parametrlar any bo'lib qoladi va xatolar ko'rinmay ketadi.

strictNullChecks

null va undefined alohida type deb hisoblanadi. Ularni boshqa type'larga avtomatik qo'shib bo'lmaydi.

const user = users.find(u => u.id === 1); // type'i: User | undefined
console.log(user.name);
// ❌ 'user' is possibly 'undefined'.

if (user) console.log(user.name); // ✅
console.log(user?.name);          // ✅

Bu sozlamasiz Cannot read properties of undefined kabi xatolar faqat ishga tushganda (runtime) chiqadi. Bu eng foydali tekshiruvlardan biri.

noUnusedLocals

E'lon qilinib, lekin ishlatilmagan lokal o'zgaruvchi va import uchun xato beradi.

import { readFile } from "fs";
// ❌ 'readFile' is declared but its value is never read.

function calc() {
  const temp = 5;
  // ❌ 'temp' is declared but its value is never read.
  return 10;
}

noUnusedParameters

Ishlatilmagan funksiya parametrlari uchun xato beradi.

function handler(req: Request, res: Response) {
  // ❌ 'req' is declared but its value is never read.
  res.send("ok");
}

Parametr majburiy bo'lsa (masalan, callback imzosi talab qilsa), nomini _ bilan boshlang. Shunda TS uni tekshirmaydi:

function handler(_req: Request, res: Response) { res.send("ok"); } // ✅

Bu ikki sozlama strict'ga kirmaydi, ularni alohida yoqish kerak.

Tayyor shablonlar

Node.js backend:

{
  "include": ["src"],
  "compilerOptions": {
    "rootDir": "src",
    "outDir": "dist",
    "target": "ES2022",
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "lib": ["ES2022"],
    "strict": true,
    "noUnusedLocals": true,
    "noUnusedParameters": true
  }
}

Vite / React frontend:

{
  "include": ["src"],
  "compilerOptions": {
    "target": "ES2022",
    "module": "ESNext",
    "moduleResolution": "bundler",
    "lib": ["ES2022", "DOM", "DOM.Iterable"],
    "strict": true,
    "noUnusedLocals": true,
    "noUnusedParameters": true,
    "noEmit": true
  }
}

(Frontendda JS'ni Vite chiqaradi, shuning uchun outDir o'rniga noEmit ishlatiladi.)

Eslab qolish uchun qisqacha

  • include/exclude — qaysi fayllar olinadi.
  • rootDir/outDir — qayerdan olinib, qayerga yoziladi.
  • target — qaysi JS sintaksisi chiqadi.
  • module — qaysi modul formati chiqadi.
  • moduleResolution — import'lar qanday topiladi.
  • lib — qaysi tayyor API type'lari mavjud.
  • strict va boshqalar — tekshiruv qanchalik qattiq.