Ədədlər və Math obyekti

Bir `number` tipi və sürüşkən vergül (0,1 + 0,2), Number.EPSILON, təhlükəsiz tam ədədlər və BigInt, Number/parseInt/parseFloat, NaN, yuvarlaqlaşdırma tələləri, Math metodları və aralıqda təsadüfi tam ədəd.

  • Başlanğıc
  • 22 dəq
  • 12 sual
  • 39 dərsdən 4-cüsü

Bu dərsdə öyrənəcəksən

  • 0.1 + 0.2-nin niyə 0,3 olmadığını izah etmək və kəsrləri, pulu düzgün müqayisə edib hesablamaq
  • Təhlükəsiz tam ədəd həddini tanımaq və lazım olanda BigInt işlətmək
  • Sətri Number, parseInt, parseFloat ilə çevirmək və NaN-ı düzgün yoxlamaq
  • Ədədləri yuvarlaqlaşdırmaq, Math metodlarından istifadə etmək və aralıqda təsadüfi tam ədəd almaq

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.

JavaScript
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.

JavaScript
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⁻¹⁶).

|a − b| < ε

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 üçün Number.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.

JavaScript
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.

MAX_SAFE_INTEGER = 2⁵³ − 1 = 9007199254740991

Burada

2⁵³
number daxilində 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.

JavaScript
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.

JavaScript
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'424242
'42px'NaN4242
'3.99'3.9933.99
'2,5'NaN22
''0NaNNaN
' 12 '121212
JavaScript
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.

JavaScript
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:

JavaScript
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.

round(x, n) = Math.round(x · 10ⁿ) / 10ⁿround(x, n) = Math.round(x · 10ⁿ) / 10ⁿ

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.

JavaScript
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.

JavaScript
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:

randomInt = Math.floor(Math.random() · (max − min + 1)) + min

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.

JavaScript
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
Zərlər hər dəfə fərqli düşür, amma 6000 atışda bu yoxlamaların nəticəsi praktiki olaraq həmişə eynidir.

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.

JavaScript
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.

Tapşırıq · JavaScript
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.

Tapşırıq · JavaScript
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), onu number ilə qarışdırmaq olmaz.
  • Number bütün sətri, parseInt/parseFloat başlanğıcı oxuyur; NaN-ı Number.isNaN ilə yoxla.
  • toFixed sətir qaytarır və 1.005 kimi ədədlərdə aşağı yuvarlaqlaşdıra bilər; göstərmək üçün Intl.NumberFormat də var.
  • [min; max] aralığında təsadüfi tam ədəd: Math.floor(Math.random() * (max − min + 1)) + min; parollar üçün crypto.
Dərsdə səhv və ya qeyri-dəqiqlik gördün?

Özünü yoxla

12 sual. Hər düzgün cavab XP qazandırır.

Sual 1 / 12

Sual 1 / 12. console.log(0.1 + 0.2 === 0.3) nə çap edir?