JavaScript'da matnni songa aylantirish: Number, parseInt va sonni tekshirish

Qisqacha: Satrni songa aylantirishning uch yo'li bor: qat'iy Number("12"), kechirimli parseInt("12px", 10) va parseFloat("1.5kg"). Aylantirgandan keyin natijani albatta tekshiring: Number.isFinite(x) — to'g'ri sonmi, Number.isInteger(x) — butunmi. Teskari yo'nalishdagi toFixed(2) esa son emas, satr qaytaradi.

Bu darsda

• Number, unar +, parseInt va parseFloat qaysi satrni qanday o'qishini aniq bilasiz.
• parseInt ga nega doim ikkinchi qiymat — 10 — yozilishini tushuntira olasiz.
• Number.isNaN, Number.isFinite, Number.isInteger, Number.isSafeInteger bilan sonni tekshira olasiz.
• toFixed va toPrecision satr qaytarishini va undagi tuzoqlarni bilasiz.
• Formadan kelgan "12 000 so'm" kabi matnni tozalab, songa aylantirib, tekshira olasiz.

Oldin bilishingiz kerak: Turlarni aniq o'zgartirish, Number turi JS'da, Son yozish shakllari va sanoq tizimlari, Matnni o'zgartirish va tozalash.

1. Nega bu kerak?

Oldingi darsda sonni turli shakllarda yozishni ko'rdik: 0xff, 1e6, 1_000_000. Endi teskari savol: son matn bo'lib kelsa-chi?

Tasavvur qiling: siz Payme'ga o'xshash ilovada "O'tkazma summasi" maydonini yozyapsiz. Foydalanuvchilar summani har xil yozadi:

console.log(Number("12000")); // 12000
console.log(Number("12 000 so'm")); // NaN
console.log(Number("1e9")); // 1000000000
console.log(Number("-5000")); // -5000

Birinchisi to'g'ri. Ikkinchisi — oddiy odam yozgan eng tabiiy summa, lekin NaN. Uchinchisini kimdir ataylab yozgan: 1e9 — bu bir milliard! To'rtinchisi — manfiy o'tkazma, ya'ni boshqaning hisobidan pul olishga urinish.

Demak, ish ikki qadamdan iborat:

1. Aylantirish — satrdan son olish.
2. Tekshirish — olingan son haqiqatan biz kutgan sonmi.

Turlarni aniq o'zgartirish darsida birinchi qadam bilan tanishgandik. Bu darsda ikkalasini ham oxirigacha o'rganamiz.

Hayotdan o'xshatish: bankka pul topshirasiz. Kassir avval pulni sanaydi (aylantirish), keyin har bir kupyurani chiroqqa tutib qalbaki emasligini tekshiradi (tekshirish). Faqat sanash yetarli emas.

2. Number() qaysi satrni qabul qiladi?

2.1 Number son deb biladigan satrlar

Turlarni aniq o'zgartirish darsidan eslaysiz: Number() qat'iy. Satr to'liq son bo'lsa qabul qiladi, bitta begona belgi bo'lsa — NaN. Lekin "to'liq son" deganda JavaScript siz kutgandan ko'proq narsani tushunadi:

console.log(Number("1e3")); // 1000
console.log(Number("0x10")); // 16
console.log(Number("0b101")); // 5
console.log(Number("Infinity")); // Infinity
console.log(Number(".5")); // 0.5
console.log(Number("5.")); // 5
console.log(Number("+7")); // 7

Bular — oldingi darsdagi son yozish shakllari. JavaScript kodda 1e3 ni son deb tushunsa, satr ichida ham tushunadi. Formada esa bu kutilmagan "eshik" bo'lishi mumkin — buni 6-bo'limda ko'ramiz.

2.2 Number rad etadigan satrlar

console.log(Number("12_000")); // NaN
console.log(Number("12,5")); // NaN
console.log(Number("12 000")); // NaN
console.log(Number("12px")); // NaN

Birinchi qatorga e'tibor bering. Kodda 12_000 yozsangiz — bu son, 12000. Lekin satr ichidagi "12_000" — NaN. Pastki chiziq faqat dasturchi kodni o'qishi uchun, u satrdan son o'qishda ishlamaydi.

2.3 Unar + — xuddi Number

