JavaScript Number turi: EPSILON, MAX_SAFE_INTEGER, NaN va -0

Qisqacha: JavaScript'dagi har bir son — 64 bitli kasr son (IEEE 754). Shuning uchun kasrlarni === bilan emas, kichik farq bilan solishtirasiz: Math.abs(a - b) < Number.EPSILON. Butun sonlar faqat Number.MAX_SAFE_INTEGER (9 007 199 254 740 991) gacha aniq — undan kattasini satr yoki BigInt'da saqlang. NaN ni Number.isNaN bilan, -0 ni Object.is bilan tekshiring.

Bu darsda

• JavaScript'da nega faqat bitta son turi borligini va u qanday chegaralarga ega ekanini tushuntira olasiz.
• Kasr sonlarni Number.EPSILON yoki o'z chegarangiz bilan to'g'ri solishtira olasiz.
• Number.MAX_SAFE_INTEGER va Number.isSafeInteger yordamida katta butun sonlardagi xavfni aniqlaysiz.
• NaN ni Number.isNaN bilan to'g'ri tekshira olasiz va eski global isNaN ga nega ishonmaslik kerakligini bilasiz.
• -0 qayerdan chiqishini, qanday yashirinishini va qachon muammo berishini taniysiz.

Oldin bilishingiz kerak: Sonlar ichkarida: kasr sonlar va bitli amallar, Arifmetik operatorlar, Tenglik: ==, === va Object.is, Turlarni aniq o'zgartirish.

1. Nega bu kerak?

Siz to'lov tizimi uchun kod yozyapsiz. Foydalanuvchi Humo karta raqamini kiritdi, siz uni son sifatida saqladingiz:

const karta = 9860123456789013;

console.log(karta); // 9860123456789012

Oxirgi raqam 3 edi, 2 bo'lib qoldi. Hech qanday xato chiqmadi — JavaScript raqamni jimgina o'zgartirdi. Pul boshqa kartaga ketishi mumkin edi.

Ikkinchi holat. Bozordagi tarozi dasturi 0,7 kg va 0,1 kg ni qo'shib, 0,8 kg bilan solishtiradi:

const jami = 0.7 + 0.1;

console.log(jami); // 0.7999999999999999
console.log(jami === 0.8); // false

Ikkala muammo ham bitta sababdan: JavaScript sonni qanday saqlashidan. Bu darsda shu "ichki qurilma"ni JavaScript tomondan ko'ramiz va har bir tuzoq uchun tayyor himoya olasiz.

2. JavaScript'da bitta son turi

2.1 Butun va kasr — bitta tur

Ko'p tillarda butun son (int) va kasr son (float) — alohida turlar. JavaScript'da esa oddiy son turi bitta — number:

console.log(typeof 5); // number
console.log(typeof 5.5); // number
console.log(5 === 5.0); // true

5 va 5.0 — aynan bir xil qiymat. Ichkarida ikkalasi ham kasr son sifatida saqlanadi.

Maslahat: Juda katta butun sonlar uchun ikkinchi son turi ham bor — bigint. Uni BigInt darsida o'rganamiz. Shu darsgacha "son" deganda doim number tushuniladi.

2.2 64 bit qanday taqsimlanadi

Sonlar ichkarida darsida IEEE 754 standartini ko'rgan edingiz. JavaScript uning 64 bitli variantini ishlatadi. U "double" (ikki karra aniqlik) deb ham ataladi:

Bu darsdagi hamma chegaralar shu jadvaldan kelib chiqadi:

• Raqamlar uchun 52 bit (va yana bitta "yashirin" bit) → butun sonlar faqat ma'lum chegaragacha aniq.
• Daraja uchun 11 bit → sonning o'zi ham cheksiz katta bo'la olmaydi.
• Ishora alohida bit → nolning ham ikki xil ishorasi bor: 0 va -0.

Hayotdan o'xshatish: chizg'ich. Unda millimetr belgilari bor, lekin 0,3 mm ni aniq belgilab bo'lmaydi — eng yaqin belgini olasiz. JavaScript sonlari ham shunday "belgilar"dan iborat. G'alati tomoni: noldan uzoqlashgan sari belgilar orasi kengayib boradi.

3. Kasr sonlar va Number.EPSILON

3.1 0.1 aslida 0.1 emas

