# JavaScript kod sifati va nomlash qoidalari

> O'qiladigan kod yozish: nomlash qoidalari, funksiyani qisqartirish, sehrli sonlar, erta qaytish naqshi va izoh yozish. Amaliy tavsiyalar bilan.

Manba: https://learncode.uz/javascript/kod-sifati/
Sana: 2026-06-06

Ishlaydigan kod yozish — birinchi qadam. Ikkinchisi: olti oydan keyin
o'zingiz (yoki hamkasbingiz) uni o'qib tushuna olishi. Bu darsda shu farqni
beradigan qoidalar.

## Nom hamma narsani aytadi

```js
// Yomon
const d = 86400000;
function f(a, b) {
  return a.filter((x) => x.b > b);
}

// Yaxshi
const DAY_MS = 24 * 60 * 60 * 1000;
function passedStudents(students, minScore) {
  return students.filter((student) => student.score > minScore);
}

const students = [
  { name: "Aziz", score: 85 },
  { name: "Bobur", score: 45 },
];

console.log(passedStudents(students, 60));
console.log("Bir kun:", DAY_MS, "ms");
```

Ikkinchi variantda izoh kerak emas — nomlarning o'zi tushuntiradi.

Amaliy qoidalar:

- **O'zgaruvchi** — ot: `student`, `price`, `totalSum`;
- **Funksiya** — fe'l bilan: `calculate`, `validate`, `send`;
- **Mantiqiy qiymat** — savol shaklida: `isActive`, `hasItems`, `isDone`;
- **Massiv** — ko'plik: `students`, `prices`;
- **Doimiy** — `KATTA_HARF`: `MAX_RETRIES`, `BASE_URL`.

> **Qisqartirmang**
>
> `usr`, `btn`, `tmp`, `res` — bir belgi tejab, o'nlab soniya o'g'irlaydi.
> Zamonaviy muharrirlar nomni avtomatik to'ldiradi — to'liq yozish uchun
> bir necha belgi kifoya.
> Istisno: `i`, `j` sikl sanagichlari va `e` hodisa parametri — bular
> umumqabul qilingan.

## Sehrli sonlar

```js
// Yomon: 0.12 va 50000 nima?
function calcBad(amount) {
  if (amount > 50000) return amount * 0.12;
  return amount * 0.05;
}

// Yaxshi
const HIGH_LIMIT = 50000;
const HIGH_RATE = 0.12;
const BASE_RATE = 0.05;

function calcGood(amount) {
  const percent = amount > HIGH_LIMIT ? HIGH_RATE : BASE_RATE;
  return amount * percent;
}

console.log(calcGood(60000));
console.log(calcGood(30000));
```

Nomlangan doimiy ikki foyda beradi: ma'nosi ko'rinadi va o'zgartirish
kerak bo'lganda **bitta joyda** o'zgaradi.

## Erta qaytish — ichma-ich shartlardan qutulish

```js
// Yomon: chuqurlik oshib boradi
function checkNested(student) {
  if (student) {
    if (student.isActive) {
      if (student.score >= 60) {
        return "O'tdi";
      } else {
        return "Yiqildi";
      }
    } else {
      return "Faol emas";
    }
  } else {
    return "Talaba yo'q";
  }
}

// Yaxshi: shartlar tekis
function checkFlat(student) {
  if (!student) return "Talaba yo'q";
  if (!student.isActive) return "Faol emas";
  return student.score >= 60 ? "O'tdi" : "Yiqildi";
}

console.log(checkFlat(null));
console.log(checkFlat({ isActive: false }));
console.log(checkFlat({ isActive: true, score: 85 }));
```

**Erta qaytish** (early return): istisno holatlarni boshida tugatib, asosiy
mantiqni oxirida tekis qoldirish. Chuqurlik ikki darajadan oshsa — shu
naqshni o'ylang.

## Bitta funksiya — bitta vazifa

```js
const students = [
  { name: "Aziz", score: 85 },
  { name: "Dilnoza", score: 92 },
  { name: "Bobur", score: 45 },
];

// Har biri bitta ish qiladi
function passed(list) {
  return list.filter((t) => t.score >= 60);
}

function sortByScore(list) {
  return [...list].sort((a, b) => b.score - a.score);
}

function names(list) {
  return list.map((t) => t.name);
}

// Birga ishlatiladi
const result = names(sortByScore(passed(students)));
console.log(result);
```

Kichik funksiyalar sinash, qayta ishlatish va nomlash uchun qulay. Funksiya
nomida "va" so'zi paydo bo'lsa (`saveAndSend`) — uni bo'lish vaqti keldi.