Unar + aynan Number() qoidalari bilan ishlaydi. Farqi faqat yozilishida:

console.log(+"1e3"); // 1000
console.log(+"12px"); // NaN
console.log(+"  8  "); // 8

Shuning uchun bu darsda Number() haqida aytilgan hamma gap unar + ga ham tegishli.

Tekshirib ko'ring: Number("0x1A") va Number("1_5") nima qaytaradi?

3. parseInt va parseFloat chuqurroq

3.1 Boshidan o'qib, to'xtaydi

parseInt va parseFloat boshqacha ishlaydi. Ular satrni chapdan o'ngga o'qiydi va son bo'lmagan birinchi belgida to'xtaydi. Boshidagi bo'sh joylar va ishora (-, +) hisobga olinadi:

console.log(parseInt("  42abc", 10)); // 42
console.log(parseInt("-12.9", 10)); // -12
console.log(parseFloat("3.14.15")); // 3.14
console.log(parseFloat(".5")); // 0.5
console.log(parseInt("so'm 500", 10)); // NaN

Oxirgi qatorda satr harf bilan boshlangan. Boshida bitta ham raqam yo'q — natija NaN.

Hayotdan o'xshatish: kassir chekni chapdan o'qiydi va birinchi tushunarsiz belgida to'xtaydi. Number esa qat'iy nazoratchi: chekda bitta ortiqcha belgi bo'lsa, butun chekni qaytaradi.

3.2 1e3 bilan qiziq farq

console.log(Number("1e3")); // 1000
console.log(parseFloat("1e3")); // 1000
console.log(parseInt("1e3", 10)); // 1

parseFloat ilmiy yozuvni (e) taniydi. parseInt esa faqat butun son raqamlarini o'qiydi: 1 ni oladi, e da to'xtaydi.

3.3 Radix — sanoq tizimi

parseInt dagi ikkinchi qiymat radix (sanoq tizimi asosi) deyiladi. U 2 dan 36 gacha bo'ladi va "satrni qaysi sanoq tizimida o'qiyman" degan savolga javob beradi. Son yozish shakllari darsida parseInt("ff", 16) ni ko'rgandik:

console.log(parseInt("ff", 16)); // 255
console.log(parseInt("101", 2)); // 5
console.log(parseInt("12", 2)); // 1
console.log(parseInt("2", 2)); // NaN

Uchinchi qatorga qarang. Ikkilik tizimda faqat 0 va 1 bor. parseInt 1 ni o'qidi, 2 ni "begona belgi" deb to'xtadi. To'rtinchi qatorda esa birinchi belgining o'zi begona.

Endi eng muhim savol: radix yozilmasa nima bo'ladi?

console.log(parseInt("0x1f")); // 31
console.log(parseInt("0x1f", 10)); // 0
console.log(parseInt("08")); // 8

Radix yozilmasa, parseInt satr boshiga qaraydi. 0x bilan boshlansa — o'n oltilik deb o'qiydi. Tasavvur qiling: mahsulot kodi "0x1f" bo'lib qolgan, siz esa o'nlik son kutyapsiz. Natija jimgina 31 bo'ladi — xato xabarisiz.

Maslahat: Eski brauzerlarda parseInt("08") sakkizlik tizimda o'qilib, 0 qaytarardi. Hozir bu tuzatilgan, lekin 0x tuzog'i qolgan. Qoida oddiy: radix'ni har doim yozing — parseInt(s, 10). ESLint (kodni avtomatik tekshiradigan vosita, keyinroq o'rganamiz) buni radix qoidasi bilan eslatib turadi.

3.4 parseFloat da radix yo'q

parseFloat faqat o'nlik tizimda ishlaydi, ikkinchi qiymat qabul qilmaydi. 0x ni ham tanimaydi:

console.log(parseFloat("0x10")); // 0
console.log(parseFloat("12,5")); // 12

Ikkinchi qator — O'zbekistonda ko'p uchraydigan tuzoq. Vergulli kasr 12,5 jimgina 12 ga aylandi. Yarim kilogramm yo'qoldi, xato esa chiqmadi.

3.5 parseInt ga son bermang

parseInt satr uchun yaratilgan. Unga son bersangiz, avval sonni satrga aylantiradi. Bu kutilmagan natija beradi:

