اعداد

در جاوااسکریپت، دو نوع عدد وجود دارد:

1. اعداد معمولی در جاوااسکریپت با فرمت 64 بیتی IEEE-754 ذخیره می‌شوند، همچنین با “اعداد اعشاری با دقت یک صدم” هم شناخته می‌شوند. ما اکثر اوقات از این اعداد استفاده می‌کنیم، و درباره آنها در این فصل صحبت خواهیم کرد.

2. اعداد BigIntØŒ برای نمایش اعدادی با طول دلخواه استفاده می‌شوند. آنها بعضی اوقات مورد نیاز هستند، چون اعداد معمولی نمی‌توانند از 253 بیشتر یا از -253 کمتر باشند. چون bigintها در چند حوزه خاص استفاده می‌شوند، ما به آنها یک فصل خاص BigInt اختصاص می‌دهیم.

پس اینجا درباره اعداد معمولی صحبت می‌کنیم. بیایید دانش‌مان درباره آنها را گسترش دهیم.

راه‌های دیگر نوشتن یک عدد

فرض کنید نیاز داریم بنویسیم یک میلیارد. راه واضح این است:

let billion = 1000000000;

همچنین ما می‌توانیم از خط تیره _ به عنوان جداکننده استفاده کنیم:

let billion = 1_000_000_000;

اینجا خط تیره _ نقش “syntactic sugar” را بازی می‌کند، Ùˆ عدد را خواناتر می‌کند. موتور جاوااسکریپت به راحتی _ بین ارقام را نادیده می‌گیرد، پس دقیقا عددی مانند یک میلیارد بالا است.

اما در زندگی واقعی ما عموما از نوشتن رشته حرف با تعداد زیاد صفر خودداری میکنیم به خاطر اینکه به راحتی ممکن است خطا داشته باشیم و اشتباه بنویسیم. همینطور، ما تنبل هستیم! ما معمولا یه چیزی شبیه “1bn” مینویسیم به جای یک میلیارد یا “7.3bn” برای هفت میلیارد و سیصد میلیون. این حقیقت برای اکثر اعداد بزرگ هم صحیح است.

در جاوااسکریپت، ما یک عدد را براساس اضافه کردن حرف "e" به انتهای آن خلاصه می‌کنیم Ùˆ با آن تعداد صفرها مشخص می‌شود.

let billion = 1e9;  // 1 billion, literally: 1 and 9 zeroes

alert( 7.3e9 );  // 7.3 billions (same as 7300000000 or 7_300_000_000)

به زبانی دیگر، "e" عدد را در 1 با تعداد صفر داده شده ضرب می‌کند.

1e3 === 1 * 1000; // e3 یعنی *1000
1.23e6 === 1.23 * 1000000; // e6 یعنی *1000000

حالا بگذارید مقداری خیلی کوچک بنویسیم. مثلا؛ یک میکروثانیه، (یک میلیونیوم ثانیه):

let mсs = 0.000001;

دقیقا مثل قبل، استفاده از "e" می‌تواند Ú©Ù…Ú© کند. اگر ما بخواهیم Ú©Ù‡ از نوشتن صفرها خودداری کنیم، می‌توانیم بنویسیم:

let mcs = 1e-6; // پنج صفر در سمت چپ ۱

اگر ما تعداد صفرهای 0.000001 را بشماریم، شش تا از آنها موجودست. بنابراین طبعا می‌شود 1e-6.

به زبانی دیگر، یک عدد منفی بعد "e"ØŒ به معنی تقسیم بر یک با تعداد صفرهای داده شده است.

// -3 divides by 1 with 3 zeroes
1e-3 === 1 / 1000; // 0.001

// -6 divides by 1 with 6 zeroes
1.23e-6 === 1.23 / 1000000; // 0.00000123

// مثالی با یک عدد بزرگتر
1234e-2 === 1234 / 100; // ممیز دو بار حرکت می‌کند، 12.34

اعداد پایه ۱۶، دودویی، پایه ۸

