Что возвращает typeof?

typeof оператор: Полное руководство

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

Базовые типы и возвращаемые значения

Оператор typeof возвращает одну из следующих строк:

// 1. undefined — переменная объявлена, но не инициализирована
typeof undefined;        // "undefined"
let x;
typeof x;               // "undefined"

// 2. boolean — логическое значение
typeof true;            // "boolean"
typeof false;           // "boolean"

// 3. number — число (включая NaN и Infinity)
typeof 42;              // "number"
typeof 3.14;            // "number"
typeof NaN;             // "number" (особенность!)
typeof Infinity;        // "number"

// 4. bigint — большое целое число
typeof 123n;            // "bigint"
typeof BigInt(123);     // "bigint"

// 5. string — строка
typeof "hello";         // "string"
typeof `template`;      // "string"

// 6. symbol — уникальный идентификатор
typeof Symbol('id');    // "symbol"

// 7. object — объект (ВСЕ объекты, включая null!)
typeof {};              // "object"
typeof [];              // "object"
typeof null;            // "object" (ошибка в спецификации!)
typeof {};              // "object"
typeof new Date();      // "object"
typeof /regex/;         // "object"

// 8. function — функция
typeof function() {};   // "function"
typeof () => {};        // "function"
typeof class {};        // "function" (класс это функция)

Важные случаи и ловушки

1. null является "object" — это ошибка в JavaScript!

typeof null;            // "object" (НЕПРАВИЛЬНО!)

// Правильный способ проверить null
function isNull(value) {
  return value === null;
}

function isUndefined(value) {
  return value === undefined;
}

console.log(isNull(null));        // true
console.log(isNull(undefined));   // false

2. Массивы являются "object", не "array"

typeof [1, 2, 3];      // "object" (не "array"!)

// Правильная проверка на массив
Array.isArray([1, 2, 3]); // true
Array.isArray({});        // false

// Или через instanceof
[1, 2, 3] instanceof Array; // true

3. NaN имеет тип "number"

typeof NaN;             // "number" (NaN = Not-a-Number, но это число!)

// Правильная проверка на NaN
Number.isNaN(NaN);      // true
isNaN(NaN);             // true (но менее надёжно)

const value = 0 / 0; // NaN
typeof value;         // "number"
Number.isNaN(value);  // true

4. Функции это особый подтип "object"

function myFunc() {}
typeof myFunc;          // "function"

const arrow = () => {};
typeof arrow;           // "function"

class MyClass {}
typeof MyClass;         // "function" (класс это синтаксический сахар)

// Функции это объекты с дополнительными возможностями
typeof myFunc === 'object'; // false
typeof myFunc === 'function'; // true
myFunc instanceof Function;   // true
myFunc instanceof Object;     // true (функции это объекты)

Практические примеры использования

Пример 1: Проверка типов переменных

function processValue(value) {
  if (typeof value === 'string') {
    console.log(`Строка длины ${value.length}`);
  } else if (typeof value === 'number') {
    console.log(`Число: ${value * 2}`);
  } else if (typeof value === 'boolean') {
    console.log(`Логическое значение: ${value}`);
  } else if (typeof value === 'function') {
    console.log("Функция:", value());
  } else if (value === null) {
    console.log("Значение null");
  } else if (typeof value === 'object') {
    console.log("Объект:", Object.keys(value));
  }
}

processValue("hello");          // Строка длины 5
processValue(42);               // Число: 84
processValue(true);             // Логическое значение: true
processValue(() => 'test');     // Функция: test
processValue(null);             // Значение null
processValue({ a: 1, b: 2 });   // Объект: ['a', 'b']

Пример 2: Валидация параметров функции

function divide(a, b) {
  if (typeof a !== 'number' || typeof b !== 'number') {
    throw new TypeError('Оба параметра должны быть числами');
  }
  
  if (b === 0) {
    throw new Error('Деление на ноль!');
  }
  
  return a / b;
}

console.log(divide(10, 2));     // 5
console.log(divide('10', 2));   // Error: Оба параметра должны быть числами

Пример 3: Установка значений по умолчанию

function greet(name, greeting) {
  if (typeof name !== 'string') {
    name = 'Гость';
  }
  
  if (typeof greeting !== 'string') {
    greeting = 'Привет';
  }
  
  return `${greeting}, ${name}!`;
}

console.log(greet('John', 'Привет'));  // Привет, John!
console.log(greet('Jane'));             // Привет, Jane!
console.log(greet(null));               // Привет, Гость!

Пример 4: Определение существует ли переменная

// typeof не выбросит ошибку если переменная не объявлена
if (typeof unknownVariable !== 'undefined') {
  console.log(unknownVariable);
}
// Вывода не будет, нет ошибки

// Без typeof это вызовет ошибку
if (unknownVariable !== undefined) { // ReferenceError!
  console.log(unknownVariable);
}

Пример 5: Проверка API доступности

function useLocalStorage() {
  if (typeof window !== 'undefined' && typeof window.localStorage !== 'undefined') {
    return localStorage;
  }
  return null; // Браузер не поддерживает или это Node.js
}

function useSessionStorage() {
  if (typeof sessionStorage === 'object') {
    return sessionStorage;
  }
  return null;
}

Таблица всех типов

Сравнение различных способов проверки типов

// typeof — быстро, но имеет особенности
const arr = [1, 2, 3];
typeof arr;             // "object" (не полезно для массивов)

// Array.isArray() — специально для массивов
Array.isArray(arr);     // true

// instanceof — проверяет прототипы
arr instanceof Array;   // true
arr instanceof Object;  // true

// Конструктор
arr.constructor === Array; // true

// Object.prototype.toString — самый надёжный способ
Object.prototype.toString.call(arr);  // "[object Array]"
Object.prototype.toString.call({});   // "[object Object]"
Object.prototype.toString.call(null); // "[object Null]"

Лучшая практика: Type Guards

// Функции для проверки типов
function isString(value) {
  return typeof value === 'string';
}

function isNumber(value) {
  return typeof value === 'number' && !Number.isNaN(value);
}

function isBoolean(value) {
  return typeof value === 'boolean';
}

function isArray(value) {
  return Array.isArray(value);
}

function isObject(value) {
  return value !== null && typeof value === 'object' && !Array.isArray(value);
}

function isFunction(value) {
  return typeof value === 'function';
}

function isNull(value) {
  return value === null;
}

function isDefined(value) {
  return typeof value !== 'undefined';
}

// Использование
if (isString(userInput)) {
  process(userInput);
}

Заключение

Оператор typeof возвращает одну из 8 строк: "undefined", "boolean", "number", "bigint", "string", "symbol", "object" или "function". Он полезен для быстрой проверки типов, но имеет некоторые особенности (null как "object", массивы как "object"). Для более специфичных проверок используй Array.isArray(), instanceof или более специализированные функции проверки типов.