Number

Значення Number (число) представляють числа з рухомою комою, як то 37 чи -9.25.

Конструктор Number містить константи й методи для роботи з числами. Значення інших типів можуть бути перетворені на числа за допомогою функції Number().

Опис

Числа найчастіше виражають у літеральних формах, як то 255 або 3.14159. Лексична граматика містить докладнішу довідку.

255; // двісті п'ятдесят п'ять
255.0; // те саме число
255 === 255.0; // true
255 === 0xff; // true (шістнадцятковий запис)
255 === 0b11111111; // true (двійковий запис)
255 === 0.255e3; // true (десятковий експоненційний запис)

Числовий літерал, як то 37, в коді JavaScript є значенням з рухомою комою, а не цілим. Немає загальновживаного окремого типу цілих чисел. (JavaScript тепер має тип BigInt, але він був розроблений не для заміни Number в повсякденному використанні. 37 – це все ж Number, а не BigInt.)

Бувши застосованим як функція, Number(value) перетворює рядок чи інше значення на Number. Якщо значення не може бути перетворено, буде повернено NaN.

Number("123"); // повертає число 123
Number("123") === 123; // true

Number("єдиноріг"); // NaN
Number(undefined); // NaN

Кодування Number

Тип JavaScript Number є значенням 64-бітного двійкового формату подвійної точності (IEEE 754), подібно до double в Java чи C#. Це означає, що він може представляти дробові значення, але є певні обмеження щодо величини та точності значень, котрі він може зберігати. Дуже стисло кажучи, число подвійної точності IEEE 754 використовує 64 біти для представлення 3 частин:

