Какие знаешь конструкции в JS, позволяющие узнать тип переменной?

Методы определения типа переменной в JavaScript

В JavaScript существует несколько конструкций и операторов для определения типа данных переменной. Каждый из них имеет свои особенности, преимущества и подводные камни.

1. Оператор typeof

Наиболее известный оператор, возвращающий строку с типом данных.

console.log(typeof 42);           // "number"
console.log(typeof "Hello");      // "string"
console.log(typeof true);         // "boolean"
console.log(typeof undefined);    // "undefined"
console.log(typeof null);         // "object" ← известная особенность!
console.log(typeof {});           // "object"
console.log(typeof []);           // "object" (не "array"!)
console.log(typeof function(){}); // "function"

Особенности:

• Возвращает тип в виде строки
• Для null возвращает "object" (историческая особенность языка)
• Для массивов возвращает "object", а не "array"
• Для функций возвращает "function"

2. Оператор instanceof

Проверяет, принадлежит ли объект определенному классу или конструктору в цепочке прототипов.

const arr = [1, 2, 3];
const date = new Date();

console.log(arr instanceof Array);     // true
console.log(arr instanceof Object);    // true (наследование)
console.log(date instanceof Date);     // true
console.log(date instanceof Object);   // true

// Пример с кастомными классами
class Animal {}
class Dog extends Animal {}

const myDog = new Dog();
console.log(myDog instanceof Dog);     // true
console.log(myDog instanceof Animal);  // true
console.log(myDog instanceof Object);  // true

Ограничения:

• Работает только с объектами (не с примитивами)
• Не работает через iframe (разные глобальные контексты)
• Может быть обманчивым при использовании Object.create(null)

3. Метод Object.prototype.toString.call()

Самый надежный способ получения точного типа объекта.

console.log(Object.prototype.toString.call(42));          // "[object Number]"
console.log(Object.prototype.toString.call("text"));      // "[object String]"
console.log(Object.prototype.toString.call(true));        // "[object Boolean]"
console.log(Object.prototype.toString.call(null));        // "[object Null]"
console.log(Object.prototype.toString.call(undefined));   // "[object Undefined]"
console.log(Object.prototype.toString.call([]));          // "[object Array]"
console.log(Object.prototype.toString.call({}));          // "[object Object]"
console.log(Object.prototype.toString.call(new Date()));  // "[object Date]"
console.log(Object.prototype.toString.call(/regex/));     // "[object RegExp]"

Преимущества:

• Корректно определяет null как "[object Null]"
• Отличает массивы от объектов
• Определяет все встроенные типы
• Работает с примитивами и объектами

4. Проверка на Array с помощью Array.isArray()

Специальный метод для точной проверки массивов.

const arr = [1, 2, 3];
const obj = {};

console.log(Array.isArray(arr));  // true
console.log(Array.isArray(obj));  // false
console.log(Array.isArray("[]")); // false

5. Проверка на NaN

Для проверки на NaN используется специальная функция Number.isNaN():

console.log(Number.isNaN(NaN));       // true
console.log(Number.isNaN(42));        // false
console.log(Number.isNaN("text"));    // false (в отличие от isNaN())

6. Проверка null и undefined

Для явной проверки на null и undefined:

const value = null;

console.log(value === null);           // true
console.log(value === undefined);      // false
console.log(value == null);            // true (проверяет и null, и undefined)
console.log(value == undefined);       // true

// Современный подход (ES2020)
console.log(value ?? 'default');       // оператор нулевого слияния

7. Number.isInteger() и Number.isFinite()

Специализированные проверки для чисел:

console.log(Number.isInteger(42));     // true
console.log(Number.isInteger(42.5));   // false
console.log(Number.isFinite(42));      // true
console.log(Number.isFinite(Infinity)); // false

Практические рекомендации

Для повседневного использования:

1. Примитивы → используйте typeof
2. Массивы → Array.isArray()
3. Точный тип объектов → Object.prototype.toString.call()
4. Проверка классов → instanceof
5. null и undefined → строгое сравнение (===)

Пример комбинированного подхода:

function getType(value) {
  if (value === null) return 'null';
  if (value === undefined) return 'undefined';
  
  const type = typeof value;
  if (type !== 'object') return type;
  
  if (Array.isArray(value)) return 'array';
  
  const objectType = Object.prototype.toString.call(value);
  return objectType.slice(8, -1).toLowerCase();
}

// Использование
console.log(getType(null));        // "null"
console.log(getType([1, 2]));      // "array"
console.log(getType(new Date()));  // "date"
console.log(getType(42));          // "number"

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