First code
Назад

Числовые методы JavaScript

JavaScript, как язык программирования для веб-разработки, предоставляет богатый арсенал для работы с числами. Понимание этих инструментов — ключ к созданию надежных и точных приложений, будь то финансовые расчеты, научные симуляции или просто обработка данных форм.

Методы чисел в JavaScript — это встроенные функции и операции, предназначенные для преобразования, проверки и выполнения математических действий над числовыми значениями. Они делятся на методы, вызываемые непосредственно на числе (например, n.toFixed()), и статические методы, вызываемые через глобальный объект Math или объект-конструктор Number.

Методы чисел для форматирования и преобразования

Эти методы вызываются непосредственно на экземпляре числа и используются primarily для преобразования числа в строку в определенном формате.

toFixed()

Метод toFixed() - Форматирует число, фиксируя количество знаков после запятой, и возвращает строку. В качестве аргумента передается число, которое определяет, сколько должно выводиться количество знаков после десятичной точки. По умолчанию 0.

const number = 9.21893;

// если в качестве агрумента передается ноль или нет значения, то возвращает целое число и округляет его в большую или в меньшую сторону
console.log( number.toFixed() ); // 9
console.log( number.toFixed(0) ); // 9

console.log( number.toFixed(2) ); // 9.21
console.log( number.toFixed(4) ); // 9.2189

toPrecision()

Метод toPrecision() - возвращает строку с числом заданной длины. Форматирует число до заданной точности (общего количества значащих цифр) и возвращает строку.

const number = 9.21893;

console.log( number.toPrecision() ); // 9.21893
console.log( number.toPrecision(2) ); // 9.2
console.log( number.toPrecision(4) ); // 9.218

toExponential()

Возвращает строку, представляющую число в экспоненциальной записи.

const number = 12345;

console.log( number.toExponential(2) ); // "1.23e+4" (то есть 1.23 * 10⁴)

Статические методы объекта Number

Эти методы вызываются непосредственно на объекте-конструкторе Number и служат для проверки или преобразования числовых значений.

Number.isInteger()

Метод Number.isInteger() - возвращает true, если переданное значение является целым числом, и false в противном случае. Обратите внимание, что метод isInteger() не преобразует строковые значения в числа, поэтому если вы передадите строку, метод вернёт false, даже если строка содержит целое число.

console.log(Number.isInteger(123)); // true
console.log(Number.isInteger(123.45)); // false
console.log(Number.isInteger('123')); // false
console.log(Number.isInteger('123.45')); // false
console.log(Number.isInteger(true)); // false
console.log(Number.isInteger(null)); // false
console.log(Number.isInteger(undefined)); // false

Number.isNaN()

Метод Number.isNaN() объекта Number возвращает true, если переданное значение является Not a Number (NaN), и false в противном случае. NaN - это специальное значение в JavaScript, которое представляет собой результат операции, которая не может быть вычислена как число.

console.log(Number.isNaN(NaN)); // true
console.log(Number.isNaN(123 / 'abc')); // true
console.log(Number.isNaN('abc')); // false
console.log(Number.isNaN(123)); // false
console.log(Number.isNaN('123')); // false
console.log(Number.isNaN(null)); // false
console.log(Number.isNaN(undefined)); // false

Number.isFinite()

Метод Number.isFinite() в JavaScript проверяет, является ли переданное значение конечным числом. Он возвращает true, если значение является конечным числом, и false в противном случае. Конечное число - это число, которое не является бесконечным (Infinity) и не является NaN. true - если значение является конечным числом (например, 10, -5, 3.14, 0). false - если значение является: NaN, Infinity, или -Infinity.

console.log(Number.isFinite(123));      // true
console.log(Number.isFinite(0));         // true
console.log(Number.isFinite(-10));       // true
console.log(Number.isFinite(3.14));      // true
console.log(Number.isFinite(NaN));       // false
console.log(Number.isFinite(Infinity));  // false
console.log(Number.isFinite(-Infinity)); // false
console.log(Number.isFinite('10'));      // false (в отличие от isFinite('10') === true)
console.log(Number.isFinite(null));      // false
console.log(Number.isFinite(undefined)); // false

Number.isSafeInteger()

Проверяет, является ли число 'безопасным' целым. Безопасные целые числа лежат в диапазоне от -(2⁵³ - 1) до +(2⁵³ - 1). В этом диапазоне математические операции работают корректно.