console.log(parseInt(0.0000005)); // 5
console.log(String(0.0000005)); // 5e-7

Juda kichik son satrga "5e-7" bo'lib aylanadi. parseInt undan 5 ni o'qiydi va e da to'xtaydi. Natija — nol o'rniga besh!

Sonning kasr qismini tashlash kerak bo'lsa, parseInt emas, Math.trunc yoki Math.floor ishlating. Ularni keyingi darsda o'rganamiz.

Maslahat: Number.parseInt va Number.parseFloat ham bor. Ular global parseInt va parseFloat ning aynan o'zi: Number.parseInt === parseInt — true. Zamonaviy kodda ikkalasini ham uchratasiz.

Tekshirib ko'ring: parseInt("15px", 10) + parseInt("5px", 10) va parseInt("0x1f", 16) nima beradi?

4. Sonni tekshirish

Satrni aylantirdik. Endi natijani tekshirish kerak. Number obyektida buning uchun to'rtta tayyor tekshiruv bor.

4.1 Number.isNaN va global isNaN

Tenglik darsidan bilasiz: NaN === NaN — false. Shuning uchun NaN ni maxsus tekshiruv bilan aniqlaymiz. Number turi darsida Number.isNaN bilan tanishdik va eski global isNaN ham borligini aytdik. Endi ularning farqini aniq ko'ramiz — bu ikki tekshiruv har xil ishlaydi:

console.log(isNaN("salom")); // true
console.log(Number.isNaN("salom")); // false
console.log(isNaN("")); // false
console.log(isNaN(undefined)); // true