اعداد پایه Û±Û¶ برای نمایش رنگ‌ها، کدگذاری حروف Ùˆ بسیاری دیگر، به طور وسیعی در جاوااسکریپت مورد استفاده قرار می‌گیرند. بنابراین، یک راه کوتاهتری برای نوشت آنها وجود دارد: 0x Ùˆ سپس عدد.

به عنوان مثال:

alert( 0xff ); // 255
alert( 0xFF ); // 255 (the same, case doesn't matter)

اعداد هشت‌تایی Ùˆ دودویی به ندرت مورد استفاده قرار میگیرند اما نحوه‌ی استفاده‌ی آنها به صورت پیشوند‌های 0b Ùˆ 0o است:

let a = 0b11111111; // binary form of 255
let b = 0o377; // octal form of 255

alert( a == b ); // true, the same number 255 at both sides

سه نوع سیستم عددی با پشتیبانی مخصوص به خود وجود دارد. برای بقیه‌ی سیستم‌ها ما باید از تابع parseInt استفاده کنیم. (Ú©Ù‡ ما در بخش‌های بعدی خواهیم دید.)

toString(base)

تابع num.toString(base)ØŒ یک رشته حرف نمایشگر num را در سیستم عددی با پایه داده شده خروجی می‌دهد.

به عنوان مثال:

let num = 255;

alert( num.toString(16) );  // ff
alert( num.toString(2) );   // 11111111

پایه میتواند از بین Û² تا Û³Û¶ تغییر کند. در حالت عادی، Û±Û° است.

حالات معمول استفاده بدین شکلند:

• base=16 برای رنگ‌های هگزایی، کدگذاری حروف Ùˆ غیره، ارقام میتوانند به صورت 0..9 یا A..F باشند.

• base=2 برای دیباگ کردن عملوند‌های بیتی هستند، ارقام میتوانند 0 یا 1 باشند.

• base=36 بزرگترین است، ارقام میتوانند 0..9 یا A..Z باشند. Ú©Ù„ الفبای لاتین برای نمایش یک عدد مورد استفاده قرار میگیرد. یک حالت خنده دار، اما مفید برای Û³Û¶ وقتی است Ú©Ù‡ ما نیاز داریم تا یک نشانگر بزرگ عددی را به چیز کوچکتری تبدیل کنیم، به عنوان مثال برای . ساختن لینک‌ های کوتاه شده (short url). میتوان به سادگی اعداد را در پایه‌ی Û³Û¶ نمایش داد:

  alert( 123456..toString(36) ); // 2n9c

رند کردن

یکی از عملگرهایی در اعداد زیاد مورد استفاده قرار میگیرد، رند کردن است.

چندین تابع از پیش آماده شده برای رند کردن به شرح زیر است:

Math.floor

رند پایین: Û³.Û± میشود Û³, Ùˆ -Û±.Û± میشود -Û².

Math.ceil

رند بالا: Û³.Û± میشود Û´, Ùˆ -Û±.Û± میشود -Û±.

Math.round

رند کردن به نزدیک ترین عدد صحیح: Û³.Û± میشود Û³, Û³.Û¶ میشود Û´ Ùˆ -Û±.Û± میشود -Û±.

Math.trunc (توسط اینترنت اکسپلورر ساپورت نمیشود)

حذف کردن قسمت اعشاری بدون رند کردن: Û³.Û± میشود Û³, -Û±.Û± میشود -Û±.

این جدول تفاوت بین ‌آنهارا خلاصه کرده است:

این توابع تمام حالات کار با قسمت اعشاری یک عدد را پوشش میدهند. اما چطور میتوانیم عدد را تا رقم n-ام بعد از اعشار رند کنیم؟

برای مثلا، داریم Û±.Û²Û³Û´Ûµ Ùˆ میخواهیم تا Û² رقم اعشار آن را رند کنیم یعنی Û±.Û²Û³

دو روش برای اینکار داریم:

۱. ضرب و تقسیم

