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 functionfunction'ga,constesavar'ga aylanadi,asyncva??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.mtsbo'lsa, ESM chiqadi.- Aks holda yoki fayl
.ctsbo'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:
ESNextyokiPreserve - 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:
./mathyozsangiz, ketma-ketmath.ts,math.d.ts,math/index.tsqidiriladi.node_modulesichidapackage.json'dagimain/typesmaydonlariga qaraydi.- ❌
package.json'dagiexportsmaydonini tushunmaydi. Zamonaviy paketlar esa aynan shu maydondan foydalanadi, shuning uchun bu variant eskirgan.
node16 / nodenext — zamonaviy Node.js algoritmi:
- ✅
package.json'dagiexportsvaimportsmaydonlarini 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:
- ✅
exportsmaydonini 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:
noImplicitAnystrictNullChecksstrictFunctionTypesstrictBindCallApplystrictPropertyInitializationstrictBuiltinIteratorReturn(TS 5.6+)noImplicitThisalwaysStrictuseUnknownInCatchVariables
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.strictva boshqalar — tekshiruv qanchalik qattiq.