Math.log10() - метод для вычисления десятичного логарифма в JavaScript

Math.log10() вычисляет десятичный логарифм числа.

Проще всего запомнить так: Math.log10(x) отвечает на вопрос, в какую степень нужно возвести 10, чтобы получить x.

Синтаксис

Math.log10(x)

x - число, для которого нужно найти логарифм по основанию 10.

Что делает Math.log10()

Метод возвращает логарифм по основанию 10.

console.log(Math.log10(1));    // 0
console.log(Math.log10(10));   // 1
console.log(Math.log10(1000)); // 3

Это значит:

Math.log10(1) даёт 0, потому что 10^0 = 1
Math.log10(10) даёт 1, потому что 10^1 = 10
Math.log10(1000) даёт 3, потому что 10^3 = 1000

Что возвращает Math.log10()

Math.log10() возвращает число типа number.

const result = Math.log10(100);

console.log(result);        // 2
console.log(typeof result); // "number"

Почему Math.log10(1) равно 0

Это один из базовых случаев.

console.log(Math.log10(1)); // 0

Потому что любое ненулевое основание в степени 0 даёт 1.

Числа больше 1 и меньше 1

Если число больше 1, логарифм будет положительным.

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

Если число находится между 0 и 1, логарифм будет отрицательным.

console.log(Math.log10(0.1));  // -1
console.log(Math.log10(0.01)); // -2

Это нормальное поведение, а не ошибка.

Что происходит с 0

Для нуля результатом будет -Infinity.

console.log(Math.log10(0)); // -Infinity

Это логично: чтобы получить всё более маленькие положительные числа, степень у 10 должна уходить всё дальше в минус.

Отрицательные числа

Для отрицательных значений результатом будет NaN.

console.log(Math.log10(-1)); // NaN

В обычных числах JavaScript десятичный логарифм отрицательного значения не вычисляется.

Math.log10() и Math.log()

Math.log10() и Math.log() - это не одно и то же.

console.log(Math.log10(100)); // 2
console.log(Math.log(100));   // 4.605170185988092

Math.log10() работает по основанию 10
Math.log() работает по основанию e

Именно поэтому для десятичных логарифмов лучше сразу использовать Math.log10().

Math.log10() и Math.log(x) / Math.log(10)

Десятичный логарифм можно получить и через формулу смены основания.

console.log(Math.log10(1000));              // 3
console.log(Math.log(1000) / Math.log(10)); // 3

Результат обычно будет одинаковым.

Но Math.log10(x) читается проще и сразу показывает намерение.

Math.log10() и Math.log2()

В JavaScript есть отдельные методы и для других оснований.

console.log(Math.log10(100)); // 2
console.log(Math.log2(8));    // 3

Если нужен логарифм по основанию 2, обычно используют Math.log2().

Без аргумента

Если вызвать Math.log10() без аргумента, результатом будет NaN.

console.log(Math.log10()); // NaN

Так происходит потому, что метод попытается обработать undefined как число.

Неявное приведение типов

Math.log10() сначала пытается привести аргумент к числу.

console.log(Math.log10("100"));   // 2
console.log(Math.log10(true));    // 0
console.log(Math.log10(null));    // -Infinity
console.log(Math.log10(undefined)); // NaN

На практике обычно лучше передавать в метод уже готовое число.

NaN и Infinity

Для специальных значений метод ведёт себя предсказуемо.

console.log(Math.log10(NaN));       // NaN
console.log(Math.log10(Infinity));  // Infinity
console.log(Math.log10(-Infinity)); // NaN

Это полезно помнить:

Infinity даёт Infinity
-Infinity даёт NaN

Число не меняется

Math.log10() не изменяет исходное значение. Он только возвращает новый результат.

const value = 1000;
const result = Math.log10(value);

console.log(value);  // 1000
console.log(result); // 3

Когда это полезно

Math.log10() удобно использовать, когда:

нужен именно десятичный логарифм
вы работаете с величинами, которые удобно выражать степенями 10
хочется быстро понять порядок числа
нужно получить значение в более компактной шкале

Пример:

const value = 1000000;

console.log(Math.log10(value)); // 6

Частые ошибки

Путать Math.log10() и Math.log()

console.log(Math.log10(100)); // 2
console.log(Math.log(100));   // 4.605170185988092

У этих методов разное основание.

Ожидать NaN для нуля

console.log(Math.log10(0)); // -Infinity

Для нуля метод возвращает именно -Infinity.

Ожидать обычное число для отрицательного аргумента

console.log(Math.log10(-10)); // NaN

Для отрицательных значений десятичный логарифм в обычных числах JavaScript не вычисляется.

Быстрая памятка

Math.log10(x) вычисляет логарифм по основанию 10
метод возвращает number
Math.log10(1) равно 0
Math.log10(10) равно 1
для чисел между 0 и 1 результат отрицательный
Math.log10(0) даёт -Infinity
для отрицательных чисел результатом будет NaN
это не то же самое, что Math.log()

Коротко

Math.log10() - это стандартный способ вычислить десятичный логарифм в JavaScript. Главное, что стоит запомнить: метод работает именно по основанию 10, для 0 возвращает -Infinity, а для отрицательных значений даёт NaN.