Global isNaN (oldida Number. yo'q) avval qiymatni songa aylantiradi, keyin tekshiradi. "salom" → NaN → true. "" → 0 → false.

Number.isNaN esa hech narsani aylantirmaydi. U bitta savolga javob beradi: "bu qiymatning o'zi NaN mi?" "salom" — satr, NaN emas. Shuning uchun false.

Qoida: Number.isNaN ishlating va uni aylantirishdan keyin qo'llang:

const kiritilgan = "salom";
const son = Number(kiritilgan);

console.log(Number.isNaN(son)); // true

4.2 Number.isFinite — eng foydali tekshiruv

NaN dan tashqari yana bir "yolg'on son" bor — Infinity. U ham number turida, lekin summa sifatida ma'nosiz. Number turi darsida ko'rgandik:

const son = Number("1e999");

console.log(son); // Infinity
console.log(Number.isNaN(son)); // false
console.log(Number.isFinite(son)); // false

1e999 — juda katta son, u Infinity ga aylandi. Number.isNaN uni o'tkazib yubordi: Infinity — NaN emas. Number.isFinite esa ushladi.

Number.isFinite(x) faqat bitta holatda true beradi: x — oddiy, chekli son bo'lsa. NaN, Infinity, -Infinity va son bo'lmagan har qanday qiymat — false. Ya'ni bitta tekshiruv ikkita muammoni ushlaydi.

Bu yerda ham global "egizak" bor — isFinite. U ham avval aylantiradi:

console.log(isFinite("12")); // true
console.log(Number.isFinite("12")); // false
console.log(isFinite(null)); // true

Qoida xuddi o'sha: Number. bilan boshlanadiganini ishlating. Global isNaN va isFinite — JavaScript'ning eski, 1990-yillardan qolgan versiyalari.

4.3 Number.isInteger — butunmi?

Ba'zi qiymatlar faqat butun bo'lishi kerak: mahsulot soni, yosh, xonadon raqami. 2,5 ta non sotib bo'lmaydi.

console.log(Number.isInteger(5)); // true
console.log(Number.isInteger(5.0)); // true
console.log(Number.isInteger(5.5)); // false
console.log(Number.isInteger("5")); // false
console.log(Number.isInteger(Infinity)); // false

Ikkinchi qator g'alati tuyulishi mumkin. Lekin JavaScript uchun 5.0 va 5 — bir xil son, ular farqlanmaydi. Number.isInteger ham aylantirmaydi: "5" satri — false. NaN va Infinity ham false. Demak Number.isInteger o'z ichida Number.isFinite tekshiruvini ham bajaradi.

4.4 Number.isSafeInteger va "son bo'lmagan raqamlar"

Number turi darsida Humo karta raqami songa aylanganda oxirgi raqami jimgina o'zgarib qolganini va Number.isSafeInteger buni aniqlashini ko'rdik. Satrdan aylantirganda ham xuddi shunday:

const karta = Number("9860123456789013");

console.log(karta); // 9860123456789012
console.log(Number.isSafeInteger(karta)); // false

...013 — ...012 bo'lib qoldi. Eslatma: Number.isSafeInteger son butun va xavfsiz chegarada bo'lsagina true beradi.

Bundan muhim xulosa kelib chiqadi. Karta raqami, telefon raqami, pasport seriyasi, buyurtma ID si — bular "son" emas, raqamlardan iborat matn. Ular bilan hech kim qo'shish yoki ko'paytirish qilmaydi. Ularni songa aylantirsangiz, boshqa narsalar ham yo'qoladi:

console.log(Number("+998901234567")); // 998901234567
console.log(Number("007")); // 7

+ belgisi va boshidagi nollar yo'qoldi. Qoida: hisoblamaydigan raqamlarni satr holida saqlang. Juda katta sonlar bilan aniq hisoblash kerak bo'lsa — BigInt bor, uni 3 darsdan keyin o'rganamiz.

Tekshirib ko'ring: Number.isFinite(Number("")) nima qaytaradi? Bu forma tekshiruvi uchun qanday xavf?

5. Sonni matnga: toFixed va toPrecision

5.1 toFixed — kasr xonalari soni

Narxni ekranda chiroyli ko'rsatish uchun ko'pincha aniq ikki xona kerak: 5.00, 12.50. Buni toFixed(n) metodi qiladi — n ta kasr xonasigacha yaxlitlaydi:

const narx = 5;
const kurs = 12650.3456;
const reyting = 4.75;

console.log(narx.toFixed(2)); // 5.00
console.log(kurs.toFixed(2)); // 12650.35
console.log(reyting.toFixed(1)); // 4.8
console.log((0.1 + 0.2).toFixed(2)); // 0.30

Son o'zgaruvchida bo'lsa, metod nuqta bilan chaqiriladi: narx.toFixed(2). Sonning o'ziga yozsangiz, qavsga oling: (5).toFixed(2). Sababi J-18 darsida: 5.toFixed da JavaScript nuqtani kasr belgisi deb o'ylaydi.

5.2 Tuzoq: toFixed satr qaytaradi

Bu darsning eng muhim ogohlantirishi:

const narx = (0.1 + 0.2).toFixed(2);

console.log(typeof narx); // string
console.log(narx + 1); // 0.301

0.30 + 1 = 1.3 kutgandik. Lekin toFixed satr qaytaradi — "0.30". Satrga + 1 esa yopishtirish bo'ladi: "0.301".

Nega satr? Chunki 5.00 dagi nollar faqat matnda mavjud. Son sifatida 5.00 va 5 — bir xil, sonda "ikki xona" degan tushuncha yo'q. toFixed ning vazifasi — ko'rsatish uchun matn tayyorlash.

Qoida: toFixed ni hisob-kitobning eng oxirida, ekranga chiqarishdan oldin ishlating. Oraliq natijani toFixed bilan "yaxlitlab", keyin hisoblashni davom ettirmang.

5.3 toFixed ham adashadi

const a = 1.005;
const b = 2.345;

console.log(a.toFixed(2)); // 1.00
console.log(b.toFixed(2)); // 2.35

1.005 ni ikki xonaga yaxlitlasak, 1.01 kutamiz. Natija esa 1.00. Sababi Number turi darsida: 1.005 xotirada aslida 1.00499999... bo'lib saqlanadi. 2.345 esa tasodifan biroz kattaroq saqlanadi va "to'g'ri" yaxlitlanadi.

Ya'ni toFixed pul hisobi uchun ishonchli emas. Pulni qanday aniq hisoblashni Pul va aniq hisob-kitob darsida ko'ramiz.

5.4 toPrecision — qiymatli raqamlar soni

toPrecision(n) kasr xonalarini emas, jami qiymatli raqamlar sonini belgilaydi. U ham satr qaytaradi:

const son = 1234.5678;
const kichik = 0.000123;

console.log(son.toPrecision(6)); // 1234.57
console.log(kichik.toPrecision(2)); // 0.00012
console.log(son.toPrecision(2)); // 1.2e+3

Uchinchi qatorda son ilmiy yozuvga o'tdi: 2 ta raqam bilan 1234 ni boshqacha yozib bo'lmaydi. toPrecision o'lchov va ilmiy hisoblarda ishlatiladi. Kundalik ishda toFixed ancha ko'p uchraydi.

Tekshirib ko'ring: (7).toFixed(1) + (3).toFixed(1) nima beradi?

6. Amaliyot: "12 000 so'm" ni tekshirish

Endi hammasini birlashtiramiz. Vazifa: foydalanuvchi o'tkazma summasini yozdi. Uni songa aylantirib, to'g'riligini tekshirish kerak.

6.1 To'liq yechilgan misol

const kiritilgan = " 12 000 so'm ";

const tozalangan = kiritilgan
  .replace("so'm", "")
  .replaceAll(" ", "");
const summa = Number(tozalangan);

const togri = Number.isInteger(summa) && summa > 0;

console.log(tozalangan); // 12000
console.log(summa); // 12000
console.log(togri); // true

Qatorma-qator:

1. replace("so'm", "") — "so'm" so'zini olib tashlaymiz. Matnni o'zgartirish darsidan.
2. replaceAll(" ", "") — hamma bo'sh joylarni olib tashlaymiz: chetdagilarni ham, 12 000 o'rtasidagini ham.
3. Number(tozalangan) — qat'iy aylantirish. Tozalanmagan har qanday begona belgi NaN beradi.
4. Number.isInteger(summa) — summa butun son. Bu NaN va Infinity ni ham rad etadi.
5. summa > 0 — manfiy summa va nol rad etiladi. Bo'sh satr 0 ga aylanishini eslaysizmi? U ham shu yerda ushlanadi.

&& — mantiqiy operatorlar darsidagi "va": ikkala shart ham true bo'lsagina togri — true.

Endi natijani foydalanuvchiga ko'rsatamiz. Ternary yordam beradi:

const kiritilgan = "12 000 so'm";
const summa = Number(
  kiritilgan.replace("so'm", "").replaceAll(" ", ""),
);
const togri = Number.isInteger(summa) && summa > 0;

console.log(togri ? `O'tkazma: ${summa} so'm` : "Noto'g'ri summa");
// O'tkazma: 12000 so'm

kiritilgan ni "abc", "-500" yoki "" ga o'zgartirib ko'ring — har safar Noto'g'ri summa chiqadi.

6.2 Vergulli kasr: bo'sh joyni to'ldiring

Endi vazn maydoni: foydalanuvchi "2,5 kg" yozdi. Vergulni nuqtaga almashtirish va "kg" ni olib tashlash kerak. Tekshiruv — Number.isFinite, chunki vazn kasr bo'lishi mumkin.

const kiritilgan = "2,5 kg";

const vazn = Number(
  kiritilgan.replace("kg", "").replace(",", ".").trim(),
);
const togri = Number.isFinite(vazn) && vazn > 0;

console.log(vazn); // 2.5
console.log(togri); // true

Savol: bu yerda nega Number.isInteger emas, Number.isFinite ishlatildi? Chunki vazn bo'lishi mumkin, Number.isInteger(2.5) esa false qaytaradi.

6.3 Nusxalangan matndagi ko'rinmas bo'sh joy

Real hayotdagi tuzoq. Foydalanuvchi summani boshqa saytdan nusxalab qo'ydi. Ekranda 12 000 ko'rinadi, lekin kod ishlamaydi:

const kiritilgan = "12\u00a0000";
const summa = Number(kiritilgan.replaceAll(" ", ""));

console.log(summa); // NaN

\u00a0 — String asoslari darsidagi Unicode escape. Bu uzilmas bo'sh joy (non-breaking space). U oddiy bo'sh joyga o'xshaydi, lekin boshqa belgi. Saytlar undan son ichida foydalanadi: 12 va 000 ikki qatorga bo'linib ketmasin deb. Keyingi darslarda ko'rasiz: JavaScript'ning o'zi ham sonni formatlaganda aynan shu belgini qo'yadi.

replaceAll(" ", "") faqat oddiy bo'sh joyni olib tashlaydi. Yechim — uzilmas bo'sh joyni ham alohida olib tashlash:

const kiritilgan = "12\u00a0000";
const summa = Number(
  kiritilgan.replaceAll(" ", "").replaceAll("\u00a0", ""),
);

console.log(summa); // 12000

Istalgan bo'sh joy turini bittada olib tashlash uchun muntazam ifodalar (regex) ishlatiladi. Ularni RegExp asoslari darsida o'rganamiz.

7. Hujumchi nigohi

Formadagi summa — pul bilan bog'liq joy. Hujumchi uni qanday buzishga urinadi?

6.1 dagi tekshiruvimiz (Number.isInteger va > 0) manfiy, Infinity va kasr summalarni to'xtatadi. Lekin 1e9 va 0x10 o'tib ketadi — ikkalasi ham musbat butun son. Bundan himoyalanishning ikki qo'shimcha qadami bor.

Birinchisi — yuqori chegara. Ilova bir o'tkazmada qancha ruxsat beradi? Masalan 100 million so'm:

const summa = Number("1e9");
const togri =
  Number.isInteger(summa) && summa > 0 && summa <= 100_000_000;

console.log(togri); // false

Ikkinchisi — qayta yozib solishtirish. Sonni yana satrga aylantiramiz. Natija tozalangan matn bilan aynan bir xil bo'lishi kerak:

const tozalangan = "0x10";
const summa = Number(tozalangan);

console.log(String(summa)); // 16
console.log(String(summa) === tozalangan); // false

"0x10" → 16 → "16". Bu "0x10" ga teng emas — demak foydalanuvchi oddiy son yozmagan. Bu usul "1e3", "+5" va "007" ni ham rad etadi. Oddiy "12000" esa "12000" bo'lib qaytadi va o'tadi.

Diqqat: Brauzerdagi har qanday tekshiruvni chetlab o'tish mumkin. Hujumchi sahifani emas, to'g'ridan-to'g'ri serverga so'rov yuboradi. Shuning uchun summa serverda qayta tekshiriladi. Buni Validatsiya darsida to'liq ko'ramiz. Brauzerdagi tekshiruv — foydalanuvchiga qulaylik, himoya esa serverda.

8. Ko'p uchraydigan xatolar

8.1 Global isNaN bilan tekshirish

isNaN("") — false, ya'ni "bo'sh satr son". Global versiya avval aylantiradi va sizni aldaydi. Doim Number.isNaN yoki, yaxshisi, Number.isFinite ishlating.

8.2 NaN ni === bilan tekshirish

const son = Number("abc");

console.log(son === NaN); // false
console.log(Number.isNaN(son)); // true

NaN hech narsaga, hatto o'ziga ham teng emas. son === NaN har doim false — bu shart hech qachon ishlamaydi. Xato xabari ham chiqmaydi, shuning uchun sezish qiyin.

8.3 Radix'siz parseInt

parseInt("0x1f") — 31. Satr qayerdan kelishini bilmasangiz, natijani ham bilmaysiz. Har doim parseInt(s, 10).

8.4 toFixed natijasi bilan hisoblash

2.5-bob.toFixed(1) + 1 — "2.51". toFixed faqat ekranga chiqarish uchun. Hisob-kitob sonlar bilan, formatlash eng oxirida.

8.5 Telefon yoki karta raqamini son qilish

Number("+998901234567") — + yo'qoladi. Number("9860123456789013") — oxirgi raqam o'zgaradi. Hisoblamaydigan raqamlar — satr.

9. Mashqlar

1-mashq (oson): Natijani oldindan ayting

Har bir qator nima chiqarishini daftarga yozing, keyin ishga tushirib tekshiring.

const reyting = 9.5;

console.log(Number("2e2"));
console.log(parseInt("2e2", 10));
console.log(parseFloat("2e2"));
console.log(parseInt("101", 2));
console.log(Number.isNaN("abc"));
console.log(Number.isInteger(7.0));
console.log(reyting.toFixed(0) + 1);

const reyting = 9.5;

console.log(Number("2e2")); // 200
console.log(parseInt("2e2", 10)); // 2
console.log(parseFloat("2e2")); // 200
console.log(parseInt("101", 2)); // 5
console.log(Number.isNaN("abc")); // false
console.log(Number.isInteger(7.0)); // true
console.log(reyting.toFixed(0) + 1); // 101

2-mashq (o'rta): Mahsulot soni

Onlayn do'konda "Soni" maydoni bor. kiritilgan o'zgaruvchisida foydalanuvchi yozgan satr. togri o'zgaruvchisi faqat quyidagi holda true bo'lsin: son butun, 1 dan kichik emas va 99 dan katta emas. Ekranga ternary bilan Savatga qo'shildi: 3 ta yoki Soni 1 dan 99 gacha bo'lishi kerak chiqaring.

kiritilgan ga "3", " 3 ", "2.5", "0", "150" va "" berib sinab ko'ring.

Ishora: Number(), Number.isInteger, >=, <= va && yetarli. Taqqoslash operatorlari — taqqoslash darsidan.

const kiritilgan = " 3 ";
const soni = Number(kiritilgan);

const togri = Number.isInteger(soni) && soni >= 1 && soni <= 99;

console.log(
  togri
    ? `Savatga qo'shildi: ${soni} ta`
    : "Soni 1 dan 99 gacha bo'lishi kerak",
);
// Savatga qo'shildi: 3 ta

3-mashq (qiyin): Qat'iy summa tekshiruvi

Click'ga o'xshash ilova uchun summa tekshiruvini yozing. kiritilgan satri quyidagicha qayta ishlansin:

1. "so'm" so'zi, oddiy bo'sh joylar va uzilmas bo'sh joylar ("\u00a0") olib tashlanadi.
2. Natija Number() bilan songa aylanadi.
3. togri faqat shunda true: summa butun, 1 000 dan kam emas, 50 000 000 dan ko'p emas va String(summa) tozalangan matnga aynan teng.

"12 000 so'm", "1e4", "500", "12\u00a0000" va "0012000" bilan sinab ko'ring. Qaysilari o'tishi kerak?

Ishora: replace va replaceAll ni ketma-ket yozing — Matnni o'zgartirish. Katta sonlarni 1_000 kabi yozish mumkin — Son yozish shakllari.

const kiritilgan = "12\u00a0000 so'm";

const tozalangan = kiritilgan
  .replace("so'm", "")
  .replaceAll(" ", "")
  .replaceAll("\u00a0", "");
const summa = Number(tozalangan);

const togri =
  Number.isInteger(summa) &&
  summa >= 1_000 &&
  summa <= 50_000_000 &&
  String(summa) === tozalangan;

console.log(tozalangan); // 12000
console.log(togri); // true

10. Real ishda

• Formalar: har bir sonli maydon — aylantirish va tekshirish. Forma qiymatlarini o'qish darsida buni brauzerda qilasiz.
• Server: so'rov bilan kelgan ?page=2 yoki amount — satr. Backend'da ham xuddi shu Number + Number.isInteger juftligi ishlatiladi.
• Validatsiya kutubxonalari: Zod (ma'lumot tekshirish kutubxonasi, kursda alohida dars bor) ichida xuddi shu tekshiruvlar yotadi: z.number().int().positive(). Kutubxonani tushunish uchun bu darsdagi asos kerak.
• Intervyu: "isNaN va Number.isNaN farqi?", "parseInt ga nega radix beriladi?", "parseInt(0.0000005) nega 5?" — tez-tez beriladigan savollar.

Xulosa

• Number() va unar + — qat'iy: satr to'liq son bo'lishi kerak. Lekin "1e3", "0x10", "Infinity" ni ham son deb qabul qiladi.
• parseInt(s, 10) va parseFloat(s) — satr boshidagi sonni oladi. parseInt ga radix'ni doim yozing va unga son bermang.
• Global isNaN / isFinite o'rniga Number.isNaN, Number.isFinite, Number.isInteger ishlating — ular aylantirmaydi.
• Karta, telefon, ID — satr bo'lib qoladi: son bo'lsa, +, nollar va raqamlar yo'qolishi mumkin.
• toFixed va toPrecision satr qaytaradi va faqat ko'rsatish uchun.
• Forma kiritishi: tozalash → Number → tekshirish (butunmi, chegaradami) → serverda yana tekshirish.

Keyingi dars: Math obyekti — sonlarni yaxlitlash, chegaralash va tasodifiy son olish uchun tayyor asboblar to'plami.