Arifmetika darsida 0.1 + 0.2 natijasi 0.30000000000000004 ekanini ko'rgan edik. Sababi A-10 darsida: 0.1 ni ikkilik tizimda aniq yozib bo'lmaydi.

JavaScript'da buni o'z ko'zingiz bilan ko'rsa bo'ladi. toFixed(20) sonni kasrdan keyin 20 ta raqam bilan ko'rsatadi (bu metodni matn va son darsida o'rganamiz):

console.log((0.1).toFixed(20)); // 0.10000000000000000555
console.log((0.3).toFixed(20)); // 0.29999999999999998890

Xotirada 0.1 emas, unga juda yaqin son saqlangan. 0.3 esa 0.3 dan sal kichik.

Unda nega console.log(0.1) shunchaki 0.1 ko'rsatadi? JavaScript sonni ekranga chiqarganda "shu sonni boshqasidan ajratish uchun yetarli bo'lgan eng qisqa yozuv"ni tanlaydi. 0.1 ga eng yaqin saqlangan son uchun bu — 0.1. 0.1 + 0.2 natijasi esa 0.3 ning "belgisi"ga emas, qo'shni belgiga tushadi. Shuning uchun uzun yozuv chiqadi.

3.2 Number.EPSILON — eng kichik qadam

Number.EPSILON — 1 va undan keyingi eng yaqin son orasidagi farq. Ya'ni "chizg'ich"ning 1 atrofidagi eng kichik qadami:

console.log(Number.EPSILON); // 2.220446049250313e-16
console.log(Number.EPSILON === 2 ** -52); // true

2.220446049250313e-16 yozuvi — "2,22 ni 10 ning −16 darajasiga ko'paytir", ya'ni 0.000000000000000222. Bu ilmiy yozuv, uni son yozish shakllari darsida batafsil ko'ramiz. 2 ** -52 esa 52 bitli mantissaning eng kichik bo'lagi.

Number.EPSILON dan kichik narsani 1 ga qo'shsangiz, hech narsa o'zgarmaydi:

console.log(1 + Number.EPSILON === 1); // false
console.log(1 + Number.EPSILON / 2 === 1); // true

Yarim qadam "belgilar" orasiga tushdi va eng yaqin belgiga — 1 ga yaxlitlandi.

3.3 Kasrlarni to'g'ri solishtirish

Kasrlarni === bilan solishtirish ishonchsiz. To'g'ri usul: "ular orasidagi farq juda kichikmi?" deb so'rash:

const jami = 0.7 + 0.1;
const farq = Math.abs(jami - 0.8);

console.log(farq); // 1.1102230246251565e-16
console.log(farq < Number.EPSILON); // true

Math.abs(x) — sonning ishorasini olib tashlaydi: Math.abs(-3) → 3. Farq manfiy chiqsa ham, biz faqat uning kattaligini solishtiramiz. Math ni Math obyekti darsida to'liq o'rganamiz.

Qoida: Math.abs(a - b) < Number.EPSILON — "a va b amalda teng".

3.4 Katta sonlarda EPSILON yetmaydi

Number.EPSILON — 1 atrofidagi qadam. Sonlar kattalashgan sari qadam ham kattalashadi. 1000 atrofida u allaqachon EPSILON dan ming baravar katta:

const jami = 1000.1 + 1000.2;
const farq = Math.abs(jami - 2000.3);

console.log(jami); // 2000.3000000000002
console.log(farq < Number.EPSILON); // false
console.log(farq < 0.000001); // true

Shuning uchun amalda ko'pincha o'z chegarangizni (tolerance) tanlaysiz. Tarozi uchun milligramm aniqligi yetarli: 0.000001 kg. Masofa uchun santimetr: 0.01 metr. Chegara vazifaning o'zidan kelib chiqadi.

Diqqat: Pul uchun bu usul ham yaramaydi. Pulni hech qachon kasr son sifatida hisoblamang — tiyinda, butun son bilan hisoblang. Buni pul va aniq hisob-kitob darsida o'rganamiz.

Tekshirib ko'ring: 0.2 + 0.4 === 0.6 nima beradi? Qanday tekshirish to'g'ri?

4. Butun sonlar chegarasi: MAX_SAFE_INTEGER

4.1 Xavfsiz chegara

Mantissada 52 bit va bitta "yashirin" bit bor — jami 53 bit raqam. Demak, 2 ning 53-darajasigacha har bir butun sonni aniq saqlash mumkin. Bu chegara tayyor nom bilan berilgan:

console.log(Number.MAX_SAFE_INTEGER); // 9007199254740991
console.log(Number.MAX_SAFE_INTEGER === 2 ** 53 - 1); // true
console.log(Number.MIN_SAFE_INTEGER); // -9007199254740991

To'qqiz kvadrillion — juda katta son. Lekin 16 xonali karta raqami va ba'zi ID'lar undan oshib ketadi.

4.2 Chegaradan keyin nima bo'ladi?

Chegaradan keyin "belgilar" orasidagi qadam 2 ga teng bo'ladi. Endi har bir butun sonni saqlab bo'lmaydi — faqat har ikkinchisini:

const chegara = 2 ** 53;

console.log(chegara); // 9007199254740992
console.log(chegara + 1); // 9007199254740992
console.log(chegara + 2); // 9007199254740994
console.log(chegara === chegara + 1); // true

chegara + 1 — yana o'sha son. Toq son yo'q, u eng yaqin juft songa yaxlitlandi. Matematikada mumkin bo'lmagan x === x + 1 endi true!

Darsning boshidagi karta raqami ham shu sababli buzildi. 9860123456789013 chegaradan katta va toq, uni saqlab bo'lmaydi.

4.3 Number.isSafeInteger — tekshiruv

Number.isSafeInteger(x) — "x butun sonmi va xavfsiz chegara ichidami?" deb so'raydi:

console.log(Number.isSafeInteger(8600123456789012)); // true
console.log(Number.isSafeInteger(9860123456789012)); // false
console.log(Number.isSafeInteger(2 ** 53)); // false
console.log(Number.isSafeInteger(5.5)); // false
console.log(Number.isSafeInteger("5")); // false

• Uzcard raqami (8600...) chegaradan kichik — xavfsiz.
• Humo raqami (9860...) chegaradan katta — xavfsiz emas.
• 5.5 butun emas, "5" esa son emas (satr). Metod turni o'zgartirmaydi.

Yaqin qarindoshi — Number.isInteger(x): faqat "butunmi?" deb so'raydi, chegarani tekshirmaydi. Ikkalasini matn va son darsida yana ishlatamiz.

Maslahat: Karta raqami, telefon raqami, pasport raqami — bular "son" emas, raqamlar ketma-ketligi. Ular bilan hisob-kitob qilinmaydi, shuning uchun ularni doim satrda saqlang: "9860123456789013". Katta butun sonlar bilan haqiqatan hisoblash kerak bo'lsa — BigInt.

Tekshirib ko'ring: Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2 nima beradi?

5. Eng katta, eng kichik va Infinity

MAX_SAFE_INTEGER — aniqlik chegarasi. Lekin sonning o'zi bundan ancha katta bo'la oladi:

console.log(Number.MAX_VALUE); // 1.7976931348623157e+308
console.log(Number.MAX_VALUE * 2); // Infinity
console.log(Number.MIN_VALUE); // 5e-324
console.log(Number.MIN_VALUE / 2); // 0

• Number.MAX_VALUE — saqlanishi mumkin bo'lgan eng katta son: taxminan 1,8 ni 10 ning 308-darajasiga ko'paytirilgani. Undan kattasi Infinity bo'ladi. Bu to'lib ketish (overflow) deyiladi.
• Number.MIN_VALUE — eng kichik musbat son, noldan juda oz katta. Undan kichigi 0 ga aylanadi.

Diqqat: Number.MIN_VALUE — eng kichik manfiy son emas! Nomi aldaydi. Eng kichik manfiy son — -Number.MAX_VALUE.

Infinity ni arifmetika darsida nolga bo'lishda ko'rgan edingiz. U number turidagi oddiy qiymat va hisobda ishtirok etadi:

console.log(Infinity + 1); // Infinity
console.log(Infinity - Infinity); // NaN
console.log(Infinity * 0); // NaN
console.log(Number.POSITIVE_INFINITY === Infinity); // true

Oxirgi ikki amalning ma'nosi yo'q — natija NaN. Son chekli ekanini tekshiradigan Number.isFinite bilan matn va son darsida tanishasiz.

6. NaN chuqurroq

6.1 Eslaymiz

Oldingi darslardan bilasiz: NaN ("Not a Number" — son emas) — number turidagi maxsus qiymat. U ma'nosiz hisobdan chiqadi va o'ziga ham teng emas (tenglik darsi):

console.log(typeof NaN); // number
console.log(NaN === NaN); // false
console.log(0 / 0); // NaN
console.log(Number("salom")); // NaN
console.log(undefined + 1); // NaN

6.2 NaN — "yuqumli"

NaN ning eng xavfli xususiyati: u hisob-kitob bo'ylab jimgina tarqaladi. NaN ishtirok etgan har qanday arifmetik amal natijasi ham NaN:

const non = 4000;
const choy = 3000;
const somsa = Number("8 000"); // foydalanuvchi bo'sh joy bilan yozdi

const jami = non + choy + somsa;
const chegirma = jami * 0.1;

console.log(somsa); // NaN
console.log(jami); // NaN
console.log(chegirma); // NaN

Bitta buzuq narx butun chekni buzdi. Xato esa chiqmadi — ekranda shunchaki "Jami: NaN so'm" paydo bo'ladi. Shuning uchun foydalanuvchidan kelgan sonni darhol tekshirish kerak.

6.3 Number.isNaN — to'g'ri tekshiruv

NaN o'ziga ham teng emas, shuning uchun x === NaN hech qachon true bermaydi. NaN ni aniqlash uchun maxsus funksiya bor:

console.log(Number.isNaN(NaN)); // true
console.log(Number.isNaN(0 / 0)); // true
console.log(Number.isNaN(5)); // false

Number.isNaN(x) bitta savol beradi: "x aynan NaN qiymatimi?".

Eski kodda oldida Number. yo'q global isNaN ni ham uchratasiz. U boshqacha ishlaydi: qiymatni avval Number() bilan songa aylantiradi, keyin tekshiradi. Shuning uchun isNaN("salom") ham true beradi, garchi "salom" — satr bo'lsa ham. Ikkalasining farqini jadval bilan Matn ↔ son va sonni tekshirish darsida ko'ramiz. Hozircha qoida: doim Number.isNaN ishlating.

Maslahat: Eski kodda x !== x degan g'alati tekshiruvni uchratishingiz mumkin. Bu ham NaN testi: JavaScript'da faqat NaN o'ziga teng emas. Ishlaydi, lekin tushunarsiz — Number.isNaN(x) yozing.

Tekshirib ko'ring: isNaN("12px") va Number.isNaN("12px") nima qaytaradi?

7. -0: yashirin minus

7.1 -0 qayerdan chiqadi?

Tenglik darsida ko'rdingiz: JavaScript'da 0 va -0 bor. Sababi — ishora uchun alohida bit. Nol natija chiqqanda ham bu bit "minus" holida qolishi mumkin:

console.log(0 * -1); // -0
console.log(0 / -5); // -0
console.log(-5 % 5); // -0
console.log(Math.round(-0.3)); // -0

Oxirgisi eng ko'p uchraydi. Math.round — eng yaqin butun songa yaxlitlash (Math darsi). -0.3 ning eng yaqin butuni — nol. Lekin son manfiy tomondan kelgani uchun ishora saqlanib qoldi.

Nega bunday qilingan? -0 "noldan manfiy tomonga juda yaqin" degan ma'lumotni saqlaydi. Masalan, yo'nalish yoki juda kichik manfiy harorat. Matematik hisoblarda bu ba'zan muhim.

7.2 -0 qanday yashirinadi

-0 ni ko'pchilik sezmaydi, chunki deyarli hamma joyda u oddiy 0 dek ko'rinadi:

const nol = 0 * -1;

console.log(nol === 0); // true
console.log(String(nol)); // 0
console.log(`${nol} gradus`); // 0 gradus
console.log(nol + 0); // 0

=== ularni farqlamaydi. Satrga aylanganda minus yo'qoladi. Faqat console.log(nol) ning o'zi -0 ko'rsatadi — Node'da ham, brauzer konsolida ham.

Aniq tekshirish uchun — Object.is:

const nol = 0 * -1;

console.log(Object.is(nol, -0)); // true
console.log(Object.is(nol, 0)); // false
console.log(1 / nol); // -Infinity

Oxirgi qator — eski hiyla: 1 / -0 natijasi -Infinity, 1 / 0 esa Infinity. Eski kodda uchratasiz, o'zingiz Object.is yozing.

7.3 Qachon muammo beradi?

Ob-havo ilovasini tasavvur qiling. Datchik -0.04 gradus o'lchadi. Siz uni bitta kasr raqam bilan ko'rsatmoqchisiz:

const harorat = -0.04;

console.log(harorat.toFixed(1)); // -0.0

Ekranda "-0.0 °C" chiqadi. Foydalanuvchi "minus nol nima?" deb hayron bo'ladi. toFixed satr yasaganda ishorani saqlab qoldi.

Yechim: avval yaxlitlaymiz, keyin -0 ni oddiy 0 ga almashtiramiz. Bu yerda ternary yordam beradi — -0 === 0 rost bo'lgani uchun shart -0 ni ham ushlaydi:

const harorat = -0.04;
const yaxlit = Math.round(harorat * 10) / 10;
const toza = yaxlit === 0 ? 0 : yaxlit;

console.log(yaxlit); // -0
console.log(toza.toFixed(1)); // 0.0

Math.round(harorat * 10) / 10 — "bitta kasr raqamgacha yaxlitlash" retsepti. Natija -0 bo'ldi. Ternary uni haqiqiy 0 ga almashtirdi va endi ekranda "0.0 °C".

Tekshirib ko'ring: const x = -0; bo'lsa, x === 0 va Object.is(x, 0) nima beradi?

8. Ko'p uchraydigan xatolar

8.1 Kasrni === bilan solishtirish

0.7 + 0.1 === 0.8 — false. Hisoblangan kasr sonlarni doim farq orqali solishtiring: Math.abs(a - b) < chegara. Chegara 1 atrofida Number.EPSILON, katta sonlarda — vazifaga mos kichik son.

8.2 Katta ID'ni son sifatida saqlash

Karta raqami yoki serverdan kelgan 17–19 xonali ID son bo'lsa, oxirgi raqamlari jimgina o'zgaradi. Hisob-kitob qilinmaydigan "raqamlar"ni satrda saqlang. Shubha bo'lsa — Number.isSafeInteger bilan tekshiring.

8.3 Global isNaN ga ishonish

isNaN("") — false, isNaN(undefined) — true. Natija qiymatning o'ziga emas, uning songa aylanishiga bog'liq. Number.isNaN ishlating.

8.4 Number.MIN_VALUE ni "eng kichik son" deb o'ylash

U — eng kichik musbat son (5e-324). Manfiy chegara kerak bo'lsa: -Number.MAX_VALUE yoki butun sonlar uchun Number.MIN_SAFE_INTEGER.

8.5 Doimiylarni o'zgartirishga urinish

Number.EPSILON, Number.MAX_SAFE_INTEGER kabi qiymatlar — faqat o'qish uchun. Ularni o'zgartirmoqchi bo'lsangiz:

Number.MAX_SAFE_INTEGER = 10;

TypeError: Cannot assign to read only property 'MAX_SAFE_INTEGER' of function 'function Number() { [native code] }'

Tarjimasi: "Number funksiyasining faqat o'qiladigan MAX_SAFE_INTEGER xususiyatiga qiymat berib bo'lmaydi". function Number() qismidan qo'rqmang — Number ning o'zi aslida funksiya, shuning uchun xabar uni shunday ataydi. [native code] — "JavaScript ichiga o'rnatilgan kod".

Bu xato modul fayllarda (.mjs, <script type="module">) chiqadi. Oddiy skriptda esa JavaScript xato bermaydi — qiymat shunchaki o'zgarmay qoladi. Ikkala holatda ham bunday kod yozmang.

9. Mashqlar

1-mashq (oson): Xavfsizmi?

Quyidagi qiymatlarning har biri uchun Number.isSafeInteger natijasini konsolga chiqaring. Avval taxmin qiling:

• Telegram foydalanuvchi ID'si: 1234567890123
• Kutubxona kitobining 17 xonali kodi: 12345678901234567
• Vazn: 72.5

console.log(Number.isSafeInteger(1234567890123)); // true
console.log(Number.isSafeInteger(12345678901234567)); // false
console.log(Number.isSafeInteger(72.5)); // false

2-mashq (o'rta): Tarozi

Malika bozorda 0,7 kg olma va 0,1 kg mayiz tortdi. Buyurtmada "0,8 kg" deb yozilgan. Ikki tekshiruvni konsolga chiqaring:

1. === bilan solishtirish natijasi.
2. Math.abs va 1 milligramm (0.000001 kg) chegarasi bilan solishtirish. Natijani ternary bilan "Vazn to'g'ri" yoki "Vazn noto'g'ri" deb chiqaring.

const olma = 0.7;
const mayiz = 0.1;
const buyurtma = 0.8;
const jami = olma + mayiz;

console.log(jami === buyurtma); // false

const teng = Math.abs(jami - buyurtma) < 0.000001;
console.log(teng ? "Vazn to'g'ri" : "Vazn noto'g'ri"); // Vazn to'g'ri

3-mashq (qiyin): Ob-havo va chek

Ikki kichik vazifa.

A. Datchik -0.3 gradus ko'rsatdi. Uni butun songa yaxlitlang (Math.round), keyin natija -0 ekanini Object.is bilan tekshiring. So'ng ternary bilan -0 ni 0 ga almashtirib, `${toza} °C` ko'rinishida chiqaring.

B. Chekda uch narx bor: 12000, Number("5 000") va 3000. Jamini hisoblang. Number.isNaN bilan jami buzilganini tekshiring va ternary bilan "Chek xato: narxni tekshiring" yoki `Jami: ${jami} so'm` deb chiqaring.

// A
const olchov = -0.3;
const yaxlit = Math.round(olchov);
const toza = yaxlit === 0 ? 0 : yaxlit;

console.log(Object.is(yaxlit, -0));
console.log(`${toza} °C`);

// B
const jami = 12000 + Number("5 000") + 3000;
const xabar = Number.isNaN(jami)
  ? "Chek xato: narxni tekshiring"
  : `Jami: ${jami} so'm`;

console.log(xabar);

true
0 °C
Chek xato: narxni tekshiring

10. Real ishda

• Katta ID'lar: X (Twitter) postlarining ID'lari 2010-yilda MAX_SAFE_INTEGER dan oshib ketdi. Shundan beri ularning API'si har bir ID'ni ikki marta beradi: son va satr (id_str). JavaScript dasturchilari satrni ishlatadi.
• Telegram Bot API: hujjatda to'g'ridan-to'g'ri yozilgan: foydalanuvchi ID'si 52 bitdan oshmaydi, shuning uchun JavaScript sonida xavfsiz saqlanadi. Bunday izohlar aynan shu dars mavzusi haqida.
• Ma'lumotlar bazasi: PostgreSQL'dagi katta butun son (bigint) Node'ga ko'pincha satr bo'lib keladi — kutubxonalar aniqlikni yo'qotmaslik uchun shunday qiladi. Buni backend darslarida ko'rasiz — hozir sababini bilasiz.
• Grafiklar va ob-havo: "-0" yozuvi foydalanuvchi interfeysida tez-tez chiqadigan kichik, lekin noqulay xato.
• Intervyu: "Nega 0.1 + 0.2 !== 0.3?", "NaN === NaN nima beradi?", "MAX_SAFE_INTEGER nima?" — boshlang'ich darajadagi frontend va backend intervyularining klassik savollari.

Xulosa

• JavaScript'da oddiy son turi bitta — number, u 64 bitli IEEE 754 kasr son.
• Kasrlarni === bilan emas, Math.abs(a - b) < Number.EPSILON (yoki o'z chegarangiz) bilan solishtiring.
• Butun sonlar Number.MAX_SAFE_INTEGER gacha aniq. Katta ID va karta raqamlarini satrda saqlang, tekshirish uchun Number.isSafeInteger.
• Number.MAX_VALUE dan kattasi — Infinity. Number.MIN_VALUE — eng kichik musbat son.
• NaN hisob bo'ylab tarqaladi. Uni Number.isNaN bilan tekshiring, global isNaN bilan emas.
• -0 deyarli hamma joyda 0 dek ko'rinadi. Aniqlash uchun — Object.is, ekranga chiqarishdan oldin tozalang.

Manbalar

• MDN: Number
• MDN: Number.EPSILON

Keyingi dars: Son yozish shakllari va sanoq tizimlari — 1_000_000, 1e6, 0xff kabi yozuvlarni va sonni ikkilik yoki o'n oltilik tizimga o'tkazishni o'rganamiz.