JavaScript strict mode: "use strict" va jim xatolarni haqiqiy xatoga aylantirish

Qisqacha: Qat'iy rejim (strict mode) — JavaScript'ning eski, xavfli qoidalari o'chirilgan rejimi. Oddiy rejimda jimgina o'tib ketadigan xatolar (e'lonsiz o'zgaruvchi, faqat o'qiladigan xususiyatga yozish, takroriy parametr) qat'iy rejimda darhol ReferenceError, TypeError yoki SyntaxError beradi. U fayl yoki funksiya boshidagi "use strict"; bilan yoqiladi, modullarda (.mjs, type="module") va klasslarda esa avtomatik yoqilgan.

Bu darsda

• Oddiy va qat'iy rejim farqini bitta kodni .cjs va .mjs fayllarda ishga tushirib ko'rasiz.
• "use strict" ni qayerga va qanday yozishni, qayerda u ishlamasligini bilasiz.
• Qat'iy rejim taqiqlaydigan narsalar ro'yxatini — yashirin global, this = undefined, takroriy parametr, sakkizlik son — tushuntira olasiz.
• Qaysi kod avtomatik qat'iy ekanini aniqlay olasiz.
• vazifalar.js ni qat'iy rejimga o'tkazasiz.

Oldin bilishingiz kerak: var va nega undan voz kechildi, Shorthand, computed kalitlar va metodlar, Getter va setter, Obyektni himoyalash: freeze, Global obyekt va globalThis.

1. Nega bu kerak?

Kurs davomida bir xil ogohlantirishni bir necha marta uchratdingiz:

• var darsida: narx = 5000 oddiy skriptda jimgina global yaratadi, "qat'iy rejimda va modul fayllarda" esa ReferenceError beradi.
• String asoslari darsida: ism[0] = "M" oddiy skriptda jim o'tadi, modulda — TypeError.
• Son yozish shakllari darsida: 010 oddiy skriptda — sakkiz, modulda — SyntaxError.
• Parametrlar darsida: takroriy parametr nomi oddiy skriptda birinchisini bosib ketadi, modulda — SyntaxError.
• reduce darsida: bir xil xato oddiy skriptda va modulda boshqa-boshqa xabar berdi.

Har safar "buni Strict mode darsida tushuntiramiz" degan edik. Mana o'sha dars. Beshala holatning sababi bitta: modul fayllar avtomatik qat'iy rejimda ishlaydi.

Jim xato (silent error) — dastur xato qildi, lekin hech kimga aytmadi: xabar yo'q, to'xtash yo'q, faqat natija noto'g'ri. Bunday xato eng qimmati. U yozilgan joyida emas, bir necha qadam keyin — ba'zan haftalar o'tib, foydalanuvchi shikoyat qilganda — topiladi.

Hayotdan o'xshatish: ikki xil hisobchi. Birinchisi hujjatda xato ko'rsa, indamay "to'g'rilab" qo'yadi yoki e'tiborsiz qoldiradi — oy oxirida hisobot to'g'ri kelmaydi va hech kim sababini topolmaydi. Ikkinchisi xatoni ko'rishi bilan hujjatni qaytaradi: "bu yerda imzo yo'q". Bezovta qiladi, lekin xato darhol, o'z joyida tuzatiladi. Qat'iy rejim — ikkinchi hisobchi.

2. Bitta kod, ikki natija

2.1 Tajriba: .cjs va .mjs

reduce darsidagi xatoli sanoq kodini eslang: callback akkumulyator o'rniga sonni qaytaradi. Uni Node 24 da ikki faylga, harfma-harf bir xil qilib yozamiz: sanoq.cjs va sanoq.mjs.

const buyurtmalar = ["osh", "choy", "osh"];

const sanoq = buyurtmalar.reduce((n, taom) => {
  n[taom] = (n[taom] ?? 0) + 1;
  return n[taom];
}, {});

console.log(sanoq);

node sanoq.cjs

TypeError: Cannot read properties of undefined (reading 'osh')

node sanoq.mjs

TypeError: Cannot create property 'choy' on number '1'

Kod bir xil, xabarlar har xil. Qadamma-qadam:

1. Birinchi qadam: n — {}, n.osh = 1, callback 1 ni qaytaradi. Akkumulyator endi son 1.
2. Ikkinchi qadam: n — 1, kod n.choy = ... deb songa xususiyat yozmoqchi.
   • .cjs da songa yozish jimgina e'tiborsiz qoldiriladi. n.choy — undefined, callback undefined qaytaradi. Uchinchi qadamda n — undefined, va n.osh ni o'qishda dastur nihoyat yiqiladi. Xabar osh haqida — lekin xato osh da emas edi!
   • .mjs da songa yozish darhol TypeError: "1 soniga choy xususiyatini yaratib bo'lmaydi". Xato aynan sodir bo'lgan qadamda, aynan sababi bilan.

Ikkinchi xabar bir qadam oldin keldi va haqiqiy sababni aytdi. Katta dasturda "bir qadam" — o'nlab funksiya va yuzlab qator bo'lishi mumkin.

2.2 Farq qayerdan?

Node faylni kengaytmasiga qarab ishga tushiradi. .cjs — CommonJS: Node'ning eski fayl formati, u oddiy rejimda ishlaydi. .mjs — ES modul: u avtomatik qat'iy rejimda. Oddiy .js fayl esa sukut bo'yicha .cjs kabi ishlaydi. Bu formatlarni CommonJS va ESM darsida batafsil ko'ramiz — hozir faqat rejimlar farqi muhim.

Qat'iy rejim (strict mode) 2009-yilda, ES5 standarti bilan qo'shilgan. JavaScript 1995-yilda o'n kunda yozilgan va unda keyinchalik xato deb tan olingan qoidalar qolgan. Ularni shunchaki "tuzatib" bo'lmasdi: millionlab eski saytlar aynan shu qoidalarga tayanib ishlaydi. Shuning uchun yangi qoidalar ixtiyoriy rejim sifatida qo'shildi — kim xohlasa, yoqadi. Qat'iy bo'lmagan oddiy rejimni dasturchilar norasmiy ravishda "sloppy mode" ("beparvo rejim") deyishadi.

Tekshirib ko'ring: .cjs faylda const ism = "malika"; ism[0] = "M"; console.log(ism); nima chiqaradi? .mjs da-chi?

3. Qanday yoqiladi?

3.1 Fayl boshida

Oddiy skriptni qat'iy rejimga o'tkazish uchun uning birinchi ko'rsatmasi sifatida satr yoziladi:

"use strict";

function chekniHisobla() {
  jami = 35000 + 5000;
  return jami;
}

console.log(chekniHisobla());

ReferenceError: jami is not defined

Global obyekt darsida xuddi shu funksiya jimgina global jami yaratgan edi. Endi — xato: "jami aniqlanmagan". Bir harfi xato yozilgan nom ham shunday darhol ushlanadi.

"use strict" — oddiy satr. Lekin fayl yoki funksiya boshida turgan bunday satr direktiva (directive) — dvigatelga berilgan buyruq. Nega satr? 2009-yildagi eski brauzerlar uni tushunmasdi, lekin xato ham bermasdi: oddiy satr — hech narsa qilmaydigan to'g'ri ifoda. Yangi brauzerlar esa uni taniydi. Shu hiyla tufayli bitta fayl eski va yangi brauzerda ishlay olgan.

Qoidalar qat'iy:

• Birinchi ko'rsatma bo'lsin. Undan oldin faqat izoh va bo'sh qator bo'lishi mumkin. Boshqa kod bo'lsa — direktiva oddiy satrga aylanadi va hech narsa qilmaydi, xato ham bermaydi.
• Aniq yozilsin. "use strict" yoki 'use strict' — ikkalasi ishlaydi. "Use strict" (katta harf) yoki `use strict` (backtick) — ishlamaydi, jimgina.

const versiya = 2;
"use strict";

jami = 5;
console.log(jami); // 5

Ikkinchi qatordagi direktiva birinchi ko'rsatma emas — fayl oddiy rejimda qoldi va jami global bo'ldi. Bu xatoning yomoni — u jim: siz qat'iy rejim yoqilgan deb o'ylaysiz.

3.2 Funksiya ichida

Direktivani funksiya boshiga qo'ysa, qat'iy rejim faqat shu funksiyaga (va uning ichidagi funksiyalarga) tegishli bo'ladi:

function qatiy() {
  "use strict";
  return this;
}

function oddiy() {
  return this === globalThis;
}

console.log(qatiy(), oddiy()); // undefined true

Bu — eski katta kodni asta-sekin qat'iy rejimga o'tkazish usuli: avval bitta funksiya, keyin boshqasi. this dagi farqni «Nima o'zgaradi?» bo'limida ochamiz.

Bitta cheklov bor: parametrlarida default qiymat, destructuring yoki rest bo'lgan funksiyaga ichidan "use strict" yozib bo'lmaydi:

function narxniHisobla(narx, foiz = 10) {
  "use strict";
  return narx - (narx * foiz) / 100;
}

SyntaxError: Illegal 'use strict' directive in function with non-simple parameter list

Tarjimasi: "Oddiy bo'lmagan parametrlar ro'yxatiga ega funksiyada 'use strict' direktivasi noqonuniy". Sababi texnik: parametrlar funksiya tanasidan oldin o'qiladi, direktiva esa tanada. Dvigatel parametrlarni qaysi rejimda o'qishni bilmay qoladi. Tuzatish: direktivani faylning boshiga qo'ying.

3.3 Orqaga yo'l yo'q

Qat'iy rejimni yoqish mumkin, o'chirish — yo'q. "use sloppy" degan narsa yo'q. Qat'iy fayl ichidagi har bir funksiya ham qat'iy. Bu ataylab: kod bir qismi "xavfsiz", bir qismi "xavfli" bo'lib aralashib ketmasin.

Tekshirib ko'ring: Fayl boshida // Bahor kassasi izohi, keyin "use strict";. Qat'iy rejim yoqildimi?

4. Qayerda u avtomatik yoqilgan?

Zamonaviy kodning katta qismida "use strict" yozish kerak emas — rejim o'zi yoqilgan:

• ES modullar. .mjs fayllar, brauzerda <script type="module">, package.json ida "type": "module" yozilgan loyihadagi .js fayllar. Modullarni Nega modullar darsidan boshlab o'rganamiz; package.json — loyiha sozlamalari fayli, uni frontend asboblari qismida ko'ramiz.
• Klasslar. class { ... } ichidagi hamma kod — oddiy skriptda yozilgan bo'lsa ham. Klasslarni class sintaksisi darsida o'rganamiz — hozir bilish shart emas.

Brauzerda tekshiramiz — birinchi (oddiy) skript jim qoladi, ikkinchisi (modul) esa xato beradi:

<p>Oddiy skript va modul</p>
<script>
  narx = 35000;
  console.log("Oddiy skript:", window.narx);
</script>
<script type="module">
  taom = "osh";
  console.log("Modul:", taom);
</script>

Konsolda:

Oddiy skript: 35000
Uncaught ReferenceError: taom is not defined

Oddiy skript narx ni window ga yozdi. Modul taom ni yozishga ruxsat bermadi — u console.log gacha yetmadi.

Faylingiz qat'iymi — shu sxema bo'yicha aniqlang:

flowchart TB
  B["Kod qayerda?"] --> M{"Modulmi?<br/>.mjs, type=module"}
  M -- "ha" --> Q["Qat'iy"]
  M -- "yo'q" --> K{"class ichidami?"}
  K -- "ha" --> Q
  K -- "yo'q" --> D{"Fayl yoki funksiya boshida<br/>'use strict'?"}
  D -- "ha" --> Q
  D -- "yo'q" --> O["Oddiy rejim"]

Node'dagi fayllar uchun qisqa jadval:

Shuning uchun 08–09-qismlarda ba'zi misollar "oddiy skriptda — bunday, modulda — boshqacha" deb ikki xil natija bilan berilgan edi.

Saytdagi kod bloklari haqida ham bir gap. «Ishga tushir» tugmasi kodni qat'iy rejimda bajaradi — xuddi .mjs fayl kabi. Bu darsda oddiy rejimni ko'rsatadigan bloklar (masalan, jami = 5 jimgina ishlaydigan misol) esa ataylab oddiy skript sifatida bajariladi. Shuning uchun tugmani bossangiz, matnda yozilgan natijani ko'rasiz.

Tekshirib ko'ring: Brauzerdagi <script type="module"> boshiga "use strict"; yozish kerakmi?

5. Nima o'zgaradi?

5.1 E'lonsiz o'zgaruvchi — ReferenceError

«Fayl boshida» bo'limidagi jami. Eng muhim o'zgarish: global obyektga tasodifiy yozish to'xtaydi (Global obyekt). Bir harfli xato (jamii) darhol ushlanadi.

5.2 Funksiyada this — undefined

Shorthand va metodlar darsida this bilan tanishgansiz: metod ichida u — metod chaqirilgan obyekt. Metodni obyektdan ajratib, oddiy funksiya kabi chaqirsak-chi?

const hamyon = {
  balans: 50000,
  korsat() {
    console.log(`Balans: ${this.balans}`);
  },
};

const korsat = hamyon.korsat;
korsat(); // Balans: undefined

Nuqtadan oldin obyekt yo'q. Oddiy rejimda bunday holatda this — global obyekt. globalThis.balans — undefined, dastur xato bermadi, ekranga esa "undefined" chiqdi. Undan ham yomoni — metod this.balans = 0 deb yozganda, u global obyektga yangi nom qo'shib qo'yardi.

Qat'iy rejimda this — undefined:

"use strict";

const hamyon = {
  balans: 50000,
  korsat() {
    console.log(`Balans: ${this.balans}`);
  },
};

const korsat = hamyon.korsat;
korsat();

TypeError: Cannot read properties of undefined (reading 'balans')

Tarjimasi: "undefined ning xususiyatini o'qib bo'lmaydi (balans ni o'qishda)". Xato darhol, metod ichida. this ning to'liq qoidalarini this: to'rt qoida darsida, metod "ajralib qolganda" uni qanday tiklashni esa this yo'qolishi va uni tiklash darsida ko'ramiz. Bu ikki dars qat'iy rejimdagi xulqqa tayanadi.

5.3 Faqat o'qiladigan narsaga yozish — TypeError

Oddiy rejimda "yozib bo'lmaydigan" joyga yozish jimgina e'tiborsiz qoldiriladi. Qat'iy rejimda — har biri TypeError. To'rt holat:

const menyu = Object.freeze({ osh: 35000 });
menyu.osh = 1000;

TypeError: Cannot assign to read only property 'osh' of object '#<Object>'

Muzlatilgan obyekt (Obyektni himoyalash). Oddiy rejimda menyu.osh jimgina 35000 bo'lib qolardi — va siz narx o'zgardi deb o'ylardingiz.

const taom = {
  get narx() {
    return 35000;
  },
};
taom.narx = 1000;

TypeError: Cannot set property narx of #<Object> which has only a getter

Faqat getter'i bor xususiyat (Getter va setter): "faqat getter'i bor narx ga qiymat berib bo'lmaydi".

const ism = "osh";
ism.narx = 35000;

TypeError: Cannot create property 'narx' on string 'osh'

Primitivga xususiyat yozish — reduce tajribasidagi xatoning o'zi. Shu guruhga Object.preventExtensions qilingan obyektga yangi kalit qo'shish (Cannot add property ..., object is not extensible) va undefined = 5 kabi o'rnatilgan nomlarga yozish ham kiradi.

5.4 delete cheklovlari

• O'zgaruvchini o'chirish (delete narx;) — SyntaxError: Delete of an unqualified identifier in strict mode. ("qat'iy rejimda oddiy nomni o'chirib bo'lmaydi"). Oddiy rejimda bu jimgina false qaytarardi. delete faqat obyekt xususiyati uchun: delete savat.osh.
• O'chirib bo'lmaydigan xususiyatni o'chirish (delete Object.prototype) — TypeError: Cannot delete property 'prototype' of function Object() { [native code] }.

5.5 Sintaksis taqiqlari

Quyidagilar kodni ishga tushirishdan oldin, o'qish bosqichida SyntaxError beradi:

Takroriy parametr va sakkizlik son — Parametrlar va Son yozish shakllari darslaridagi tanish xatolar. with — eski, chalkash konstruksiya, zamonaviy kodda ishlatilmaydi; uni va eval ni eval, new Function va with darsida ko'ramiz. Zaxira so'zlar — kelajak uchun band qilingan nomlar: implements, interface, let, package, private, protected, public, static, yield. Qat'iy rejimda ularni o'zgaruvchi nomi qilib bo'lmaydi.

5.6 arguments parametrdan ajraldi

Oddiy rejimda eski arguments obyekti (Arrow funksiyalar darsida eslatilgan) parametrlar bilan "bog'langan": parametr o'zgarsa, arguments[0] ham o'zgaradi. Qat'iy rejimda bog'lanish yo'q:

function narxniOzgartir(narx) {
  narx = 9000;
  return arguments[0];
}

console.log(narxniOzgartir(5000)); // 5000

Bu blok modul sifatida (qat'iy) ishlaydi — 5000. Oddiy rejimda xuddi shu funksiya 9000 qaytarardi. Amalda arguments o'rniga rest parametr ishlatiladi (Spread va rest), shuning uchun bu farq kam seziladi — lekin eski kodni o'qiganda bilib qo'ying.

5.7 Yig'ma jadval

Jadvalning o'ng ustunida bitta ham "jim" so'zi yo'q. Qat'iy rejimning butun mohiyati shu.

Tekshirib ko'ring: Qat'iy rejim yangi imkoniyat qo'shadimi?

6. Ko'p uchraydigan xatolar

6.1 Direktiva birinchi emas

«Fayl boshida» bo'limidagi const versiya = 2; misoli. Ayniqsa xavfli: hech qanday belgi yo'q, siz esa himoyalanganman deb o'ylaysiz. Tekshirish: faylda jami = 5 kabi ataylab xato qator yozib ko'ring — ReferenceError chiqmasa, rejim yoqilmagan.

6.2 Default parametrli funksiyada direktiva

SyntaxError: Illegal 'use strict' directive in function with non-simple parameter list. Tuzatish: direktivani fayl boshiga ko'chiring.

6.3 Fayllarni ulab yuborish

Eski loyihalarda bir nechta skriptni bitta faylga ketma-ket ulab (concatenation) yuklashardi. Birinchi faylda "use strict" bo'lsa, butun ulangan fayl qat'iy bo'lib qoladi — va boshqa, oddiy rejimga tayangan fayl buziladi. Teskarisida esa ikkinchi fayldagi direktiva o'rtada qolib, ishlamaydi. Shuning uchun eski kodda funksiya-darajasidagi "use strict" va IIFE ko'p uchraydi. Zamonaviy bundler'lar (fayllarni yig'uvchi asboblar — keyinroq o'rganamiz) modullar bilan ishlaydi va bu muammo yo'q.

6.4 "Qat'iy rejim skriptni modulga aylantiradi" deb o'ylash

Yo'q. "use strict" faqat qoidalarni o'zgartiradi. Oddiy skriptning tashqi function e'lonlari qat'iy rejimda ham window ga yoziladi, skriptlar bitta global muhitni bo'lishadi (Global obyekt). O'z muhitini faqat modul beradi.

7. Mashqlar

1-mashq (oson): Oddiymi, qat'iymi?

Har qator uchun ayting: oddiy rejimda nima bo'ladi, qat'iy rejimda nima bo'ladi?

narx = 35000;
const chek = Object.freeze({ jami: 40000 });
chek.jami = 0;
function f(a, a) {}
console.log(07);

2-mashq (o'rta): Yashirin xatoni toping

Kassir kun oxirida tushumni hisoblaydi, lekin natija har doim 0. Faylga "use strict" qo'shib, xato qayerdaligini toping va tuzating.

let tushum = 0;

function sotuvQosh(narx) {
  tushumm = tushum + narx;
}

sotuvQosh(35000);
sotuvQosh(5000);
console.log(tushum);

ReferenceError: tushumm is not defined

"use strict";

let tushum = 0;

function sotuvQosh(narx) {
  tushum = tushum + narx;
}

sotuvQosh(35000);
sotuvQosh(5000);
console.log(tushum); // 40000

3-mashq (qiyin): Eski funksiyani qat'iy qiling

Eski kod bazasida bitta funksiyani qat'iy rejimga o'tkazish kerak (butun faylni hali o'zgartirib bo'lmaydi). Direktivani qo'shing, chiqqan xatolarni tuzating va xulq saqlanganini tekshiring.

function buyurtmaniYoz(stol, stol, taom) {
  oxirgiBuyurtma = `${stol}-stol: ${taom}`;
  return oxirgiBuyurtma;
}

Ishora: eski kodni chaqiruvchilar buyurtmaniYoz(3, 5, "osh") deb yozishadi va natija "5-stol: osh" bo'ladi.

function buyurtmaniYoz(_eskiStol, stol, taom) {
  "use strict";
  const oxirgiBuyurtma = `${stol}-stol: ${taom}`;
  return oxirgiBuyurtma;
}

console.log(buyurtmaniYoz(3, 5, "osh")); // 5-stol: osh

4-mashq: Vazifalar qadami — qat'iy rejimni yoqing

vazifalar.js — oddiy <script defer>, ya'ni oddiy rejimda. Uni qat'iy rejimga o'tkazing va hech narsa buzilmaganini tekshiring.

1. Branch: git switch -c refactor/strict.
2. Fayl boshiga direktivani qo'ying — birinchi izohdan keyin, birinchi kod qatoridan oldin.
3. Ilovani to'liq sinang: DevTools Console'da xato bormi?

// vazifalar.js — vazifalar ro'yxati v1 (09-qism yakuniy loyihasi)
"use strict";

// 1. Holat — yagona haqiqat manbai
const holat = {
  // ...

git add assets/js/vazifalar.js
git commit -m "Vazifalar: qat'iy rejimni yoq"
git switch main
git merge refactor/strict
git branch -d refactor/strict
git push

8. Real ishda

• Zamonaviy kod — deyarli hammasi qat'iy. React, Vue, Next.js loyihalari, TypeScript chiqargan kod, Vite va boshqa asboblar — hammasi modullarda ishlaydi. Siz "use strict" yozmaysiz, lekin qat'iy qoidalar doim amalda.
• Eski kod va CommonJS. Node'dagi eski .js loyihalar, WordPress plaginlari, jQuery davri skriptlari — oddiy rejimda. Bunday faylning boshida "use strict" ni ko'rsangiz, muallif ataylab qat'iy qoidalarni yoqqan.
• Kod sifati vositalari. ESLint'ning strict qoidasi direktivani tekshiradi, no-undef esa e'lonsiz nomni yozish paytidayoq ko'rsatadi — qat'iy rejimdan ham oldin. 12-qismda sozlaymiz.
• Intervyu. "'use strict' nima qiladi?", "qat'iy rejimda this nimaga teng?", "modulda 'use strict' kerakmi?" — tez-tez so'raladi. Uch qisqa javob: jim xatolarni baland qiladi; oddiy chaqiruvda undefined; kerak emas, modul o'zi qat'iy.

Xulosa

• Qat'iy rejim — JavaScript'ning xavfli eski qoidalari o'chirilgan rejimi: jim xatolar ReferenceError, TypeError, SyntaxError ga aylanadi.
• Yoqish: fayl yoki funksiyaning birinchi ko'rsatmasi — "use strict";. Undan oldin faqat izoh. O'chirib bo'lmaydi.
• ES modullar (.mjs, type="module") va klasslar — avtomatik qat'iy. Node'da .cjs va oddiy .js — oddiy rejim.
• Asosiy farqlar: e'lonsiz o'zgaruvchi taqiqlangan, oddiy chaqiruvda this — undefined, faqat o'qiladigan joyga yozish — TypeError, takroriy parametr va 010 — SyntaxError.
• Qat'iy rejim qoidalarni o'zgartiradi, muhitni emas: oddiy skript qat'iy bo'lsa ham global muhitni bo'lishadi.

Keyingi dars: this: to'rt qoida va arrow istisnosi — bugun ko'rgan this = undefined dan boshlab, this qaysi qoidalar bo'yicha aniqlanishini to'liq o'rganamiz.

Manbalar

• MDN: "Strict mode", "Sloppy mode" — developer.mozilla.org
• ECMAScript 2025 Language Specification: "The Strict Variant of ECMAScript" (Annex C), "Directive Prologues and the Use Strict Directive" — tc39.es/ecma262
• Node.js hujjatlari: "Modules: Packages — Determining module system" — nodejs.org/api/packages.html