undefined или null в JavaScript: как проверить переменную в 2025

«Переменная не определена»: почему этот вопрос мучает всех?

Если вы хоть раз писали на JavaScript, вы точно сталкивались с ситуацией: запускаете код, а в консоли — красная надпись Uncaught TypeError: Cannot read properties of undefined. Или ещё хуже — null is not an object. Знакомо? Это одна из самых частых ошибок, которая преследует разработчиков всех уровней.

Вопрос «How can I determine if a variable is 'undefined' or 'null'?» на Stack Overflow собрал тысячи просмотров и сотни ответов. И это неспроста: в JavaScript эти два значения похожи, но ведут себя по-разному. В 2025 году, когда код становится сложнее, а проекты — масштабнее, умение правильно проверять undefined и null превращается из «хорошо бы знать» в «обязательно уметь».

В этой статье мы разберём все способы проверки, от простых до продвинутых, и покажем, какие методы стоит использовать в современной разработке. Поехали!

undefined vs null: в чём разница?

Прежде чем проверять, давайте разберёмся, с чем мы имеем дело. В JavaScript undefined и null — это два разных примитивных значения, каждое со своим типом.

undefined

undefined — это значение, которое присваивается переменной автоматически, если вы объявили её, но не задали значение. Также функция возвращает undefined, если в ней нет явного return.

let myVar;
console.log(myVar); // undefined

function doNothing() {}
console.log(doNothing()); // undefined

console.log(someNonExistentVariable); // ReferenceError, но если обратиться к свойству объекта:
const obj = {};
console.log(obj.prop); // undefined

null

null — это значение, которое разработчик присваивает намеренно. Оно означает «пусто», «ничего», «значение отсутствует». null — это объект с точки зрения typeof (да, это исторический баг, но он уже стал фичей).

let myVar = null;
console.log(myVar); // null
console.log(typeof myVar); // "object" — да, это так!

Главное отличие: undefined — это «ещё не назначено», а null — «намеренно пусто». Но при нестрогом сравнении они равны:

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

Именно из-за этого нестрогого равенства возникает путаница. Поэтому лучшие практики 2025 года рекомендуют использовать строгое сравнение (===).

Топ-5 способов проверить undefined и null

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

1. Строгое сравнение (===) — золотой стандарт

Самый прямой и понятный способ — сравнить переменную напрямую с undefined или null через ===.

let value = null;

// Проверка на null
if (value === null) {
    console.log('Это null');
}

// Проверка на undefined
if (value === undefined) {
    console.log('Это undefined');
}

// Проверка на null ИЛИ undefined (по отдельности)
if (value === null || value === undefined) {
    console.log('Значение отсутствует');
}

Почему это лучшая практика?

• Максимально читаемо — любой разработчик поймёт, что вы проверяете.
• Нет неожиданных приведений типов.
• Работает во всех версиях JavaScript, включая самые старые.

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

2. Оператор нулевого слияния (??) — новинка, которая прижилась

Начиная с ES2020, в JavaScript появился оператор ?? (nullish coalescing operator). Он проверяет, является ли значение null или undefined, и если да — возвращает правый операнд.

let name = null;
let displayName = name ?? 'Гость';
console.log(displayName); // 'Гость'

let age = 0;
let displayAge = age ?? 25;
console.log(displayAge); // 0 — потому что 0 не является null/undefined

Обратите внимание: ?? работает только с null и undefined. В отличие от ||, он не сработает на 0, '' или false. Это очень удобно, если вам нужно установить значение по умолчанию только для «пустых» переменных.

Как использовать для проверки?

function greet(user) {
    // Если user — null или undefined, используем 'Гость'
    const name = user ?? 'Гость';
    console.log(`Привет, ${name}!`);
}

greet(null); // Привет, Гость!
greet('Анна'); // Привет, Анна!

3. Оператор опциональной цепочки (?.) — защита от ошибок

Ещё один подарок ES2020 — опциональная цепочка. Она позволяет безопасно обращаться к свойствам объектов, которые могут быть null или undefined.

const user = {
    profile: null
};

// Без опциональной цепочки — ошибка!
// console.log(user.profile.name); // TypeError

// С опциональной цепочкой — безопасно
console.log(user.profile?.name); // undefined

Это не совсем «проверка на null/undefined» в чистом виде, но это способ избежать ошибок при работе с потенциально пустыми значениями. В 2025 году это must-have для любого разработчика.

4. typeof — когда переменная может быть не объявлена

Если вы не уверены, объявлена ли переменная вообще (например, при работе с глобальными объектами или сторонними скриптами), используйте typeof. Он никогда не выбрасывает ошибку, даже если переменная не существует.

// Проверка на undefined через typeof
if (typeof someGlobalVar === 'undefined') {
    console.log('Переменная не существует или undefined');
}

// А вот так — получите ReferenceError!
// if (someGlobalVar === undefined) { ... }

Важно: typeof null возвращает 'object', поэтому для проверки на null этот метод не подходит. Используйте его только для undefined.

5. Функция-помощник — для частых проверок

Если в вашем коде постоянно встречаются проверки на null/undefined, вынесите их в отдельную функцию. Это улучшит читаемость и уменьшит дублирование.

function isNil(value) {
    return value === null || value === undefined;
}

// Использование
if (isNil(someValue)) {
    console.log('Значение отсутствует');
}

// Или ещё проще — стрелочная функция
const isNil = (v) => v