برای مثال، برای گرد کردن عدد تا دومین رقم اعشاری، می‌توانیم عدد را در`۱۰۰` ضرب کنیم، تابع رند کردن را صدا بزنیم و سپس دوباره تقسیم کنیم.
```js run
let num = 1.23456;

alert( Math.round(num * 100) / 100 ); // 1.23456 -> 123.456 -> 123 -> 1.23
```

Û². تابع toFixed(n) عدد را تا رقم n-ام بعد اعشار رند میکند Ùˆ سپس آن را به صورت رشته حرفی حرفی خروجی میدهد.

```js run
let num = 12.34;
alert( num.toFixed(1) ); // "12.3"
```

این عدد را به نزدیک ترین مقدار رند میکند مشابه `Math.round`:

```js run
let num = 12.36;
alert( num.toFixed(1) ); // "12.4"
```

توجه داشته باشید که مقدار `toFixed` یک رشته است. اگر قسمت بعد اعشار کوچک‌تر از آنجه نیاز است باشد، صفر به آخر آن اضافه خواهد شد:

```js run
let num = 12.34;
alert( num.toFixed(5) ); // "12.34000", صفر اضافه شده تا دقیقا ۵ رقم شود 
```

ما می‌توانیم آن را با کمک عملگر جمع یگانه یا با فراخوانی `Number()` تبدیل کنیم؛ برای مثال بنویسیم  `+num.toFixed(5)`.

محاسبات تقریبی

در درون سیستم، یک عدد به شکل ۶۴-بیتی است IEEE-754، بنابراین دقیقا ۶۴ بیت برای ذخیره‌ی یک عدد داریم: ۵۲ تا از آنها برای ذخیره کردن ارقام هستند، ۱۱ تا از آنها برای ذخیره کردن جایگاه نقطه‌ی مشخص کننده‌ی اعشار (که برای اعداد صحیح صفر است)، و یک بیت برای علامت آن.

اگر عددی بیش از حد بزرگ باشد، حافظه‌ی ۶۴ بیتی سرریز می‌شود و به مقدار بی‌نهایت تبدیل می‌شود:

alert( 1e500 ); // Infinity

اتفاقی که زیاد مشخص نیست و کمتر اتفاق می‌افتد، از دست دادن دقت است.

این آزمون (اشتباه!)برابری را در نظر بگیرید:

alert( 0.1 + 0.2 == 0.3 ); // false

این درست است، اگر ما بررسی کنیم Ú©Ù‡ جمع 0.1 Ùˆ 0.2ØŒ 0.3 است، ما مقدار false را در جواب میگیریم.

عجیب است! Ú†ÛŒ هست پس اگر 0.3 نیست؟!

alert( 0.1 + 0.2 ); // 0.30000000000000004

اوه! فرض کنید شما در حال ساخت فروشگاهی اینترنتی هستید Ùˆ بازدیدکننده کالاهایی به مبلغ $0.10 Ùˆ $0.20 را به سبد خرید خود اضافه می‌کند. مجموع هزینه سفارش $0.30000000000000004 خواهد بود. این هر شخصی را Ø´Ú©Ù‡ می‌کند!

اما چرا این اتفاق می‌افتد؟

یک عدد در حافظه به Ø´Ú©Ù„ دودویی آن ذخیره میشود، مجموعه‌ای از صفرها Ùˆ یک‌ها. اما کسرهایی مثل 0.1ØŒ 0.2 Ú©Ù‡ در سیستم اعداد اعشاری ساده به نظر میرسند در اصل کسرهای بی‌پایانی در Ø´Ú©Ù„ دودویی خود هستند.

مقدار 0.1 چیست؟ مقدار یک Ú©Ù‡ بر ده تقسیم شده، 1/10 یعنی یک دهم. در سیستم اعداد اعشاری چنین اعدادی به سادگی قابل نمایش هستند. آن را با یک سوم 1/3 مقایسه کنید. به کسری بی‌پایان تبدیل می‌شود 0.33333(3).