console.log(Number.isSafeInteger(42)); // true
console.log(Number.isSafeInteger(9007199254740992)); // false (это как раз 2⁵³)

Number.parseInt()

Аналогичен глобальной функции parseInt(). Преобразует строку в целое число. Второй необязательный аргумент – система счисления (от 2 до 36).

console.log(Number.parseInt('123.45abc')); // 123
console.log(Number.parseInt('42px')); // 42
console.log(Number.parseInt('42.5px')); // 42
console.log(Number.parseInt('1010', 2)) // 10 (двоичная система)
console.log(Number.parseInt('ff', 16)) // 255 (шестнадцатеричная система)

Number.parseFloat()

Аналогичен глобальной функции parseFloat(). Преобразует строку в число с плавающей запятой. Игнорирует нечисловые символы в конце.

console.log(Number.parseFloat('123.45abc')); // 123.45
console.log(Number.parseFloat('95.27 рублей')); // 95.27
// console.log(Number.parseFloat('95 рублей')); // 95

Объект Math в JavaScript

Объект Math - это встроенный глобальный объект в JavaScript, который содержит свойства для математических констант (таких как Math.PI) и методы для выполнения математических операций. Важно отметить, что все методы и свойства объекта Math являются статическими. Это означает, что вам не нужно создавать экземпляр объекта Math для его использования — вы обращаетесь к методам и свойствам напрямую через Math.

Math.ceil()

Округляет число до следующего наибольшего целого числа

console.log( Math.ceil(9.2) ); // 10
console.log( Math.ceil(7.8) ); // 8
console.log( Math.ceil(-5.5) ); // -5
console.log( Math.ceil(-98.1) ); // -98

Math.round()

Округляет число до следующего наименьшего целого числа, если его десятичная часть меньше 0.5. Если же десятичная часть равна или больше 0.5, то округление идет до ближайшего наибольшего целого числа

console.log( Math.round(9.2) ); // 9
console.log( Math.round(7.8) ); // 8
console.log( Math.round(19.5) ); // 20
console.log( Math.round(-98.1) ); // -98
console.log( Math.round(-7.5) ); // -8

Math.trunc()

Возвращает целую часть числа, отбрасывая дробную часть

console.log( Math.trunc(9.2) ); // 9
console.log( Math.trunc(7.8) ); // 7
console.log( Math.trunc(19.5) ); // 19
console.log( Math.trunc(-98.1) ); // -98

Math.random()

Возвращает случайное число с плавающей точкой от 0 до 1

console.log( Math.random() ); // вернет случайное число от 0 до 1 (0 не включительно, 1 не включительно)
console.log( Math.random() * 100 ); // вернет случайное число от 0 до 100 (100 не включительно)
console.log( Math.round( Math.random() * 10 ) ); // вернет случайное число от 0 до 10 
console.log( Math.ceil( Math.random() * 10 ) ); // вернет случайное число от 1 до 10
console.log( Math.floor( Math.random() * 10 ) ); // вернет случайное число от 0 до 19

Math.sign()

Возвращает -1, 0 или 1 в зависимости от числа. Если число больше 0, то возвращается 1. Если число меньше 0, то возвращается -1. Если число равно 0, то возвращается 0

console.log( Math.sign(-5) ); // -1
console.log( Math.sign(0) ); // 0
console.log( Math.sign(5) ); // 1

Math.abs()

Возвращает абсолютное значение числа (неотрицательное число)

console.log( Math.abs(-25) ); // 25
console.log( Math.abs(54) ); // 54
console.log( Math.abs(0) ); // 0

Math.pow()

Возвращает число в определенной степени

console.log( Math.pow(2, 3) ); // 8
console.log( Math.pow(5, 7) ); // 78125

Math.sqrt()

Возвращает квадратный корень числа

console.log( Math.sqrt(16) ); // 4
console.log( Math.sqrt(2) ); // 1.4142135623730951
console.log( Math.sqrt(9) ); // 3
console.log( Math.sqrt(25) ); // 5

Math.cbrt()

Возвращает кубический корень числа

console.log( Math.cbrt(8) ); // 2
console.log( Math.cbrt(27) ); // 3
console.log( Math.cbrt(125) ); // 5

Math.log()

Возвращает натуральный логарифм (по основанию e) числа x. Если x < 0, то возвращается NaN

