JavaScript'da son yozish shakllari va sanoq tizimlari

Qisqacha: JavaScript'da bitta sonni turli shaklda yozish mumkin: 1_000_000 (o'qish oson), 1e6 (ilmiy yozuv), 0xff (o'n oltilik), 0o755 (sakkizlik), 0b1010 (ikkilik). Qanday yozmang, ichkarida bir xil son saqlanadi va console.log uni o'nlik shaklda ko'rsatadi. Sonni boshqa tizimda satr qilib olish uchun son.toString(2), satrdan qaytarish uchun parseInt(satr, 2) ishlatiladi.

Bu darsda

• Katta sonlarni _ ajratgich va e (ilmiy yozuv) bilan o'qishga qulay yoza olasiz.
• 0x, 0o, 0b literallarini o'qiy va yoza olasiz.
• toString(2) va toString(16) bilan sonni boshqa tizimga o'tkazasiz.
• parseInt(satr, asos) bilan boshqa tizimdagi satrni songa aylantira olasiz.
• CSS rangi, fayl ruxsatlari va bit bayroqlarida bu bilimni ishlata olasiz.

Oldin bilishingiz kerak: Nega 0 va 1: ikkilik sanoq sistemasi, O'n oltilik va sakkizlik sanoq sistemalari, Number turi JS'da, Turlarni aniq o'zgartirish.

1. Nega bu kerak?

Kodda shunday qator ko'rdingiz:

const maksHajm = 10000000;

Bu necha? O'n million yoki bir million? Nollarni barmoq bilan sanashga to'g'ri keladi. Xato bitta nolda ketadi — fayl yuklash chegarasi 10 barobar o'zgaradi.

Boshqa vaziyatlar ham bor:

• Dizayner rangni #FF8800 deb berdi. Sizga uning qizil, yashil va ko'k qismlari son sifatida kerak.
• Serverda fayl ruxsati 755 deb yozilgan. Bu oddiy "yetti yuz ellik besh" emas.
• Fizika formulasida yorug'lik tezligi — 300 000 000 m/s. Buni yozishning qisqaroq yo'li bormi?

JavaScript'da bularning hammasi uchun maxsus yozuv shakllari bor. Ularni bu darsda birma-bir ko'ramiz.

2. Raqam ajratgich: 1_000_000

2.1 Pastki chiziq bilan guruhlash

Kundalik hayotda katta sonni bo'sh joy bilan guruhlaymiz: 10 000 000. Kodda bo'sh joy qo'yib bo'lmaydi, lekin pastki chiziq _ qo'yish mumkin:

const maksHajm = 10_000_000;
const narx = 12_500.75;
const kichik = 0.000_001;

console.log(maksHajm); // 10000000
console.log(narx); // 12500.75
console.log(kichik); // 0.000001

Pastki chiziq raqam ajratgich (numeric separator) deyiladi. U faqat ko'z uchun: JavaScript uni butunlay e'tiborsiz qoldiradi. Shuning uchun console.log sonni chiziqsiz chiqaradi.

Guruhlashni xohlagancha qilish mumkin. Masalan, karta raqamini to'rttadan: 8600_1234_5678_9012. Lekin odatda uchtadan guruhlanadi — ming, million, milliard.

2.2 Ajratgich qoidalari

_ faqat ikki raqam orasida tura oladi. Boshqa joyda xato beradi:

Oxirgisi eng qiziq. _1000 — pastki chiziq bilan boshlangan nom. JavaScript uni o'zgaruvchi nomi deb tushunadi va ReferenceError: _1000 is not defined beradi.

2.3 Ajratgich faqat kodda ishlaydi

Muhim chegara: _ faqat kodda yozilgan sonda ishlaydi. Satr ichida u oddiy belgi:

console.log(Number("1_000")); // NaN
console.log(parseInt("1_000", 10)); // 1

Number pastki chiziqni tanimadi va NaN berdi. parseInt esa boshidan o'qib, _ da to'xtadi — natija 1. Foydalanuvchi formaga 1_000 yozsa, u bu ikki usulda ham to'g'ri o'qilmaydi.

Tekshirib ko'ring: console.log(5_000 + 1_000) nima chiqaradi?

3. Ilmiy yozuv: 1e6

3.1 e — "10 ning darajasi"

Juda katta yoki juda kichik sonlar uchun ilmiy yozuv (exponential notation) bor. e harfi "10 ning ... darajasiga ko'paytir" degani:

console.log(1e6); // 1000000
console.log(2.5e3); // 2500
console.log(3e8); // 300000000
console.log(1e-3); // 0.001
console.log(123e-2); // 1.23

• 1e6 — 1 × 10⁶, ya'ni bir million.
• 2.5e3 — 2,5 × 1000 = 2500.
• 3e8 — yorug'lik tezligi, 300 million m/s.
• 1e-3 — manfiy daraja "10 ga bo'l" degani: 1 ÷ 1000 = 0,001.

e katta harf bilan ham yoziladi (1E6), lekin odatda kichigi ishlatiladi.

3.2 JavaScript o'zi qachon e bilan chiqaradi?

Oldingi darsda Number.EPSILON 2.220446049250313e-16 bo'lib chiqqan edi. JavaScript juda katta va juda kichik sonlarni o'zi ilmiy yozuvda ko'rsatadi:

console.log(1e20); // 100000000000000000000
console.log(1e21); // 1e+21
console.log(0.000001); // 0.000001
console.log(0.0000001); // 1e-7

Qoida: 10²¹ va undan katta, 0,000001 dan kichik sonlar e bilan chiqadi. Bu faqat ko'rinish — son o'zgarmaydi. 1e+21 dagi + "musbat daraja" degani.

3.3 .5 va 5. — qisqa kasr yozuvi

Kasr sonning butun qismi 0 bo'lsa, uni tashlab ketish mumkin: .5 — bu 0.5. Nuqtadan keyingi 0 ni ham: 5. — bu 5:

console.log(.5); // 0.5
console.log(5.); // 5

Ikkalasi ham to'g'ri, lekin o'qishga noqulay. O'zingiz doim to'liq yozing: 0.5, 5. Bu yozuvni faqat tanib olish uchun bilib qo'ying.

Diqqat: Number() ilmiy yozuvni ham tushunadi: Number("1e3") — 1000. Foydalanuvchi "yosh" maydoniga 1e3 yozsa, dastur uni 1000 yosh deb qabul qiladi. Formadagi sonni tekshirishni matn va son darsida o'rganamiz.

Tekshirib ko'ring: 4.5e6 va 7e-2 qanday sonlar?

4. Boshqa sanoq tizimlaridagi sonlar

4.1 Uch prefiks

Ikkilik va o'n oltilik, sakkizlik sanoq tizimlarini bilasiz. JavaScript ularda son yozishga ruxsat beradi — faqat oldiga prefiks (old qo'shimcha) qo'yiladi:

