Number & BigInt
// целые (integers)
123 || +123; // целое положительное (+123)
-123; // целое отрицательное
// Дробные (floating point)
123.123; // дробное
0.123; // дробное нецелое .123 (0 можно опустить)
// Со степенью (Scientific notation)
1e6; // 1000000 (1 * 10^6)
1e-6; // 0.000001 (1 * 10^-6)
// Binary, Octal, and Hexadecimal
0b1010; // Binary (10 in decimal) - Двоичное исчисление
0b1001; // 9
0b1001 === 2 ** 3 * 1 + 2 ** 2 * 0 + 2 ** 1 * 0 + 2 ** 0 * 1; // true
0o12; // Octal (10 in decimal) - Восьмиричное исчисление
0xabc123; // 11256099 16-чная
0xff; // Hexadecimal (255 in decimal) - hex-format
// спец. значения number
NaN; // not a number
Infinity || -Infinity;
123 / 0 === Infinity;
// разделитель
1_000_000; // _ - разделитель для удобства, _ игнорируется парсером
// диапозон
// от -(2 ** 53 − 1) до 2 ** 53 − 1
bigint
typeof 1234567890123456789012345678901234567890n; // 'bigint'
BigInt(9997000254999999);
Арифметические действия
// + - оперетор сложения
// - - оперетор вычитания
// * - оперетор умножения
// / - оперетор деления
// ** - оператор возведения в степень
// % - остаток от деления
1 + 2; // 3
1 - 2; // -1
1 * 2; // 2
1 / 2; // 0.5
2 ** 5; // 32, если еще одна альтернатива Math.pow(2, 3);
3 % 2; // 1
1 % 5 === (1 + 5) % 5;
// скобки учитываются как в арифметике
(0.1 * 10 + 0.2 * 10) / 10; // 0.3
// Визуальная ошибка в JS. Фундаментальная особенность хранения дробных чисел в памяти компьютера, с ней нужно уметь работать.
0.1 + 0.2; // 0.30000000000000004
0.2 + 0.7; // 0.8999999999999999 - известая ошибка округления
// прочие мат операций
undefined + 1; // NaN
0 / 0; // NaN
null + 1; // 1
true + 1; // 2
false + 1; // 1
undefined + '1'; // 'undefined1'
null + '1'; // 'null1'
true + '1'; // 'true1'
false + '1'; // 'false1';
// Также при вычитании, делении, возведении в квадрат
undefined * 1; // NaN
null * 1; // 0
true * 1; // 1
false * 1; // 0
undefined * '1'; // NaN
null * '1'; // 0
true * '1'; // 1
false * '1'; // 0
Сокращённая запись
a += 1; // a = a + 1;
a -= 1; // a = a - 1;
a *= 1; // a = a * 1;
a /= 1; // a = a / 1;
// присвоить i остаток от деления на 4
let i = 10;
i %= 4;
console.log(i); // 2
Инкремент-декремент
let i = 0;
// инкремент
++i; // префикстаня запись - сразу возвращает увеличенное значение
i++; // постфиксная запись - возвращает предыдущее значение, при следущем вызове будет увеличенное
// дикремент
--i; // префикстаня запись - сразу возвращает уменьшенное значение
i--; // постфиксная запись - возвращает предыдущее значение, при следущем вызове будет уменьшенное
// использование в цикле
for (let i = 0; i < 5; i++) {
console.log(i);
}
На практике лучше использовать только префиксную запись.
Сравнение чисел
// возвращает boolean
1 > 1; // false
1 < 1; // false
1 >= 1; // true
1 <= 1; // true
// нестрогое равно
1 == 1; // true
1 == '1'; // true
0 == false; // true
0 === false; // false
// оператор нестрогого и строгого отрицания
1 != '1'; // false
1 !== '1'; // true
// строгое равно - проверка типа данных
1 === '1'; // false
'0' == false; // true
0 === false; // false
// прочие сравнения
undefined === undefined; // true
null === null; // true
null === undefined; // false
// на практике всегда лучше использовать тольно строгое равно, чтобы не было вот таких непоняток
null == undefined; // true
'0' == false; // true
// частные случаи
NaN === NaN; // false
Infinity / Infinity; // NaN
Infinity === Infinity; // true
Преобразование типов
typeof 123; // 'number'
typeof NaN; // 'number'
typeof Infinity; // 'number'
// числовая строка в число
Number('123') || +'123'; // 123
Number('abc'); // NaN - нечисловая строка даёт NaN
Number('') || Number(' '); // 0 - пустая строка или строка с пробелами
// NaN и Infinity
Number('NaN'); // NaN
Number('Infinity'); // Infinity
// boolean в число
Number(true) || +true; // 1
Number(false) || +false; // 0
// null и undefined
Number(null) || Number(undefined); // 0
// любой объект
Number({ a: 1 }) || Number({}); // NaN
// пустой массив
Number([]); // 0
// массив с одним number или строковым числом
Number(['3']) || Number([3]); // 3
// массив с не одним number или строковым числом
Number(['3', '4']) || Number([3, 4]); // NaN
// любая функция
Number(() => null); // NaN
Number(function () {}); // NaN
// boolean
Boolean(1); // true
Boolean(0); // false
Boolean(Infinity); // true
Boolean(NaN); // false
Методы для number
// выделение целой части из числовой строки
parseInt('123.123'); // 123
// выделение целой v дробной части из числовой строки
parseFloat('123.123'); // 123.123
// оставить кол-во знаков дробной части - вернёт строку
(123.123).toFixed(2); //'123.12'
// оставить всего знаков с округлением - вернёт строку
(3.1415926).toPrecision(4); // '3.142'
// привести в экспонентальный вид - вернёт строку
(10000000).toExponential(2); // '1.00e+7'
// проверка на NaN - вернёт boolean
Number.isNaN(123 * 'abc'); // true
// Проверака на целове
Number.isInteger(123); // true
Number.isInteger(123.123); // false
Number.isSafeInteger(9007199254740991); // true - входит ли в диапозон JS
Number.isSafeInteger(9007199254740992); // false
// проверка на Infinyty
Number.isFinite(6 / 0); // false
Number.isFinite(6 / 2); // true
// локализация
new Intl.NumberFormat('ru', {
notation: 'compact',
}).format(100_000_000_000); // '100 млрд'
Также можно упомянуть некоторые свойства объекта Number:
// наибольшее представимое положительное число
Number.MAX_VALUE; // 1.7976931348623157e+308
// наименьшее представимое положительное число, большее нуля
Number.MIN_VALUE; // 5e-324
// наибольшее безопасное целое число в JavaScript
Number.MAX_SAFE_INTEGER; // 9007199254740991
// наименьшее безопасное целое число в JavaScript.
Number.MIN_SAFE_INTEGER; // -9007199254740991
// специальное значение, большее любого числа.
Number.POSITIVE_INFINITY; // Infinity
// специальное значение, меньшее любого числа.
Number.NEGATIVE_INFINITY; // -Infinity
// наименьшая разница между двумя представимыми числами
Number.EPSILON; // 2.220446049250313e-16
Math
// округление
Math.floor(123.123); // 123 - округление до нижнего
Math.ceil(123.123); // 124 - округление до верхнего
Math.round(123.123); // 123 - округление до среднего
Math.round(123.523); // 124 - округление до среднего
Math.trunc(123.523); // 123 - возвращает целую часть числа путём удаления всех дробных знаков
Math.trunc(-123.523); // -123
// рандом
Math.random(); // 0.2137036305422546 - рандомное значение от 0 до 1
Math.round(Math.random() * 100); // рандомное значение от 1 до 100
// min-max
Math.min(1, 2, 3, 4, 5, 6, 7); // 1
Math.max(1, 2, 3, 4, 5, 6, 7); // 7
// константы
Math.PI; // 3.141592653589793
Math.E; // 2.718281828459045
// тригонометрия
Math.sin(0); // 0
Math.cos(0); // 1
Math.tan(180); // 1.33
// степень
Math.pow(16, 2); // 256
Math.sqrt(256); // 16
// логорифм
Math.log(148.41316); // 5
// модуль
Math.abs(-123); // 123
Math редко используемые*
// Math.sign() возвращает знак числа, указывая, является ли число положительным, отрицательным или нулем
Math.sign(3); // 1
Math.sign(-3); // -1
Math.sign(0); // 0
// Math.trunc() возвращает целую часть числа, удаляя дробную часть.
Math.trunc(13.37); // 13
Math.trunc(-13.37); // -13
// Math.cbrt() возвращает кубический корень числа
Math.cbrt(27); // 3
Math.cbrt(-8); // -2
// Math.hypot() возвращает квадратный корень суммы квадратов своих аргументов.
Math.hypot(3, 4); // 5
// Math.imul() возвращает результат C-подобного 32-битного умножения двух чисел.
Math.imul(2, 4); // 8
Math.imul(-1, 8); // -8