بنابراین، تقسیم های از توان ده، قطعا در سیستم اعشاری کار میکند اما تقسیم‌های بر ۳ اینطور نیست. به علت مشابه، در سیستم اعداد دودویی، تقسیم توان‌های ۲ هم قطعا کار میکند اما ۱/۱۰، کسر دودویی بی‌پایانی میشود.

در حقیقت هیچ راهی برای ذخیره کردن دقیقا ۰.۱ یا دقیقا ۰.۲ در سیستم دودویی وجود ندارد، دقیقا مثل اینکه برای ذخیره سازی مقدار یک سوم به عنوان یک کسر اعشاری راهی وجود ندارد.

فرمت عددی IEEE-754ØŒ این مسأله را با Ú©Ù…Ú© رند کردن به نزدیک‌ترین عدد ممکن حل می‌کند. این قوانین رند کردن عموما نمیگذارند Ú©Ù‡ ما آن مقدار Ú©ÙˆÚ†Ú© دقت Ú¯Ù… شده را متوجه بشویم، بنابراین عدد به Ø´Ú©Ù„ 0.3 خواهد بود. اما آگاه باشید Ú©Ù‡ این از دست دادن دقت هنوز وجود دارد.

میتوانیم این را در عمل هم ببینیم:

alert( 0.1.toFixed(20) ); // 0.10000000000000000555

و هنگامی که ما دو عدد را جمع میکنیم، مقدار از دست دادگی دقت آنها با هم جمع میشود.

به همین علت است Ú©Ù‡ 0.1 + 0.2ØŒ دقیقا 0.3 نمیشود.

آیا ما میتوانیم راهی برای حل این مسأله پیدا کنیم؟ طبعا، قابل اطمینان ترین راه حل این است که نتیجه را با کمک متد toFixed(n) رند کنیم:

let sum = 0.1 + 0.2;
alert( sum.toFixed(2) ); // "0.30"

توجه داشته باشید Ú©Ù‡ toFixed همیشه مقدار رشته حرفی برمیگرداند. این تابع حتما مطمئن میشود Ú©Ù‡ تا دو رقم اعشار را حساب می‌کند. Ú©Ù‡ البته این روش منطقی‌‌ست وقتی مثلا در یک فروشگاه اینترنتی ما نیاز داریم مقدار $0.30 را نمایش دهیم. برای حالات دیگر، میتوانیم از جمع واحد استفاده کنیم تا آنرا به یک عدد تبدیل کنیم:

let sum = 0.1 + 0.2;
alert( +sum.toFixed(2) ); // 0.3

همچنین ما می‌توانیم به طور موقت اعداد را در 100 ضرب کنیم (یا یک عدد بزرگتر) تا آنها را به عدد صحیح تبدیل کنیم، عملیات ریاضی را انجام دهیم، سپس آنها را دوباره تقسیم کنیم. سپس، همانطور که عملیات ریاضی را با اعداد صحیح انجام می‌دهیم، ارور مقداری کم می‌شود، اما هنوز زمان تقسیم آن را دریافت می‌کنیم:

alert( (0.1 * 10 + 0.2 * 10) / 10 ); // 0.3
alert( (0.28 * 100 + 0.14 * 100) / 100); // 0.4200000000000001

پس روش ضرب/تقسیم ارور را کاهش می‌دهد، اما آن را به طور کامل ازبین نمی‌برد.

گاهی اوقات می‌توانیم به طور کلی از کسرها فرار کنیم. برای مثال اگر ما با یک فروشگاه سر و کار داریم، می‌توانیم قیمت‌ها را به جای دلار به صورت سنت (cent) ذخیره کنیم. اما اگر یک تخفیف 30 درصدی را اعمال کنیم چه؟ در عمل، فرار کردن از کسرها به ندرت ممکن است. زمانی که نیاز شد فقط آنها را رند کنید تا “دم‌شان” را ببرید.

// Hello! I'm a self-increasing number!
alert( 9999999999999999 ); // shows 10000000000000000

آزمون‌ها: isFinite و isNaN

آیا این دو مقدار عددی خاص را به یاد دارید؟