Prefiksdagi harf tizimning inglizcha nomidan: hex, octal, binary. Oldidagi 0 JavaScript'ga "bu son boshlanyapti" deydi — shuning uchun xff nom bo'lib qoladi, 0xff esa son.

console.log(0xff); // 255
console.log(0xFF); // 255
console.log(0o755); // 493
console.log(0b1010); // 10
console.log(0b1111_1111); // 255

Hex raqamlarni katta harf bilan ham yozsa bo'ladi: 0xff va 0xFF bir xil. Prefiksning o'zi esa kichik harf bilan yoziladi (0X ham ishlaydi, lekin odat emas). Oxirgi qatorga qarang: ajratgich bu yerda ham ishlaydi va ikkilik sonni to'rttadan guruhlash qulay.

4.2 Son bitta, yozuv har xil

console.log hamma natijani o'nlik tizimda chiqardi. Nega? Chunki 0xff, 255 va 0b11111111 — bitta son, faqat uch xil yozilgan:

console.log(0xff === 255); // true
console.log(0b11111111 === 255); // true
console.log(0xa + 0b11 + 0o10); // 21

Hayotdan o'xshatish: bitta miqdorni "besh", "5" yoki "V" deb yozish mumkin. Yozuv har xil, qo'lingizdagi olma soni bir xil. JavaScript ichkarida sonni baribir ikkilik bitlarda saqlaydi. Prefiks — faqat siz kodni qanday yozishingiz uchun.