`[...list].sort(...)` da nusxa olinganiga e'tibor bering: `sort` asl
massivni **o'zgartiradi**, nusxa esa buni oldini oladi.

## O'zgartirmaslik afzal

[Massiv metodlari](https://learncode.uz/javascript/massiv-metodlari) ikki xil: biri asl massivni
o'zgartiradi, ikkinchisi yangisini qaytaradi. Farqni bilmaslik qiyin
topiladigan xatolar tug'diradi:

```js
const original = [3, 1, 2];

const bad = original.sort();
console.log("sort'dan keyin asl:", original);

const original2 = [3, 1, 2];
const good = [...original2].sort();
console.log("nusxadan keyin asl:", original2);
console.log("natija:", good);
```

Funksiya o'ziga berilgan ma'lumotni o'zgartirsa, uni chaqirgan kod buni
kutmasligi mumkin — bu topish qiyin xatolarga olib keladi.

## Izoh — nima emas, nega

```js
const price = 100000;

// Yomon izoh — kod aytayotgan narsani takrorlaydi
// narxni 0.9 ga ko'paytiramiz
const a = price * 0.9;

// Yaxshi izoh — sababni tushuntiradi
// Yangi mijozlarga birinchi buyurtmada 10% chegirma (2026 aksiyasi)
const DISCOUNT = 0.9;
const b = price * DISCOUNT;

console.log(a, b);
```

Kod **nima qilishini** o'zi aytadi. Izoh **nega** shunday qilinganini
aytishi kerak: qaror sababi, tashqi cheklov, vaqtinchalik yechim.

## Shartlarni soddalashtirish

```js
const isActive = true;
const score = 85;

// Ortiqcha
if (isActive === true) console.log("1");
const result1 = score >= 60 ? true : false;

// Toza
if (isActive) console.log("2");
const result2 = score >= 60;

console.log(result1, result2);

// Uzun shartni nomlash
const age = 20;
const hasPaid = true;

const isAccepted = age >= 18 && hasPaid && score >= 60;
if (isAccepted) console.log("Qabul qilindi");
```

Murakkab shartni o'zgaruvchiga chiqarish — nom orqali izohlashning eng oson
usuli.

## Izchillik

> **Loyihada bir xil uslub**
>
> Qaysi uslubni tanlash muhim emas — **bir xil** bo'lishi muhim. Bitta faylda
> `const` va `var`, ikki xil tirnoq yoki turli nomlash uslublari aralashmasin.
>
> Amalda buni vositalar bajaradi: **Prettier** formatlaydi (bo'sh joy, qator
> uzunligi), **ESLint** esa xatolarni topadi (ishlatilmagan o'zgaruvchi,
> `==` o'rniga `===`). Jamoada ishlaganda ikkalasi ham majburiy.

## Tekshiruv ro'yxati

Kodni topshirishdan oldin:

- [ ] Nomlar ma'noni aytadimi? Qisqartma yo'qmi?
- [ ] Sehrli son yoki matn qolmadimi?
- [ ] Funksiya bitta vazifa bajaradimi?
- [ ] Ichma-ich shart uch darajadan oshmadimi?
- [ ] `console.log` va `debugger` olib tashlandimi?
- [ ] Takrorlangan kod bo'laklari birlashtirildimi?

## Amaliy mashq

1. `d`, `f`, `x` nomli o'zgaruvchilarni ma'noli nomga o'zgartiring;
2. koddagi sonlarni nomlangan doimiyga chiqaring;
3. uch darajali `if` ni erta qaytish bilan tekislang;
4. "va" bor funksiyani ikkiga bo'ling;
5. `sort` ni nusxa ustida bajaring;
6. bitta izohni "nima" dan "nega" ga o'zgartiring.

## Qisqacha xulosa

- Nom — eng yaxshi izoh: funksiya fe'l, massiv ko'plik, doimiy `KATTA_HARF`.
- Sehrli sonlarni nomlangan doimiyga chiqaring.
- **Erta qaytish** ichma-ich shartlarni tekislaydi.
- Bitta funksiya — bitta vazifa; nomda "va" bo'lsa, bo'ling.
- Kirish ma'lumotini o'zgartirmang — nusxa oling.
- Izoh **nega** deb yozilsin, **nima** deb emas.

Bu bilan **O'rta daraja** yakunlandi. Keyingi darsda
[prototip](https://learncode.uz/javascript/prototip) bilan Yuqori daraja boshlanadi.