• Infinity (Ùˆ -Infinity) یک مقدار عددی خاص هستند بزرگتر (کوچکتر) از هرچیزی.
• NaN یک خطا را نشان می‌دهد.

آنها به مدل number مربوطند اما اعداد معمولی نیستند، پس توابع خاصی برای بررسی آنها وجود دارد.

• isNaN(value) آرگومان‌هایش را به یک عدد تبدیل میکند Ùˆ سپس آن را برای NaN بودن می‌آزماید:

  alert( isNaN(NaN) ); // true
  alert( isNaN("str") ); // true

  اما آیا ما به این تابع نیاز داریم؟ نمیتوانیم صرفا از تساوی === NaN استفاده کنیم؟‌ متاسفانه جواب خیر است. مقدار NaNØŒ مقداری یکتاست Ùˆ با هیچ چیز، حتی خودش برابر نیست.

  alert( NaN === NaN ); // false

• isFinite(value) آرگومان‌هایش را به عدد تبدیل میکند Ùˆ در صورتی Ú©Ù‡ عددی معمولی باشد true خروجی می‌دهد نه NaN/Infinity/-Infinity:

  alert( isFinite("15") ); // true
  alert( isFinite("str") ); // false, because a special value: NaN
  alert( isFinite(Infinity) ); // false, because a special value: Infinity

بعضی اوقات isFinite برای صحت سنجی اینکه یک رشته حرفی، عددی معمولیست به کار برده می‌شود.

let num = +prompt("Enter a number", '');

// صحیح برگردانده میشود مگر اینکه وارد کنید Infinity, -Infinity یا چیزی غیر از عدد
alert( isFinite(num) );

توجه داشته باشید Ú©Ù‡ رشته حرفی‌ای Ú©Ù‡ در آن فقط یک جای خالی باشد یا کلا خالی باشد، به عنوان صفر در همه‌ی توابع عددی از جمله isFinite در نظر گرفته میشود.

parseInt Ùˆ parseFloat

تبدیلات عددی Ú©Ù‡ از یک جمع + یا Number() استفاده میکنند، سخت‌گیر هستند.

alert( +"100px" ); // NaN

تنها استثنا، کاراکتر خالی در شروع یا انتهای رشته حرفی هستند که آنها در تابع در نظر گرفته نمی‌شوند.

اما در دنیای واقعی، ما مقادیر در واحدهای مختلفی داریم، مثل "100px" یا "12pt" در CSS. همینطور در بسیاری از کشورها، نماد پولی آنها بعد از مقدار عددی ظاهر میشود. مثل "19€"ØŒ Ú©Ù‡ میخواهیم آن مقدار را از قسمت حرفی جدا کنیم.

به همین علت است Ú©Ù‡ parseInt Ùˆ parseFloat استفاده می‌شوند.

آنها یک عدد را از رشته‌ی حرف میخوانند تا زمانی Ú©Ù‡ دیگر نتوانند. در صورت بروز خطا، عدد پیدا شده برگردانده می‌شود. تابع parseInt یک عدد صحیح برمیگرداند، در حالیکه parseFloat یک عدد اعشاری برمیگرداند.

alert( parseInt('100px') ); // 100
alert( parseFloat('12.5em') ); // 12.5

alert( parseInt('12.3') ); // 12, تنها قسمت صحیح عدد برگردانده شده
alert( parseFloat('12.3.4') ); // 12.3, نقطه‌ی دومی، فرآیند خوانده شدن را متوقف می‌کند.

حالاتی وجود دارد Ú©Ù‡ parseInt/parseFloat ممکن است مقدار NaN را برگردانند. این برای حالتی‌ست Ú©Ù‡ هیچ رقمی نتواند خوانده شود:

alert( parseInt('a123') ); // NaN, اولین حرف این رشته‌ی حرفی، فرآیند را متوقف می‌کند.

alert( parseInt('0xff', 16) ); // 255
alert( parseInt('ff', 16) ); // 255, بدون 0x هم کار می‌کند

alert( parseInt('2n9c', 36) ); // 123456

توابع ریاضی دیگر