0xa + 0b11 + 0o10 — bu 10 + 3 + 8 = 21. Tizimlarni aralashtirib qo'shish mumkin, chunki ular oddiy sonlar.

4.3 Eski sakkizlik yozuv: 0755

Eski JavaScript'da prefiks 0o emas, shunchaki 0 edi: 0755 sakkizlik son hisoblanardi. Bu juda chalkash edi — oldiga nol qo'yilgan oddiy son ham kutilmaganda sakkizlik bo'lib qolardi.

Oddiy skriptda (<script> yoki node fayl.js) bu eski qoida hali ham ishlaydi:

console.log(0755); // 493
console.log(010); // 8

010 — "o'n" emas, sakkiz! Xato chiqmadi, natija jimgina boshqacha.

Zamonaviy modul fayllarda (.mjs, <script type="module">) esa JavaScript "qat'iy rejim"da ishlaydi va bunga yo'l qo'ymaydi:

console.log(0755);

SyntaxError: Octal literals are not allowed in strict mode.

Tarjimasi: "Qat'iy rejimda sakkizlik literallarga ruxsat yo'q". Qat'iy rejim (strict mode) — JavaScript'ning eski, xavfli qoidalari o'chirilgan rejimi. Uni Strict mode darsida batafsil ko'ramiz. Hozircha qoida bitta: sakkizlik son kerak bo'lsa — doim 0o755 yozing. Oddiy songa esa oldiga nol qo'ymang.

Tekshirib ko'ring: 0b101 + 0x10 nimaga teng?

5. Sonni boshqa tizimda yozish: toString(asos)

5.1 toString ga asos berish

Turlarni o'zgartirish darsida (5).toString(2) ni qisqa ko'rgan edik. Endi to'liq ko'ramiz. toString(asos) sonni ko'rsatilgan asosli (radix) tizimdagi satrga aylantiradi. Asos — tizimdagi raqamlar soni: ikkilikda 2, o'n oltilikda 16:

const son = 255;

console.log(son.toString(2)); // 11111111
console.log(son.toString(8)); // 377
console.log(son.toString(16)); // ff
console.log(son.toString()); // 255

Asos berilmasa — o'nlik tizim. Natija har doim satr:

console.log(typeof (255).toString(16)); // string

Esingizda bo'lsa, butun songa to'g'ridan-to'g'ri nuqta qo'yib bo'lmaydi: 255.toString(16) — SyntaxError. Sonni qavsga oling yoki avval o'zgaruvchiga yozing.

Asos 2 dan 36 gacha bo'lishi mumkin. 36 — 10 ta raqam va 26 ta lotin harfi:

console.log((35).toString(36)); // z
console.log((2026).toString(36)); // 1ka

Qisqa ID yasashda ba'zan 36-lik tizim ishlatiladi.

5.2 Chiroyli ko'rinish: padStart va toUpperCase

Ikkilik sonni ko'pincha 8 xonali (bir bayt) ko'rsatish kerak. padStart bu yerda juda qo'l keladi. Hex uchun esa toUpperCase:

console.log((5).toString(2).padStart(8, "0")); // 00000101
console.log((255).toString(16).toUpperCase()); // FF
console.log((10).toString(16).padStart(2, "0")); // 0a

(5).toString(2) — "101". padStart(8, "0") uni chap tomondan nollar bilan 8 belgigacha to'ldirdi. Bu bayt ko'rinishi.

5.3 Manfiy va kasr sonlar

console.log((-5).toString(2)); // -101
console.log((0.5).toString(2)); // 0.1
console.log((3.75).toString(2)); // 11.11

• Manfiy son oddiy minus bilan chiqadi. Sonlar ichkarida darsidagi "two's complement" ko'rinishi emas — bu faqat yozuv.
• 0.5 ikkilikda 0.1 — ya'ni ikkidan bir. 3.75 — 11.11: 2 + 1 + 0,5 + 0,25.

