typeof - оператор для проверки типа в JavaScript

typeof возвращает строку с типом значения.

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

Важно: typeof - это именно оператор, а не функция, хотя внешне запись иногда похожа на вызов функции.

Синтаксис

typeof value
typeof(value)

Обе записи работают.

Чаще используют вариант без скобок:

console.log(typeof "hello"); // "string"

Что делает typeof

typeof принимает значение и возвращает строку с названием типа.

console.log(typeof "JavaScript"); // "string"
console.log(typeof 42);           // "number"
console.log(typeof true);         // "boolean"

Результат всегда имеет тип string.

const result = typeof 10n;

console.log(result);        // "bigint"
console.log(typeof result); // "string"

Основные результаты typeof

Вот самые частые значения, которые возвращает оператор:

console.log(typeof "text");        // "string"
console.log(typeof 123);           // "number"
console.log(typeof true);          // "boolean"
console.log(typeof undefined);     // "undefined"
console.log(typeof 10n);           // "bigint"
console.log(typeof Symbol("id"));  // "symbol"

Для обычной базовой проверки этого часто достаточно.

typeof и null

Это самый известный нюанс оператора.

console.log(typeof null); // "object"

Хотя null не является обычным объектом, typeof null возвращает "object". Это историческая особенность JavaScript.

Если нужно проверить именно null, обычно сравнивают напрямую:

if (value === null) {
  console.log("Это null");
}

typeof и массивы

С массивами есть похожий нюанс:

console.log(typeof []); // "object"

Массив - это отдельный вид структуры данных, но typeof всё равно вернёт "object".

Поэтому для массива обычно используют не typeof, а Array.isArray():

console.log(Array.isArray([])); // true
console.log(Array.isArray({})); // false

typeof и функции

Для функций typeof возвращает "function".

function greet() {}

console.log(typeof greet); // "function"
console.log(typeof (() => {})); // "function"

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

class User {}

console.log(typeof User); // "function"

typeof и объекты

Для обычных объектов результат будет "object".

console.log(typeof {}); // "object"
console.log(typeof { name: "Anna" }); // "object"

Но это довольно широкая категория. Туда же попадают, например, null и массивы в смысле результата typeof.

Именно поэтому typeof value === "object" не всегда означает “это обычный объект”.

typeof и NaN

Ещё один частый сюрприз:

console.log(typeof NaN); // "number"

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

Если нужно проверить именно NaN, для этого используют Number.isNaN().

const value = Number("hello");

console.log(Number.isNaN(value)); // true

typeof и необъявленная переменная

У typeof есть полезная особенность: он не падает на необъявленной переменной, а возвращает "undefined".

console.log(typeof notDeclaredValue); // "undefined"

Это отличает его от обычного доступа:

// console.log(notDeclaredValue); // ReferenceError

Из-за этого typeof иногда используют для безопасной проверки существования глобальных значений.

Когда typeof действительно полезен

typeof особенно удобен, когда нужно проверить примитивные типы:

строку
число
boolean
undefined
bigint
symbol
функцию

Пример:

function printUpperCase(value) {
  if (typeof value !== "string") {
    console.log("Ожидалась строка");
    return;
  }

  console.log(value.toUpperCase());
}

Такие проверки встречаются очень часто и читаются хорошо.

Когда typeof недостаточно

typeof не всегда даёт достаточно точный ответ.

Например:

console.log(typeof null); // "object"
console.log(typeof []);   // "object"
console.log(typeof {});   // "object"

Во всех трёх случаях результат похожий, хотя значения разные.

Поэтому обычно:

для null используют value === null
для массива используют Array.isArray(value)
для точной проверки объекта добавляют дополнительные условия

Пример:

if (value !== null && typeof value === "object" && !Array.isArray(value)) {
  console.log("Это обычный объект");
}

Осторожно с приоритетом операторов

Есть ещё одна неочевидная ловушка:

console.log(typeof 1 + 2); // "number2"

Так происходит потому, что сначала выполняется typeof 1, получается строка "number", а потом идёт конкатенация с 2.

Если нужен тип результата выражения, лучше писать со скобками:

console.log(typeof (1 + 2)); // "number"

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

Думать, что typeof null вернёт “null”

console.log(typeof null); // "object"

Для null нужна отдельная проверка.

Проверять массив через typeof

console.log(typeof []); // "object"

Для массива почти всегда лучше Array.isArray().

Считать, что typeof object отличает обычный объект от всего остального

console.log(typeof null); // "object"
console.log(typeof []);   // "object"
console.log(typeof {});   // "object"

Этой проверки недостаточно, если нужна точность.

Удивляться, что typeof NaN даёт “number”

console.log(typeof NaN); // "number"

Это нормальное поведение JavaScript.

Забывать про скобки в выражениях

console.log(typeof 1 + 2);   // "number2"
console.log(typeof (1 + 2)); // "number"

Если проверяется результат выражения, скобки часто обязательны.

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

typeof возвращает строку с типом значения
typeof null даёт "object" из-за исторической особенности
typeof [] тоже даёт "object"
typeof function() {} даёт "function"
typeof NaN даёт "number"
typeof notDeclaredValue безопасно вернёт "undefined"
для массива обычно лучше Array.isArray(), а для null - === null

Коротко

typeof - это стандартный оператор JavaScript для быстрой проверки типа. Главное, что стоит запомнить: он отлично подходит для примитивов и функций, но для null, массивов и некоторых более точных сценариев его уже недостаточно, поэтому рядом часто используют === null, Array.isArray() и другие проверки.