جاوااسکریپت یک شئ از پیش آماده‌ شده Math دارد که شامل کتابخانه‌ای کوچک از توابع ریاضی و ثوابت است.

تعدادی مثال:

Math.random()

یک عدد تصادفی از بین ۰ تا ۱ برمی‌گرداند (که شامل ۱ نمیشود(.

alert( Math.random() ); // 0.1234567894322
alert( Math.random() ); // 0.5435252343232
alert( Math.random() ); // ... (هر عدد تصادفی‌ای)

Math.max(a, b, c...) / Math.min(a, b, c...)

بزرگترین/کوچک‌ترین عدد را از بین تعداد دلخواه آرگومان‌ها بر‌می‌گرداند

alert( Math.max(3, 5, -10, 0, 1) ); // 5
alert( Math.min(1, 2) ); // 1

Math.pow(n, power)

عدد n را به توان داده شده می‌رساند.

alert( Math.pow(2, 10) ); // دو به توان ده = 1024

توابع Ùˆ ثوابت بیشتری در شئ Math وجود دارد، مثل روابط مثلثات Ú©Ù‡ میتوانید در مستندات برای شئ Math پیدا کنید.

خلاصه

برای نوشتن اعدادی که صفر زیاد دارند:

• حرف "e" را با تعداد صفرها به انتهای عدد اضافه کنید. مثل: 123e6 Ú©Ù‡ 123 است با Û¶ صفر 123000000.
• یک عدد منفی بعد "e" باعث تقسیم شدن عدد بر یک با تعداد صفر مشخص شده میشود. مانند 123e-6 به معنی `0.000123 (123 میلیونیوم).

برای سیستم‌های عددی متفاوت:

• میتوان اعداد را مستقیما در فرم پایه۱۶ (0x) نوشت، پایه۸ (0o) Ùˆ دودویی (0b) نوشت.
• parseInt(str, base) یک عدد صحیح را از هر سیستم عددی با پایه‌ی 2 ≤ base ≤ 36 را استخراج می‌کند.
• num.toString(base) یک عدد را به یک رشته‌ی حرفی در سیستم عددی با پایه داده شده تبدیل می‌کند.

برای آزمایش عادی عددها:

• isNaN(value) آرگومان خود را به یک عدد تبدیل می‌کند Ùˆ بررسی می‌کند Ú©Ù‡ NaN است یا خیر.
• Number.isNaN(value) بررسی می‌کند Ú©Ù‡ آرگومان آن به نوع number تعلق دارد یا خیر Ùˆ اگر داشت، بررسی می‌کند Ú©Ù‡ NaN هست یا خیر
• isFinite(value) آرگومان خود را به عدد تبدیل می‌کند Ùˆ اگر یک عدد معمولی باشد true برمی‌گرداند نه اینکه NaN/Infinity/-Infinity باشد.
• Number.isFinite(vlaue) بررسی می‌کند Ú©Ù‡ آیا آرگومان آن به نوع number تعلق دارد یا خیر Ùˆ اگر داشت، بررسی می‌کند Ú©Ù‡ NaN/Infinity/-Infinity نباشد

برای تبدیل مقادیری مثل 12pt Ùˆ 100px به یک عدد:

• parseInt/parseFloat را برای تبدیلات ساده استفاده کنید Ú©Ù‡ یک عدد را از یک رشته‌ی حرفی می‌خواند Ùˆ سپس مقداری Ú©Ù‡ قبل از بروز خطا خوانده‌ست را برمی‌گرداند.

برای کسرها:

• با Ú©Ù…Ú© Math.floorØŒ Math.ceilØŒ Math.truncØŒ Math.round یا num.toFixed(precision) رند کنید.
• به یاد داشته باشید Ú©Ù‡ یک دقت از دست رفته‌ای در حین کار با کسر ها وجود دارد.

توابع ریاضی بیشتر:

• Math شئ را وقتی به آنها نیاز دارید ببینید. کتابخانه‌ی بسیار کوچکیست اما توابع پایه‌ای را پوشش می‌دهد.