Endi 0.1 ni ikkilikda ko'raylik:

console.log((0.1).toString(2));

Konsolda:

0.0001100110011001100110011001100110011001100110011001101

0011 qayta-qayta takrorlanyapti va hech tugamaydi. JavaScript uni 64 bitli sonning aniqligi tugagan joyda kesib qo'ydi. Oldingi darsdagi 0.1 + 0.2 !== 0.3 sirining ildizi — aynan shu ekranda.

Tekshirib ko'ring: (16).toString(16) va (15).toString(16) nima qaytaradi?

6. Satrdan songa: parseInt(satr, asos)

6.1 Teskari yo'l

toString(16) son → satr yo'nalishida ishlaydi. Teskarisi uchun parseInt bor. Uning ikkinchi qiymati — xuddi o'sha asos:

console.log(parseInt("ff", 16)); // 255
console.log(parseInt("FF", 16)); // 255
console.log(parseInt("101", 2)); // 5
console.log(parseInt("755", 8)); // 493
console.log(parseInt("z", 36)); // 35

Endi parseInt(s, 10) dagi 10 nima ekanini to'liq tushunasiz — "o'nlik tizimda o'qi".

Aylanma yo'l ham ishlaydi:

const kod = (2026).toString(16);

console.log(kod); // 7ea
console.log(parseInt(kod, 16)); // 2026

6.2 Noto'g'ri raqamda to'xtaydi

parseInt satrni boshidan o'qiydi va shu tizimda yo'q raqamga duch kelsa, to'xtaydi:

console.log(parseInt("12", 2)); // 1
console.log(parseInt("2", 2)); // NaN
console.log(parseInt("0xff", 16)); // 255

• "12" ikkilikda: 1 — to'g'ri raqam, 2 — ikkilikda yo'q. parseInt 1 gacha o'qib, to'xtadi.
• "2" — birinchi belgining o'zi noto'g'ri, natija NaN.
• Asos 16 bo'lsa, parseInt 0x prefiksini ham tushunadi.

6.3 Number() va prefikslar

Number() prefiksli satrlarni ham o'qiy oladi, lekin asos qabul qilmaydi:

console.log(Number("0xff")); // 255
console.log(Number("0b101")); // 5
console.log(Number("0o17")); // 15
console.log(Number("-0xff")); // NaN
console.log(parseInt("-ff", 16)); // -255

Minusli prefiksli satrni Number o'qimaydi, parseInt esa asos bilan manfiy sonni ham tushunadi. parseInt va Number ning barcha farqlarini keyingi, matn va son darsida o'rganamiz.

Tekshirib ko'ring: parseInt("777", 8) va parseInt("8", 8) nima qaytaradi?

7. Amalda qayerda ishlatiladi?

7.1 CSS rangi: hex → RGB

CSS ranglari darsida #FF8800 kabi yozuvni ko'rgansiz. Bu uchta o'n oltilik son: qizil FF, yashil 88, ko'k 00. Ularni slice bilan ajratib, parseInt bilan o'qiymiz:

const rang = "#FF8800";

const qizil = parseInt(rang.slice(1, 3), 16);
const yashil = parseInt(rang.slice(3, 5), 16);
const kok = parseInt(rang.slice(5, 7), 16);

console.log(qizil, yashil, kok); // 255 136 0

Endi bu sonlar bilan ishlash mumkin: rangni och qilish, kontrastni hisoblash. Teskari yo'l — toString(16) va padStart(2, "0") — 3-mashqda.

7.2 Fayl ruxsatlari: 0o755

Fayl ruxsatlari darsidagi chmod 755 — sakkizlik son. Uni ikkilikka o'tkazsak, har bir raqam uchta bitga aylanadi:

const ruxsat = 0o755;

console.log(ruxsat); // 493
console.log(ruxsat.toString(8)); // 755
console.log(ruxsat.toString(2)); // 111101101

111 101 101 — egasi uchun rwx (hammasi), guruh va boshqalar uchun r-x (yozishdan tashqari hammasi). Node'da fayl ruxsatini o'rnatganda aynan 0o755 yoziladi — buni Node.js qismida ko'rasiz.

