Number и BigInt

TypeScript

const someNumber1: number = 123;
const someNumber2: 123 | 321 = 123;

---

Ограничен диапозоном ±(2 в 53-ей - 1).

Number.MAX_SAFE_INTEGER; // 9007199254740991

123;

1e6; // 1000000

// Изветные ошибки в js
0.6 + 0.7; // 1.2999999999999998
0.1 + 0.2; // 0.30000000000000004

// решение проблемы (в скобках приоритет)
(0.1 * 10 + 0.2 * 10) / 10; // 0.3

---

Целая и дробная часть

123; // целые числа
0.123; // дробные числа
0.123 === 0.123; // true

---

1231231312312312.toString(); // ошибка - нельзя применять методы к целым number
// так оператор . будет восприниматься как разделитель дробной части

// можно оборачивать в Number()
Number(123).toString(); // '123'

// если есть дробная часть, то ошибки не будет
123.123.toString(); // '123.123'

---

Мат. операторы

3 + 2; // 5 (сложение)
3 - 2; // 1 (вычитание)
3 * 2; // 6 (умножение)
3 / 2; // 1.5 (деление)
3 ** 2; // 9 (возведение в квадрат)
3 % 2; // 1 (остаток от деления)

Для остатка от деления неважно кол-во двоек, а важен именно остаток. У нуля и четных всегда ноль, у нечетных - один.

Число	Кол-во 2-ек	Остаток
0	0	0
1	0	1
2	1	0
3	1	1
4	2	0

---

Сокращенные операторы

let value = 123;

// сокращенная запись
value += 321; // value = value + 321;
value -= 321; // value = value - 321;
value *= 321; // value = value * 321;
value /= 321; // value = value / 321;

// Инкремент, декремент (префиксный и постфиксный)
++value; // value = value + 1; (меняет значение сразу на этой же строке)
--value; // value = value - 1; (меняет значение сразу на этой же строке)
value++; // value = value + 1; (меняет значение на следующей строке)
value--; // value = value - 1; (меняет значение на следующей строке)

---

Infinity и NaN

Специальные типы number (Частные случаи number)

123 / 0; // Infinity
123 / 'String'; // NaN (not a number)

// проверка на NaN
isNaN(123 / 'String'); // true

// проверка на число (с преобразованием типа)
isFinite('25'); // '25' --> 25 --> true
isFinite('abc'); // 'abc' --> NaN --> false
isFinite(10 / 0); // Infinity --> false

---

Конвертация строки в число

+'123'; // 123
Number('123'); // 123
parseFloat('123.12px'); // 123.12
parseInt('123.12px'); // 123

---

Системы исчисления

// 16-чная:
0xabc123; // 11256099

// 8-чная:
0123; // 83

// 2-чная:
0b1001; // 9

let num = 255;

// toString - метод-конвертатор системы исчисления
console.log(num.toString(2)); // 11111111
console.log(num.toString(8)); // 377
console.log(num.toString(16)); // ff
console.log(num.toString(32)); // 7v

---

Обрезать знаки после запятой

// будет конвертация в строку
(123.123123123123).toFixed(2); // '123.12'

// убрать конвертацию
+(123.123123123123).toFixed(2); // 123.12
Number((123.123123123123).toFixed(2)); // 123.12

Math

// рандомное число от 0 до 1
Math.random(); // 0.7010049975254584

// квадратный корень
Math.sqrt(256); // 16

// мин и макс
Math.min(5, 8, 10, 2); // 2
Math.max(5, 8, 10, 2); // 10

// округление
Math.floor(123.999); // 123 (округление в меньшую)
Math.ceil(123.111); // 124 (округление в большую)
Math.round(123.527); // 124 (округление в среднюю)

// модули
Math.trunc(-123.932); // -123 (возвращает целую часть числа путём удаления всех дробных знаков.)
Math.abs(-123.988); // 123 (возвращает положительныую часть)

// константы
Math.PI; // 3.14
Math.E; // 2.7
Math.LOG10E; // 0.434

---

BigInt

Используется редко, в основном для шифрования. Ввели, чтобы снять ограничения на цифровую длину символов.

typeof 1234567890123456789012345678901234567890n; // BigInt
typeof 10n; // BigInt

---

Локализация

// '100000000000 --> 100 млрд'
new Intl.NumberFormat('ru', {
  notation: 'compact',
}).format(100000000000);

---

Сравнение чисел

Возвращается boolean.

1 > 2; // false
1 > '2'; // false (будет конвертация строки в number)
1 > 'abc'; // 1 > NaN // false
1 >= 2; // false

1 < 2; // true
1 <= 2; // true

1 == '1'; // true - нестрогое сравнение (тип данных не учитывается)
1 === '1'; // false - строгое сравнение (тип данных учитывается)

1 != '1'; // false - нестрогое сравнение (тип данных не учитывается)
1 !== '1'; // true - строгое сравнение (тип данных учитывается)

1 === 1; // true
1 === 2; // false