• 1 біт для знаку (додане число чи від'ємне)
• 11 біт для експоненти (від -1022 до 1023)
• 52 біти для мантиси (представляє число між 0 і 1)

Мантиса – частина числа, що представляє фактичне значення (вагомі цифри). Експонента – степінь двійки, на котрий повинна бути помножена мантиса. У вигляді наукового запису:

$$\text{Number} = ({-1})^{\text{знак}} \cdot (1 + \text{мантиса}) \cdot 2^{\text{експонента}}$$

Мантиса зберігається в 52 бітах, що тлумачаться як цифри після 1.… у двійковому дробовому числі. Таким чином, точність мантиси – 2^-52 (отримується за допомогою Number.EPSILON), або приблизно від 15 до 17 знаків після коми; арифметика понад цим рівнем точності підпадає під округлення (англ.).

Найбільше значення, котре може утримувати число – 2¹⁰²³ × (2 - 2^-52) (чия експонента 1023, а мантиса – 0.1111… за основою числення 2), його можна отримати як Number.MAX_VALUE. Більші значення замінюються особливою числовою сталою – Infinity.

Цілі числа можуть бути представлені без втрати точності лише в діапазоні від -2⁵³ + 1 до 2⁵³ - 1 включно (межі доступні як Number.MIN_SAFE_INTEGER і Number.MAX_SAFE_INTEGER), тому що мантиса може утримувати лише 53 біти (включно з 1 на початку).

Більше подробиць про це описані в стандарті ECMAScript.

Зведення до числа

Чимало вбудованих операцій, що приймають числа, спершу зводять свої аргументи до чисел (здебільшого саме через це об'єкти Number поводяться подібно до числових примітивів). Ця операція може бути підсумована наступним чином:

• Числа повертаються як є.
• undefined перетворюється на NaN.
• null перетворюється на 0.
• true перетворюється на 1; false перетворюється на 0.
• Рядки перетворюються шляхом розбору їх так, ніби вони містять числовий літерал. Невдача розбору призводить до NaN. Є кілька несуттєвих відмінностей у порівнянні зі справжнім числовим літералом:
  • Пробіли й розриви на початку і в кінці рядка – ігноруються.
  • Цифра 0 на початку не робить з числа вісімковий літерал (і не призводить до відмови в суворому режимі).
  • + і - дозволені на початку й позначають знак числа. (У звичайному коді вони "мають вигляд" частини літерала, хоча насправді є окремими унарними операторами.). Проте знак може бути лише один, і після нього не повинно бути пробілів.
  • Infinity та -Infinity беруться за літерали. У звичайному коді вони є глобальними змінними.
  • Порожні рядки й рядки лише з пробілів – перетворюються на 0.
  • Числові роздільники не дозволені.
• BigInt викидають TypeError, аби запобігти ненавмисному неявному зведенню, і як наслідок – втраті точності.
• Символи викидають TypeError.
• Об'єкти спершу перетворюються на примітиви шляхом виклику їх методів [@@toPrimitive]() (з підказкою "number"), valueOf() і toString() – в такому порядку. Результівний примітив опісля перетворюється на число.

У JavaScript є два способи досягнути майже такого самого ефекту.

• Унарний плюс: + виконує для перетворення x саме такі кроки зведення до числа, як описано вище.
• Функція Number(): Number(x) використовує для перетворення x такий само алгоритм, окрім того, що BigInt не викидають TypeError, а повертають своє числове значення, з можливою втратою точності.

Number.parseFloat() і Number.parseInt() – подібні до Number(), але перетворюють лише рядки, а також мають дещо інакші правила розбору. Наприклад, parseInt() не розуміє десяткового розділювача, а parseFloat() не розуміє префіксу 0x.

Перетворення на ціле

Певні операції очікують на цілі числа, перш за все – ті, котрі працюють з індексами в масивах чи рядках, компонентами дат і часу, а також основою числення. Після виконання кроків зведення до числа, описаних вище, результат обрізається до цілого значення (шляхом відкидання дробової частини). Якщо число – це ±Infinity, то воно повертається як є. Якщо це число – NaN або -0, то воно повертається як 0. Таким чином, результат завжди є цілим числом (чим не є -0) або ±Infinity.

Цікаво, що при перетворенні на ціле число і undefined, і null стають 0, тому що undefined перетворюється на NaN, що так само стає 0.

Перетворення чисел фіксованої ширини

JavaScript має низькорівневі функції, що працюють з двійковим кодуванням цілих чисел, перш за все – бітові оператори та об'єкти TypedArray. Бітові оператори завжди перетворюють операнди на 32-бітові цілі числа. В таких випадках, після перетворення значення на число, таке число нормалізується до заданої ширини шляхом спершу відкидання дробової частини, а потім - взяття молодших бітів двійкового кодування числа.

new Int32Array([1.1, 1.9, -1.1, -1.9]); // Int32Array(4) [ 1, 1, -1, -1 ]

new Int8Array([257, -257]); // Int8Array(2) [ 1, -1 ]
// 257 = 0001 0000 0001
//     =      0000 0001 (mod 2^8)
//     = 1
// -257 = 1110 1111 1111
//      =      1111 1111 (mod 2^8)
//      = -1 (як ціле зі знаком)
new Uint8Array([257, -257]); // Uint8Array(2) [ 1, 255 ]
// -257 = 1110 1111 1111
//      =      1111 1111 (mod 2^8)
//      = 255 (як ціле без знаку)

Конструктор

Number()

Створює нове значення Number.

Коли Number викликається як конструктор (із new), це породжує об'єкт Number, котрий не є примітивом. Наприклад, typeof new Number(42) === "object", і new Number(42) !== 42 (проте new Number(42) == 42).

Застереження: Навряд вам доведеться часто застосовувати Number як конструктор.

Статичні властивості

Number.EPSILON

Найменший інтервал між числами, котрі можна представити.

Number.MAX_SAFE_INTEGER

Найбільше безпечне в JavaScript ціле число (2⁵³ - 1).

Number.MAX_VALUE

Найбільше додатне число, котре можна представити.

Number.MIN_SAFE_INTEGER

Найменше безпечне в JavaScript ціле число (-(2⁵³ - 1)).

Number.MIN_VALUE

Найменше додатне число, котре можна представити, а отже – найближче до нуля додатне число (котре все ж не є нулем).

Number.NaN

Особливе значення "Not a Number" ("не число").

Number.NEGATIVE_INFINITY

Особливе значення, що представляє від'ємну нескінченність. Повертається при переповненні.

Number.POSITIVE_INFINITY

Особливе значення, що представляє нескінченність. Повертається при переповненні.

Статичні методи

Number.isFinite()

З'ясовує, чи є передане значення скінченним числом.

Number.isInteger()

З'ясовує, чи є передане значення цілим числом.

Number.isNaN()

З'ясовує, чи є передане значення NaN.

Number.isSafeInteger()

З'ясовує, чи є передане значення безпечним цілим (числом в діапазоні від -(2⁵³ - 1) до 2⁵³ - 1).

Number.parseFloat()

Те саме, що й глобальна функція parseFloat().

Number.parseInt()

Те саме, що й глобальна функція parseInt().

Властивості примірника

Ці властивості означені на Number.prototype і є спільними для всіх примірників Number.

Number.prototype.constructor

Функція-конструктор, що створила об'єкт-примірник. Для примірників Number початковим значенням є конструктор Number.

Методи примірника

Number.prototype.toExponential()

Повертає рядок, що представляє число в експоненціальному записі.

Number.prototype.toFixed()

Повертає рядок, що представляє число в записі з фіксованою комою.

Number.prototype.toLocaleString()

Повертає рядок представлення числа, що є чутливим до мови. Заміщає метод Object.prototype.toLocaleString().

Number.prototype.toPrecision()

Повертає рядок, що представляє число до певної точності, в записі з фіксованою комою чи експоненціальному.

Number.prototype.toString()

Повертає рядок, що представляє вказаний об'єкт в указаній основі числення. Заміщає метод Object.prototype.toString().

Number.prototype.valueOf()

Повертає примітивне значення вказаного об'єкта. Заміщає метод Object.prototype.valueOf().

Приклади

Застосування об'єкта Number для присвоєння числовим змінним значень

Наступний приклад використовує властивості об'єкта Number для присвоєння значень декільком числовим змінним:

const biggestNum = Number.MAX_VALUE;
const smallestNum = Number.MIN_VALUE;
const infiniteNum = Number.POSITIVE_INFINITY;
const negInfiniteNum = Number.NEGATIVE_INFINITY;
const notANum = Number.NaN;

Діапазон цілих чисел для Number

Наступний приклад демонструє мінімальне й максимальне значення цілих чисел, що можуть бути представлені об'єктом Number.

const biggestInt = Number.MAX_SAFE_INTEGER; // (2**53 - 1) => 9007199254740991
const smallestInt = Number.MIN_SAFE_INTEGER; // -(2**53 - 1) => -9007199254740991

При розборі даних, що були серіалізовані в JSON, від цілочислових значень, що випадають із цього діапазону, можна очікувати псування, коли розбирач JSON приводитиме їх до типу Number.

Це можливо обійти шляхом застосування String.

Більші числа можуть бути представлені за допомогою типу BigInt.

Використання Number() для перетворення об'єкта Date

Наступний приклад перетворює об'єкт Date на числове значення, застосовуючи Number як функцію:

const d = new Date("1995-12-17T03:24:00");
console.log(Number(d));

Це виводить 819199440000.

Перетворення числових рядків і null на числа

Number("123"); // 123
Number("123") === 123; // true
Number("12.3"); // 12.3
Number("12.00"); // 12
Number("123e-1"); // 12.3
Number(""); // 0
Number(null); // 0
Number("0x11"); // 17
Number("0b11"); // 3
Number("0o11"); // 9
Number("foo"); // NaN
Number("100a"); // NaN
Number("-Infinity"); // -Infinity

Специфікації

Сумісність із браузерами

Дивіться також

• Поліфіл сучасної логіки Number (з підтримкою двійкових та вісімкових літералів) у складі core-js
• NaN
• Арифметичні оператори
• Math
• BigInt