7.3 Unicode kodlari

Unicode darsida codePointAt o'nlik son bergan edi. Uni U+ yozuviga aylantirish uchun o'n oltilik kerak:

const kod = "\u{1F600}".codePointAt(0);

console.log(kod); // 128512
console.log(kod.toString(16).toUpperCase()); // 1F600
console.log(String.fromCodePoint(0x1f600).length); // 2

Unicode jadvallari va \u{...} escape'lari o'n oltilikda yozilgani uchun 0x1f600 kabi literal bu yerda eng qulay.

7.4 Bit bayroqlar: 0b

Bitli operatorlar darsida bitta sonda bir nechta "ha/yo'q" belgisini saqlashni ko'rgansiz. 0b yozuvi bunday bayroqlarni juda aniq ko'rsatadi:

const OQISH = 0b100;
const YOZISH = 0b010;
const BAJARISH = 0b001;

const huquq = OQISH | YOZISH;

console.log(huquq.toString(2)); // 110
console.log((huquq & YOZISH) !== 0); // true
console.log((huquq & BAJARISH) !== 0); // false

0b100, 0b010, 0b001 — har bir bayroq qaysi bitda turgani ko'rinib turibdi. O'nlikda yozilganda (4, 2, 1) bu unchalik aniq emas.

8. Ko'p uchraydigan xatolar

8.1 Oldiga nol qo'yilgan son

const kod = 0123; — oddiy skriptda bu 83 (sakkizlik!), modulda — SyntaxError. 09 ga o'xshash sonlar esa modulda boshqa xato beradi:

SyntaxError: Decimals with leading zeros are not allowed in strict mode.

Tarjimasi: "Qat'iy rejimda boshida nol bor o'nlik sonlarga ruxsat yo'q". Tuman kodi, uy raqami kabi boshida nol bo'lishi mumkin bo'lgan qiymatlarni satrda saqlang: "0123".

8.2 Ajratgichni noto'g'ri joyga qo'yish

const summa = 1__000;

SyntaxError: Only one underscore is allowed as numeric separator

Tarjimasi: "Raqam ajratgich sifatida faqat bitta pastki chiziqqa ruxsat". Oxirida qo'yilsa (1000_) xabar boshqacha: Numeric separators are not allowed at the end of numeric literals — "raqamli literal oxirida ajratgichga ruxsat yo'q".

8.3 Tizimda yo'q raqam

0b102 yoki 0xG1 yozsangiz:

SyntaxError: Invalid or unexpected token

Tarjimasi: "Noto'g'ri yoki kutilmagan belgi". Ikkilikda faqat 0 va 1, o'n oltilikda faqat 0–9 va a–f bor. 2 yoki G ni JavaScript son qismi deb qabul qilmaydi.

8.4 Noto'g'ri asos

console.log((255).toString(37));

RangeError: toString() radix argument must be between 2 and 36

Tarjimasi: "toString() ning asos argumenti 2 va 36 orasida bo'lishi kerak". RangeError — qiymat ruxsat etilgan oraliqdan tashqarida. parseInt esa noto'g'ri asosda xato bermaydi — shunchaki NaN qaytaradi.

8.5 toString natijasini son deb o'ylash

(5).toString(2) — "101" satri, yuz bir soni emas. Unga + 1 qo'shsangiz, + satrlarni yopishtiradi: "1011". Hisoblash kerak bo'lsa, sonning o'zi bilan ishlang. Satr faqat ko'rsatish uchun.

9. Mashqlar

1-mashq (oson): O'qishga qulay yozuv

Quyidagi sonlarni o'zgaruvchilarga yozing. Birinchi ikkitasi uchun _ ajratgich, oxirgi ikkitasi uchun e yozuvini ishlating. Keyin hammasini konsolga chiqaring.

• Toshkent aholisi: 3 000 000 kishi.
• Uy narxi: 1 250 000 000 so'm.
• Kunning millisekundlari: 86 400 000 (ishora: 8,64 × 10⁷).
• Chang zarrachasi hajmi: 0,00001 metr.

