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

Math.log2() вычисляет логарифм по основанию 2.

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

Синтаксис

Math.log2(x)

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

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

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

console.log(Math.log2(1)); // 0
console.log(Math.log2(2)); // 1
console.log(Math.log2(8)); // 3

Это значит:

Math.log2(1) даёт 0, потому что 2^0 = 1
Math.log2(2) даёт 1, потому что 2^1 = 2
Math.log2(8) даёт 3, потому что 2^3 = 8

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

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

const result = Math.log2(16);

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

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

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

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

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

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

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

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

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

console.log(Math.log2(0.5));  // -1
console.log(Math.log2(0.25)); // -2

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

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

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

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

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

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

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

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

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

Math.log2() и Math.log()

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

console.log(Math.log2(8)); // 3
console.log(Math.log(8));  // 2.0794415416798357

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

Если нужен именно логарифм по двойке, лучше сразу использовать Math.log2().

Math.log2() и Math.log(x) / Math.log(2)

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

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

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

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

Math.log2() и Math.log10()

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

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

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

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

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

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

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

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

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

console.log(Math.log2("8"));   // 3
console.log(Math.log2(true));  // 0
console.log(Math.log2(null));  // -Infinity
console.log(Math.log2(undefined)); // NaN

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

NaN и Infinity

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

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

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

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

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

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

const value = 32;
const result = Math.log2(value);

console.log(value);  // 32
console.log(result); // 5

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

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

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

Пример:

const value = 1024;

console.log(Math.log2(value)); // 10

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

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

console.log(Math.log2(8)); // 3
console.log(Math.log(8));  // 2.0794415416798357

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

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

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

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

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

console.log(Math.log2(-8)); // NaN

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

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

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

Коротко

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