Проверка типа данных в JavaScript: typeof, instanceof и Array.isArray на практике

Поисковый запрос «как проверить тип данных в JavaScript» часто приводит новичков к простому ответу: используйте typeof. Но на практике этого недостаточно. В JavaScript есть особенности: null определяется как object, массивы тоже имеют тип object, а объект даты нужно отличать от обычного объекта. Разберёмся, какие инструменты использовать и когда.

Зачем вообще проверять типы в JavaScript

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

Например, функция ожидает число, а получает строку:

function calculateDiscount(price) {
  return price * 0.9;
}

console.log(calculateDiscount(100));   // 90
console.log(calculateDiscount("100")); // 90, но это не всегда безопасно
console.log(calculateDiscount("abc")); // NaN

Поэтому в реальном коде полезно явно проверять входные данные перед вычислениями.

typeof: базовая проверка примитивов

Оператор typeof возвращает строку с названием типа. Лучше всего он подходит для проверки примитивных значений: строк, чисел, boolean, undefined, symbol и bigint.

console.log(typeof "hello");    // "string"
console.log(typeof 42);         // "number"
console.log(typeof true);       // "boolean"
console.log(typeof undefined);  // "undefined"
console.log(typeof 10n);        // "bigint"
console.log(typeof Symbol());   // "symbol"
console.log(typeof function(){}); // "function"

Типичная практическая проверка выглядит так:

function greet(name) {
  if (typeof name !== "string") {
    throw new TypeError("name должен быть строкой");
  }

  return `Привет, ${name}!`;
}

console.log(greet("Анна"));

Главная ловушка: typeof null

Одна из самых известных особенностей JavaScript: typeof null возвращает "object". Это историческая ошибка языка, которую нельзя исправить без нарушения совместимости старого кода.

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

Поэтому null проверяют строго через сравнение:

const value = null;

if (value === null) {
  console.log("Значение явно равно null");
}

Если вам нужно проверить, что значение является объектом, но не null, используйте такую конструкцию:

function isObject(value) {
  return typeof value === "object" && value !== null;
}

console.log(isObject({}));   // true
console.log(isObject(null)); // false
console.log(isObject([]));   // true

Обратите внимание: массив тоже объект. Если массивы нужно исключить, добавим отдельную проверку.

Array.isArray(): как проверить массив

Для массивов не стоит использовать typeof, потому что он вернёт "object". Правильный способ — метод Array.isArray().

console.log(typeof [1, 2, 3]);      // "object"
console.log(Array.isArray([1, 2])); // true
console.log(Array.isArray({0: "a"})); // false

Практический пример: функция принимает список товаров и считает общую сумму.

function getTotal(items) {
  if (!Array.isArray(items)) {
    throw new TypeError("items должен быть массивом");
  }

  return items.reduce((sum, item) => sum + item.price, 0);
}

const cart = [
  { title: "Книга", price: 500 },
  { title: "Курс", price: 1500 }
];

console.log(getTotal(cart)); // 2000

instanceof: проверка экземпляров классов

Оператор instanceof проверяет, создан ли объект через определённый конструктор или класс. Он полезен для Date, Error, Map, Set и собственных классов.

const date = new Date();
const error = new Error("Ошибка");

console.log(date instanceof Date);   // true
console.log(error instanceof Error); // true
console.log([] instanceof Array);    // true

Пример с собственным классом:

class User {
  constructor(name) {
    this.name = name;
  }
}

const user = new User("Иван");

console.log(user instanceof User); // true
console.log(user instanceof Object); // true

Но не злоупотребляйте instanceof для обычных объектов из API. Данные, пришедшие с сервера в JSON, не становятся экземплярами ваших классов автоматически — это простые объекты.

Как проверить обычный объект

Иногда нужно убедиться, что значение — именно обычный объект, а не массив, дата или null. Например, при проверке настроек функции.

function isPlainObject(value) {
  return Object.prototype.toString.call(value) === "[object Object]";
}

console.log(isPlainObject({ name: "Alex" })); // true
console.log(isPlainObject([]));               // false
console.log(isPlainObject(null));             // false
console.log(isPlainObject(new Date()));       // false

Такой способ надёжнее, чем просто typeof value === "object", если вам важно отделить обычные объекты от других объектных типов.

Проверка числа: осторожно с NaN

Для чисел одной проверки typeof часто мало, потому что NaN тоже имеет тип number.

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

Если нужно проверить нормальное конечное число, используйте Number.isFinite():

function isValidNumber(value) {
  return typeof value === "number" && Number.isFinite(value);
}

console.log(isValidNumber(25));       // true
console.log(isValidNumber(NaN));      // false
console.log(isValidNumber(Infinity)); // false
console.log(isValidNumber("25"));     // false

Это особенно важно при расчётах, работе с ценами, процентами, координатами и любыми пользовательскими данными.

Универсальная функция определения типа

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

function getType(value) {
  if (value === null) return "null";
  if (Array.isArray(value)) return "array";
  if (value instanceof Date) return "date";
  if (value instanceof RegExp) return "regexp";

  return typeof value;
}

console.log(getType("text"));      // "string"
console.log(getType(null));        // "null"
console.log(getType([1, 2, 3]));   // "array"
console.log(getType(new Date()));  // "date"
console.log(getType({}));          // "object"

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

Практический пример: проверяем настройки функции

Допустим, у нас есть функция создания уведомления. Она принимает объект настроек: текст, тип и время показа. Проверим данные перед использованием.

function showNotification(options) {
  if (!isPlainObject(options)) {
    throw new TypeError("options должен быть объектом");
  }

  if (typeof options.message !== "string" || options.message.trim() === "") {
    throw new TypeError("message должен быть непустой строкой");
  }

  if (typeof options.type !== "string") {
    options.type = "info";
  }

  if (!Number.isFinite(options.timeout)) {
    options.timeout = 3000;
  }

  console.log(`[${options.type}] ${options.message}`);

  setTimeout(() => {
    console.log("Уведомление скрыто");
  }, options.timeout);
}

showNotification({
  message: "Данные сохранены",
  type: "success",
  timeout: 2000
});

Здесь используются сразу несколько подходов: проверка обычного объекта, строки и конечного числа. Такой стиль делает код предсказуемее и понятнее.

Краткая шпаргалка

• typeof value — для string, number, boolean, undefined, function, symbol, bigint.
• value === null — для проверки null.
• Array.isArray(value) — для массивов.
• value instanceof Date — для объектов, созданных конкретным классом или конструктором.
• Number.isFinite(value) вместе с typeof — для проверки нормальных чисел.
• Object.prototype.toString.call(value) — для более точного определения встроенных типов.

Рекомендации

Не пытайтесь проверять всё подряд без необходимости. Проверяйте границы программы: данные из форм, API, localStorage, query-параметров и аргументы публичных функций. Внутри хорошо организованного кода лишние проверки могут только усложнять чтение.

Если вы хотите не просто запомнить отдельные операторы, а уверенно понимать основы языка, типы, функции, объекты и асинхронность, обратите внимание на курс «JavaScript с нуля до Гуру 2.0» — пошаговый путь к уверенной разработке. Он хорошо дополняет такие практические темы и помогает собрать знания в систему.

Вывод

Проверка типа данных в JavaScript — это не один оператор, а набор инструментов. Используйте typeof для примитивов, Array.isArray() для массивов, instanceof для экземпляров классов и отдельные проверки для null и NaN. Тогда ваш код станет надёжнее, а ошибки из-за неожиданных типов будут встречаться намного реже.