const aholi = 3_000_000;
const uyNarxi = 1_250_000_000;
const kunMs = 8.64e7;
const zarracha = 1e-5;

console.log(aholi); // 3000000
console.log(uyNarxi); // 1250000000
console.log(kunMs); // 86400000
console.log(zarracha); // 0.00001

2-mashq (o'rta): Yil uch tizimda

2026 sonini ikkilik, sakkizlik va o'n oltilik tizimda satr qilib chiqaring. Keyin har bir satrni parseInt bilan yana songa aylantirib, uchala natija ham 2026 ekanini ko'rsating.

const yil = 2026;

const ikkilik = yil.toString(2);
const sakkizlik = yil.toString(8);
const hex = yil.toString(16);

console.log(ikkilik, sakkizlik, hex);
console.log(parseInt(ikkilik, 2));
console.log(parseInt(sakkizlik, 8));
console.log(parseInt(hex, 16));

11111101010 3752 7ea
2026
2026
2026

3-mashq (qiyin): RGB → hex

Dizayner rangni uch son bilan berdi: qizil 30, yashil 144, ko'k 255. CSS uchun #1e90ff ko'rinishidagi satr yasang.

Ishora: har bir sonni toString(16) bilan o'n oltilikka o'tkazing. Bir xonali natija chiqishi mumkin (masalan, 10 → "a"), shuning uchun padStart(2, "0") bilan ikki xonaga to'ldiring. Uchala qismni # bilan template literal ichida birlashtiring.

Bonus: natijani CSS rangi misolidagi usul bilan qayta tekshiring — parseInt yana 30, 144, 255 bersin.

const qizil = 30;
const yashil = 144;
const kok = 255;

const q = qizil.toString(16).padStart(2, "0");
const y = yashil.toString(16).padStart(2, "0");
const k = kok.toString(16).padStart(2, "0");
const rang = `#${q}${y}${k}`;

console.log(rang); // #1e90ff

// Bonus: qayta tekshirish
const q2 = parseInt(rang.slice(1, 3), 16);
const y2 = parseInt(rang.slice(3, 5), 16);
const k2 = parseInt(rang.slice(5, 7), 16);
console.log(q2, y2, k2); // 30 144 255

10. Real ishda

• Frontend: ranglar bilan ishlaydigan har qanday kutubxona (rang tanlagich, tema generator) hex ↔ RGB o'girishni aynan shunday qiladi.
• Backend va Linux: fayl ruxsatlari (0o644, 0o755) Node.js'ning fayl funksiyalarida sakkizlik literal bilan beriladi.
• Xavfsizlik: parol xeshlari, tokenlar, UUID identifikatorlari — o'n oltilik satrlar. Masalan, 3f2a9c... kabi uzun yozuvlar.
• Konfiguratsiya: vaqt va hajm chegaralari 5_000_000 (baytlar) yoki 1e3 (millisekund) kabi yoziladi. Jamoalarda katta sonlar uchun _ ajratgichni talab qiladigan qoidalar bor.
• Intervyu: "0.1 ikkilikda qanday yoziladi va bu nimaga olib keladi?", "Nega parseInt ga har doim asos beriladi?" — sanoq tizimlari bo'yicha klassik savollar.

Xulosa

• 1_000_000 — raqam ajratgich faqat o'qish uchun. U faqat kodda ishlaydi, satr ichida emas.
• 1e6, 2.5e-3 — ilmiy yozuv: e "10 ning darajasi" degani.
• 0x, 0o, 0b — o'n oltilik, sakkizlik va ikkilik literallar. Son bitta, yozuv har xil.
• Eski 0755 yozuvidan qoching — doim 0o755. Oddiy sonning oldiga nol qo'ymang.
• son.toString(asos) — sonni boshqa tizimdagi satrga, parseInt(satr, asos) — satrni songa aylantiradi.

Manbalar

• MDN: Numeric literals
• MDN: Number.prototype.toString()

Keyingi dars: Matn ↔ son va sonni tekshirish — Number(), parseInt, parseFloat va tekshiruv funksiyalarining barcha farqlarini o'rganib, foydalanuvchi kiritgan sonni ishonchli o'qishni o'rganamiz.