console.log(Math.log(1)); // 0
console.log(Math.log(Math.E)); // 1
console.log(Math.log(10)); // 2.302585092994046
console.log(Math.log(100)); // 4.605170185988092

Math.log10()

Возвращает логарифм по основанию 10 числа x. Если x < 0, то возвращается NaN

console.log(Math.log10(10)); // 1
console.log(Math.log10(100)); // 2
console.log(Math.log10(1000)); // 3
console.log(Math.log10(10000)); // 4

Math.log2()

Возвращает логарифм по основанию 2 числа x. Если x < 0, то возвращается NaN

console.log(Math.log2(2)); // 1
console.log(Math.log2(8)); // 3
console.log(Math.log2(16)); // 4
console.log(Math.log2(32)); // 5

Math.sin()

Возвращает синус угла x (в радианах). Все тригонометрические функции работают с радианами. Если x < 0, то возвращается NaN

console.log(Math.sin(0)); // 0
console.log(Math.sin(Math.PI / 2)); // 1

Math.cos()

Возвращает синус угла x (в радианах). Если x < 0, то возвращается NaN

console.log(Math.sin(0)); // 0
console.log(Math.sin(Math.PI / 2)); // 1

Math.tan()

Возвращает тангенс угла x (в радианах).

console.log(Math.tan(0)); // 0
console.log(Math.tan(Math.PI / 4)); // 0.9999999999999999 (приблизительно 1)
console.log(Math.tan(Math.PI / 2)); // 1.633123935319537e+16 (приблизительно Infinity)

Math.asin()

Возвращает арксинус числа x (результат в радианах).

console.log(Math.asin(0)); // 0
console.log(Math.asin(1)); // 1.5707963267948966 (π/2)

Math.acos()

Возвращает арккосинус числа x (результат в радианах).

console.log(Math.acos(1)); // 0
console.log(Math.acos(0)); // 1.5707963267948966 (π/2)

Math.atan(x)

Возвращает арктангенс числа x (результат в радианах).

console.log(Math.atan(0)); // 0
console.log(Math.atan(1)); // 0.7853981633974483 (π/4)

Math.atan2(y, x)

Возвращает арктангенс частного y/x (учитывает знаки аргументов).

console.log(Math.atan2(1, 1)); // 0.7853981633974483 (π/4)
console.log(Math.atan2(1, -1)); // 2.356194490192345 (3π/4)

Math.sinh(x)

Возвращает гиперболический синус числа x.


console.log(Math.sinh(0)); // 0
console.log(Math.sinh(1)); // 1.1752011936438014
console.log(Math.sinh(2)); // 3.626860407847019
console.log(Math.sinh(3)); // 7.38905609893065

Math.cosh(x)

Возвращает гиперболический косинус числа x.


console.log(Math.cosh(0)); // 1
console.log(Math.cosh(1)); // 1.5430806348152437
console.log(Math.cosh(2)); // 3.7621956910836314
console.log(Math.cosh(3)); // 10.067661995776365

Math.tanh(x)

Возвращает гиперболический тангенс числа x.


console.log(Math.tanh(0)); // 0
console.log(Math.tanh(1)); // 0.7615941559557649
console.log(Math.tanh(2)); // 0.9640275800758169
console.log(Math.tanh(3)); // 0.9950547536867305
console.log(Math.tanh(10)); // 1

Math.hypot()

Возвращает гипотенузу треугольника


console.log( Math.hypot(3, 4) ); // 5
console.log( Math.hypot(12, 5) ); // 13
console.log( Math.hypot(8, 15) ); // 17

Math.fround()

Возвращает ближайшее число с плавающей запятой одинарной точности.


console.log(Math.fround(1.337)); // 1.3370000123977661
console.log(Math.fround(1.337, 2)); // 1.34
console.log(Math.fround(1.337, 3)); // 1.337
console.log(Math.fround(1.337, 4)); // 1.3370000123977661

Math.imul()

Возвращает результат 32-битного умножения двух чисел.


console.log(Math.imul(2, 4)); // 8
console.log(Math.imul(5, 10)); // 50
console.log(Math.imul(25, 100)); // 2500
console.log(Math.imul(7, 8)); // 56

Этот обзор охватывает ключевые числовые методы JavaScript, которые являются фундаментом для любого разработчика. Правильное их применение позволит вам писать более чистый, эффективный и безошибочный код.