Onlayn mağazada səbətə 0,70 manatlıq çörək və 0,10 manatlıq paket qoyursan, sayt isə yazır: «Cəmi: 0.7999999999999999 AZN». Proqramçı səhv edib, yoxsa JavaScript hesablaya bilmir? Əslində kompüter ədədləri ikilik sistemdə saxlayır və bu, bəzən gözlənilməz nəticələr verir. «Operatorlar və tip çevrilməsi» dərsində 0.1 + 0.2 haqqında qısa eşitmişdin; bu dərsdə ədədlərin necə saxlandığını, böyük tam ədədləri, sətri ədədə düzgün çevirməyi, yuvarlaqlaşdırmanın tələlərini, Math obyektini və təsadüfi ədədləri ətraflı öyrənəcəksən.
Bütün ədədlər üçün bir tip
number tipiTərif
JavaScript-də tam və kəsr ədədlərin hamısı eyni number tipindədir: 64 bitlik sürüşkən vergüllü ədəd (IEEE 754 standartı). 5, 5.0, -2.5 və 1e6 eyni tipdir.
Ona görə 7 / 2 digər dillərdəki kimi 3 yox, 3,5 verir. Sıfıra bölmək xəta yaratmır: nəticə Infinity (sonsuzluq) olur, 0 / 0 isə NaN («ədəd deyil») verir — bu da number tipidir. Böyük ədədləri oxumaq üçün alt xətt yazmaq olar (1_000_000), 0x on altılıq, 0b ikilik, e isə «10-un qüvvəti» deməkdir: 2e3 = 2000.
console.log(typeof 5, typeof 2.5, typeof NaN);
console.log(5 === 5.0, 7 / 2);
console.log(1 / 0, -1 / 0, 0 / 0);
console.log(1_000_000, 0xff, 0b1010, 2e3, 1.5e-3);Gözlənilən nəticə
number number number true 3.5 Infinity -Infinity NaN 1000000 255 10 2000 0.0015
Davamını oxumaq üçün pulsuz qeydiyyatdan keç
Dərsin qalan bölmələri, test və qeydlər Educora hesabı ilə açılır. Qeydiyyat bir dəqiqə çəkir; irəliləyişin bütün cihazlarında saxlanılır.
Sürüşkən vergül: 0,1 + 0,2 niyə 0,3 deyil
Onluq sistemdə 1/3-i dəqiq yazmaq olmur: 0,333… sonsuza qədər davam edir və harasa kəsmək lazımdır. İkilik sistemdə eyni problem 0,1 ilə yaranır: o, sonsuz ikilik kəsrdir və yaddaşa ən yaxın qiymət yazılır — 0.1000000000000000055…. Adətən bu kiçik xəta çapda görünmür, amma bir neçə belə ədədi toplayanda və ya vuranda üzə çıxır.
console.log(0.7 + 0.1);
console.log(0.1 + 0.2 === 0.3);
console.log((0.1).toFixed(20));
console.log(1.6 * 3);
console.log(Math.floor(4.35 * 100), 4.35 * 100);Gözlənilən nəticə
0.7999999999999999 false 0.10000000000000000555 4.800000000000001 434 434.99999999999994
Son sətir xüsusilə təhlükəlidir: 4,35 manatı qəpiyə çevirəndə Math.floor 434 verdi — bir qəpik itdi. Kəsr ədədləri === ilə müqayisə etmə; onların fərqinin çox kiçik olduğunu yoxla. Number.EPSILON 1 ilə ondan sonrakı ən yaxın number arasındakı məsafədir (təxminən 2,2 · 10⁻¹⁶).
Burada
- a, b
- müqayisə olunan kəsr ədədlər
- ε
- icazə verilən xəta: 1-ə yaxın ədədlər üçün
Number.EPSILON, böyük ədədlər üçünNumber.EPSILON · max(|a|, |b|)və ya məsələyə uyğun kiçik ədəd (pul üçün 0,005)
İki kəsr ədəd o vaxt «bərabər» sayılır ki, fərqinin modulu ε-dan kiçik olsun.
function nearlyEqual(a, b) {
return Math.abs(a - b) < Number.EPSILON;
}
console.log(Number.EPSILON);
console.log(nearlyEqual(0.1 + 0.2, 0.3));
console.log(nearlyEqual(0.1 + 0.2, 0.31));
console.log(1000.1 + 1000.2);
console.log(Math.abs(1000.1 + 1000.2 - 2000.3) < Number.EPSILON);
console.log(Math.abs(1000.1 + 1000.2 - 2000.3) < Number.EPSILON * 2000.3);Gözlənilən nəticə
2.220446049250313e-16 true false 2000.3000000000002 false true
Böyük ədədlərdə qonşu number qiymətləri arasındakı məsafə də böyüyür, ona görə sabit Number.EPSILON 2000 ətrafında artıq çox kiçikdir — tolerantlığı ədədin ölçüsünə vurmaq lazımdır. Pul üçün isə ən etibarlı yol ümumiyyətlə kəsrsiz işləməkdir.
Tam ədədlərin sərhədi və BigInt
number tam ədədləri yalnız müəyyən həddə qədər dəqiq saxlayır. Bu hədd Number.MAX_SAFE_INTEGER-dir. Ondan böyük tam ədədlər arasında «boşluqlar» yaranır: 2 ** 53 + 1 yaddaşda yazıla bilmir və 2 ** 53-ə yuvarlaqlaşır. Number.isSafeInteger(n) ədədin hələ etibarlı zonada olub-olmadığını yoxlayır. Ən böyük number təxminən 1,8 · 10³⁰⁸-dir, ondan yuxarısı Infinity olur.
Burada
- 2⁵³
numberdaxilində tam hissə üçün 53 ikilik rəqəm (bit) var
Bu həddən böyük id-lər, sayğaclar və hesablamalar üçün BigInt lazımdır.
console.log(Number.MAX_SAFE_INTEGER);
console.log(2 ** 53 === 2 ** 53 + 1);
console.log(9007199254740993);
console.log(Number.isSafeInteger(2 ** 53 - 1), Number.isSafeInteger(2 ** 53));
console.log(Number.MAX_VALUE, Number.MAX_VALUE * 2);Gözlənilən nəticə
9007199254740991 true 9007199254740992 true false 1.7976931348623157e+308 Infinity
BigIntTərif
İstənilən ölçüdə tam ədədlər üçün ayrıca tip. Ədədin sonuna n yazılır (10n) və ya BigInt('123') çağırılır; typeof 'bigint' qaytarır.
BigInt ilə + - * ** % adi qaydada işləyir, bölmə isə kəsri atır (7n / 2n = 3n). BigInt və number bir ifadədə qarışdırılmır — 10n + 1 TypeError verir, birini o birinə açıq çevirmək lazımdır. Müqayisə isə işləyir (5n > 3). BigInt kəsr saxlamır, Math metodları onunla işləmir və JSON.stringify onu tanımır; ona görə ondan yalnız həqiqətən böyük tam ədədlər üçün istifadə et: verilənlər bazasının 64 bitlik id-ləri, faktoriallar, kriptoqrafiya.
const big = 2n ** 64n;
console.log(big, typeof big);
console.log(9007199254740993n + 1n);
console.log(7n / 2n, 7n % 2n);
let f = 1n;
for (let i = 1n; i <= 25n; i++) f *= i;
console.log(f);
try {
console.log(10n + 1);
} catch (error) {
console.log(error.name);
}
console.log(10n + BigInt(1), Number(10n) + 1, 5n > 3);Gözlənilən nəticə
18446744073709551616n bigint 9007199254740994n 3n 1n 15511210043330985984000000n TypeError 11n 11 true
Sətirdən ədədə: Number, parseInt, parseFloat
Formadan, URL-dən və fayldan gələn hər şey sətirdir. Onu ədədə çevirməyin üç yolu fərqli işləyir. Number(text) (və ya unar +text) bütün sətrin ədəd olmasını tələb edir, kənardakı boşluqları bağışlayır və boş sətri 0 edir. parseInt(text, radix) sətrin əvvəlindən rəqəmləri oxuyur və ilk «yad» simvolda dayanır. parseFloat(text) eyni işi kəsr ədəd üçün görür. Vergül JavaScript üçün onluq ayırıcı deyil, ona görə az, ru və tr istifadəçilərinin yazdığı '2,5' əvvəlcə replace(',', '.') ilə düzəldilməlidir.
| Giriş | Number() | parseInt() | parseFloat() |
|---|---|---|---|
'42' | 42 | 42 | 42 |
'42px' | NaN | 42 | 42 |
'3.99' | 3.99 | 3 | 3.99 |
'2,5' | NaN | 2 | 2 |
'' | 0 | NaN | NaN |
' 12 ' | 12 | 12 | 12 |
console.log(Number('42'), Number('42px'), Number(''), Number(' 12 '));
console.log(parseInt('42px'), parseInt('px42'), parseInt('3.99'));
console.log(parseFloat('3.14abc'), parseFloat('.5'), parseFloat('2,5'));
console.log(Number('2,5'), Number('2,5'.replace(',', '.')));
console.log(parseInt('ff', 16), parseInt('101', 2));
console.log(+'7' + 1, Number(null), Number(undefined), Number(true));Gözlənilən nəticə
42 NaN 0 12 42 NaN 3 3.14 0.5 2 NaN 2.5 255 5 8 0 NaN 1
Çevirmə alınmayanda nəticə NaN olur və o, qəribə davranır: NaN heç nəyə, hətta özünə də bərabər deyil, ona görə x === NaN həmişə false-dur. Yoxlamaq üçün Number.isNaN(x) işlət. Köhnə qlobal isNaN(x) əvvəlcə arqumenti ədədə çevirir, ona görə isNaN('salam') true verir, halbuki bu, sətirdir. Eyni ailədən Number.isInteger (tam ədəddirmi) və Number.isFinite (sonlu ədəddirmi) da tip çevirmir.
const value = Number('hello');
console.log(value, value === NaN, Number.isNaN(value));
console.log(isNaN('hello'), Number.isNaN('hello'));
console.log(Number.isInteger(5), Number.isInteger(5.5), Number.isInteger('5'));
console.log(Number.isFinite(1 / 0), Number.isFinite(42), isFinite('42'));Gözlənilən nəticə
NaN false true true false true false false false true true
Yuvarlaqlaşdırma: Math.round, toFixed və tələlər
Dörd funksiya kəsri tam ədədə çevirir. Math.round ən yaxın tam ədədi verir, yarımı isə yuxarı (+∞ tərəfə) yuvarlaqlaşdırır, ona görə Math.round(-2.5) −3 yox, −2-dir. Math.floor aşağı, Math.ceil yuxarı yuvarlaqlaşdırır, Math.trunc isə sadəcə kəsr hissəni atır. Mənfi ədədlərdə floor ilə trunc-un fərqi görünür:
console.log('x', 'round', 'floor', 'ceil', 'trunc');
for (const x of [2.5, 2.7, -2.5, -2.7]) {
console.log(x, Math.round(x), Math.floor(x), Math.ceil(x), Math.trunc(x));
}Gözlənilən nəticə
x round floor ceil trunc 2.5 3 2 3 2 2.7 3 2 3 2 -2.5 -2 -3 -2 -2 -2.7 -3 -3 -2 -2
Vergüldən sonra n rəqəmə qədər yuvarlaqlaşdırmanın klassik yolu ədədi 10ⁿ-ə vurmaq, yuvarlaqlaşdırmaq və geri bölməkdir. toFixed(n) isə nəticəni sətir kimi qaytarır — göstərmək üçün əladır, hesablamaq üçün yox.
Burada
- x
- yuvarlaqlaşdırılan ədəd
- n
- vergüldən sonra saxlanılan rəqəmlər
Diqqət: x · 10ⁿ özü də ikilik xəta ilə hesablanır — aşağıdakı nümunəyə bax.
console.log((3.14159).toFixed(2), typeof (3.14159).toFixed(2));
console.log(Math.round(3.14159 * 100) / 100, (5).toFixed(2));
console.log((1.005).toFixed(2));
console.log((1.005).toFixed(20));
console.log(Math.round(1.005 * 100) / 100, 1.005 * 100);
function roundTo(x, digits) {
return Number(Math.round(x + 'e' + digits) + 'e-' + digits);
}
console.log(roundTo(1.005, 2), roundTo(2.675, 2), roundTo(3.14159, 3));
const format = new Intl.NumberFormat('en-US', { maximumFractionDigits: 2 });
console.log(format.format(1.005), format.format(1234.5678));Gözlənilən nəticə
3.14 string 3.14 5.00 1.00 1.00499999999999989342 1 100.49999999999999 1.01 2.68 3.142 1.01 1,234.57
1.005 yaddaşda əslində 1.00499…-dur, ona görə həm toFixed(2), həm də düstur 1.00 verdi. roundTo funksiyası ədədi '1.005e2' kimi sətrə çevirir: Number bu yazını onluq kimi oxuyur və dəqiq 100,5 alır. Intl.NumberFormat da gördüyün onluq yazını yuvarlaqlaşdırır və minlikləri ayırır; onun bütün imkanlarını «Tarix və vaxt: Date və Intl» dərsində görəcəksən.
Math obyekti və təsadüfi ədədlər
Math hazır riyazi funksiyalar toplusudur: Math.max/Math.min (massiv üçün spread ilə: Math.max(...arr); boş massivdə -Infinity verir), Math.abs (modul), Math.sign (işarə), Math.sqrt və Math.cbrt (kvadrat və kub kök), Math.pow (eyni işi ** görür), Math.hypot (hipotenuz), Math.PI. Triqonometrik funksiyalar dərəcə yox, radian qəbul edir: 90° = π/2.
const scores = [72, 95, 88, 61];
console.log(Math.max(...scores), Math.min(...scores), Math.max());
console.log(Math.abs(-7), Math.sign(-7), Math.sqrt(144), Math.cbrt(27));
console.log(Math.pow(2, 10), 2 ** 10, Math.hypot(3, 4));
console.log(Math.PI.toFixed(5), Math.sin(Math.PI / 2), Math.sin(Math.PI));Gözlənilən nəticə
95 61 -Infinity 7 -1 12 3 1024 1024 5 3.14159 1 1.2246467991473532e-16
Math.sin(Math.PI) 0 yox, çox kiçik ədəd verdi — bu da sürüşkən vergülün izidir, çünki Math.PI π-nin özü deyil, ona ən yaxın number-dir. Math.random() [0; 1) aralığından təsadüfi kəsr qaytarır: 0 düşə bilər, 1 heç vaxt. Ondan [min; max] aralığında tam ədəd almaq üçün:
Burada
- max − min + 1
- mümkün nəticələrin sayı (zər üçün 6)
- Math.floor
- [0; 6) aralığını 0, 1, …, 5 tam ədədlərinə bərabər paylarla bölür
- + min
- nəticəni min-dən başlayan aralığa sürüşdürür
Math.round(Math.random() * 6) yanlışdır: 0–6 arası 7 nəticə verir, kənardakılar isə iki dəfə nadir düşür.
function randomInt(min, max) {
return Math.floor(Math.random() * (max - min + 1)) + min;
}
const rolls = Array.from({ length: 6000 }, () => randomInt(1, 6));
console.log(Math.min(...rolls), Math.max(...rolls));
console.log(rolls.every((r) => Number.isInteger(r) && r >= 1 && r <= 6));
console.log(new Set(rolls).size);
const wrong = Array.from({ length: 6000 }, () => Math.round(Math.random() * 6));
console.log(wrong.includes(0), Math.max(...wrong));Gözlənilən nəticə
1 6 true 6 true 6
Mini layihə: mağaza çeki. Qiymətlər istifadəçilərdən sətir kimi gəlir (bəzən vergüllə), hesablama qəpiklə aparılır, 5 % endirim yuvarlaqlaşdırılır, sonda məbləğ üç dildə göstərilir.
const cart = [
{ name: 'Bread', price: '0.70', qty: 2 },
{ name: 'Milk', price: '1,60', qty: 3 },
{ name: 'Tea', price: '4.35', qty: 1 },
];
const toQepik = (text) => Math.round(Number(text.replace(',', '.')) * 100);
let total = 0;
for (const item of cart) {
const line = toQepik(item.price) * item.qty;
total += line;
console.log(item.name.padEnd(5), item.qty, 'x', item.price, '=', (line / 100).toFixed(2));
}
const discount = Math.round(total * 0.05);
const pay = total - discount;
console.log('Total:', (total / 100).toFixed(2), '| discount 5%:', (discount / 100).toFixed(2));
console.log(['en-US', 'ru-RU', 'tr-TR'].map((loc) =>
new Intl.NumberFormat(loc, { style: 'currency', currency: 'AZN' }).format(pay / 100)).join(' | '));Gözlənilən nəticə
Bread 2 x 0.70 = 1.40 Milk 3 x 1,60 = 4.80 Tea 1 x 4.35 = 4.35 Total: 10.55 | discount 5%: 0.53 AZN 10.02 | 10,02 AZN | AZN 10,02
Tapşırıq
sumPrices(texts) istifadəçilərin yazdığı qiymətləri toplasın: vergül və nöqtə qəbul olunur, kənar boşluqlar atılır, boş və ya ədəd olmayan sətirlər buraxılır. Funksiya iki sətir çap etsin: manatla cəmi (toFixed(2)) və buraxılmış sətirlərin sayı. Hesablamanı qəpiklə apar.
function sumPrices(texts) {
let qepik = 0;
let invalid = 0;
// clean each text, convert it, skip the bad ones
console.log((qepik / 100).toFixed(2));
console.log(invalid);
}
sumPrices(['2,50', '19.99', ' 7 ', 'abc', '', '0.1', '0.2']);Gözlənilən nəticə
29.79 2
Tapşırıq
splitBill(totalText, people) hesabı dostlar arasında qəpiyinə qədər bölsün: hissələr cəmi tam versin, artıq qalan qəpiklər birincilərə bir-bir verilsin. Hissələri toFixed(2) ilə, boşluqla ayrılmış sətir kimi qaytar.
function splitBill(totalText, people) {
// 1) total in qepik 2) base part and the remainder 3) build the string
}
console.log(splitBill('10.00', 3));
console.log(splitBill('25,5', 4));
console.log(splitBill('7', 2));Gözlənilən nəticə
3.34 3.33 3.33 6.38 6.38 6.37 6.37 3.50 3.50
Yadda saxla
- Bütün ədədlər 64 bitlik sürüşkən vergüllü
number-dir; 0,1 kimi kəsrlər dəqiq saxlanmır. - Kəsrləri |a − b| < ε ilə müqayisə et, pulu qəpiklə tam ədəd kimi say və
Math.round(x * 100)ilə çevir. - Tam ədədlər 2⁵³ − 1-ə qədər dəqiqdir; daha böyükləri üçün BigInt (
10n), onunumberilə qarışdırmaq olmaz. Numberbütün sətri,parseInt/parseFloatbaşlanğıcı oxuyur;NaN-ıNumber.isNaNilə yoxla.toFixedsətir qaytarır və1.005kimi ədədlərdə aşağı yuvarlaqlaşdıra bilər; göstərmək üçünIntl.NumberFormatdə var.- [min; max] aralığında təsadüfi tam ədəd:
Math.floor(Math.random() * (max − min + 1)) + min; parollar üçüncrypto.