Как определить тип переменной?

Определение типа переменной в 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 Symbol('id'));        // 'symbol'
console.log(typeof 10n);                 // 'bigint'
console.log(typeof function() {});       // 'function'

Особенность: typeof null возвращает 'object' (это историческая ошибка JavaScript):

console.log(typeof null);                // 'object' — БУГ!

2. instanceof для объектов

Для проверки принадлежности к конкретному классу или конструктору:

const arr = [1, 2, 3];
console.log(arr instanceof Array);       // true
console.log(arr instanceof Object);      // true

const date = new Date();
console.log(date instanceof Date);       // true

const user = { name: 'John' };
console.log(user instanceof Object);     // true
console.log(user instanceof Array);      // false

Особенность: instanceof работает с цепочкой прототипов.

3. Object.prototype.toString.call()

Это наиболее надежный способ для любых типов:

function getType(value) {
  return Object.prototype.toString.call(value).slice(8, -1);
}

console.log(getType(42));                // 'Number'
console.log(getType('hello'));           // 'String'
console.log(getType(true));              // 'Boolean'
console.log(getType([]));                // 'Array'
console.log(getType({}));                // 'Object'
console.log(getType(null));              // 'Null'
console.log(getType(undefined));         // 'Undefined'
console.log(getType(new Date()));        // 'Date'
console.log(getType(/regex/));           // 'RegExp'
console.log(getType(new Map()));         // 'Map'
console.log(getType(new Set()));         // 'Set'

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

Эти значения требуют отдельной проверки:

// Проверка на null
if (value === null) { }

// Проверка на undefined
if (value === undefined) { }
if (typeof value === 'undefined') { }

// Проверка на null ИЛИ undefined
if (value == null) { } // Используй == для обоих
if (!value) { }        // Работает для null, undefined, 0, '', false, NaN

5. Array.isArray() для массивов

Специальная функция для проверки массивов:

console.log(Array.isArray([]));          // true
console.log(Array.isArray('string'));    // false
console.log(Array.isArray({ length: 3 })); // false

Зачем она нужна? Потому что typeof [] вернет 'object', что вводит в заблуждение.

6. Проверка типов в TypeScript

В TypeScript тип проверяется на этапе компиляции:

const value: string | number = 'hello';

if (typeof value === 'string') {
  // TypeScript знает, что value — строка
  value.toUpperCase();
} else {
  // TypeScript знает, что value — число
  value.toFixed(2);
}

Это намного безопаснее и быстрее, чем runtime проверки.

7. Type Guards в TypeScript

Для более сложных проверок используй type guard функции:

function isUser(obj: unknown): obj is User {
  return (
    typeof obj === 'object' &&
    obj !== null &&
    'name' in obj &&
    'email' in obj &&
    typeof obj.name === 'string' &&
    typeof obj.email === 'string'
  );
}

if (isUser(data)) {
  // data — это User
  data.name;
}

Сравнение методов

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

1. Используй TypeScript для compile-time типизации
2. Для runtime проверок используй typeof для примитивов
3. Для объектов используй instanceof или Object.toString.call()
4. Для массивов используй Array.isArray()
5. Для сложных структур пиши type guard функции
6. Избегай typeof null, используй value === null
7. В modern JavaScript используй type annotations вместо runtime проверок где возможно

Понимание типов в JavaScript критически важно для написания надежного кода и отладки неожиданного поведения приложения.