Как проверить пустоту объекта в JavaScript: 5 надежных методов

Для кого эта статья:

• Разработчики JavaScript, желающие улучшить свои навыки проверки объектов
• Студенты и начинающие веб-разработчики, обучающиеся программированию

• Опытные программисты, ищущие оптимальные решения для производительности кода

  Проверка пустоты объектов в JavaScript — одна из тех задач, которые кажутся тривиальными, пока не столкнешься с ней в боевых условиях. Достаточно один раз получить неожиданное поведение из-за неверной проверки, и ты начинаешь задумываться: "А действительно ли я правильно проверяю объект на пустоту?" 🤔 Между {}, null, undefined и объектом с унаследованными свойствами разница огромна, и выбор подходящего метода проверки может существенно повлиять как на читаемость кода, так и на производительность всего приложения.

Хотите уверенно писать код на JavaScript и избегать распространенных ошибок? На курсе Обучение веб-разработке от Skypro вы изучите не только базовые концепции, но и глубоко погрузитесь в тонкости работы с объектами, массивами и асинхронным кодом. Вместо поверхностных знаний вы получите практические навыки и научитесь писать эффективный, оптимизированный код, который работает именно так, как нужно.

Что такое пустой объект в JavaScript и зачем его проверять

В JavaScript пустым объектом обычно считается объект, который не содержит собственных перечисляемых свойств. Это может быть результат явного создания объекта через литерал {} или через конструктор new Object().

Проверка на пустоту объекта необходима в целом ряде сценариев:

• Валидация пользовательского ввода перед отправкой на сервер
• Обработка ответов API, когда пустой объект может сигнализировать об отсутствии данных
• Проверка состояния кэша или хранилища
• Предотвращение выполнения операций над пустыми данными
• Принятие решений в бизнес-логике, когда наличие или отсутствие свойств критично

Важно понимать разницу между пустым объектом и отсутствием объекта (null или undefined). Пустой объект всё же является полноценным объектом со всеми доступными методами прототипа, в то время как null или undefined таковыми не являются. Именно поэтому надежная проверка должна учитывать эти нюансы.

Алексей, ведущий frontend-разработчик Однажды наша команда столкнулась с загадочным багом. Пользователи жаловались, что фильтры в нашем приложении работают некорректно. Несколько дней мы искали проблему, пока не обнаружили, что функция очистки фильтров возвращала объект { __proto__: { someMethod: function() {} } } вместо действительно пустого объекта. Мы использовали простую проверку Object.keys(filters).length === 0, которая корректно определяла этот объект как пустой. Но код, отвечающий за применение фильтров, неявно перебирал все свойства, включая унаследованные, через цикл for...in. Это приводило к тому, что метод прототипа влиял на логику фильтрации. После этого случая мы разработали стандарт проверки объектов, учитывающий контекст использования — для перечисления только собственных свойств мы используем Object.keys() или Object.hasOwn(), а для проверки абсолютной пустоты, включая прототип, — более сложные комбинации методов.

5 методов проверки объекта на пустоту: основные решения

Существует несколько способов проверки объекта на пустоту, каждый из которых имеет свои особенности. Рассмотрим пять наиболее распространенных и надежных методов:

Теперь рассмотрим каждый из этих методов подробнее:

1. Object.keys() Этот метод возвращает массив собственных перечисляемых свойств объекта:

const isEmpty = obj => Object.keys(obj).length === 0;

console.log(isEmpty({})); // true
console.log(isEmpty({ a: 1 })); // false

2. JSON.stringify() Преобразование объекта в JSON-строку и сравнение с литералом пустого объекта:

const isEmpty = obj => JSON.stringify(obj) === '{}';

console.log(isEmpty({})); // true
console.log(isEmpty({ a: undefined })); // true (!) undefined значения пропускаются

3. Цикл for...in с ранним возвратом Этот метод перебирает все перечисляемые свойства объекта, включая унаследованные:

function isEmpty(obj) {
for (let key in obj) {
if (Object.prototype.hasOwnProperty.call(obj, key)) {
return false;
}
}
return true;
}

console.log(isEmpty({})); // true
console.log(isEmpty(Object.create({ a: 1 }))); // true (игнорирует унаследованные свойства)

4. Object.entries() Возвращает массив пар [ключ, значение] собственных перечисляемых свойств:

const isEmpty = obj => Object.entries(obj).length === 0;

console.log(isEmpty({})); // true
console.log(isEmpty({ a: 1 })); // false

5. Object.getOwnPropertyNames() В отличие от Object.keys(), этот метод включает и неперечисляемые свойства:

const isEmpty = obj => Object.getOwnPropertyNames(obj).length === 0;

const obj = Object.create({}, { 
a: { value: 1, enumerable: false } 
});

console.log(Object.keys(obj).length === 0); // true (свойство неперечисляемое)
console.log(isEmpty(obj)); // false (обнаруживает неперечисляемые свойства)

Преимущества и недостатки каждого способа проверки

Каждый метод проверки имеет свои сильные и слабые стороны. Давайте проанализируем их детальнее:

1. Object.keys()

• Преимущества:
• Высокая производительность
• Читаемый, идиоматичный код
• Игнорирует свойства прототипа

• Поддерживается во всех современных браузерах

• Недостатки:
• Не обнаруживает неперечисляемые свойства
• Не работает для примитивов (требуется проверка на объект)

2. JSON.stringify()

• Преимущества:
• Лаконичный синтаксис

• Не требует дополнительных проверок для примитивов

• Недостатки:
• Значительно медленнее других методов
• Пропускает свойства со значением undefined
• Не обрабатывает объекты с циклическими ссылками
• Может давать неожиданные результаты для объектов с методами или специальными типами данных

3. Цикл for...in

• Преимущества:
• Гибкость в настройке логики проверки
• Возможность раннего выхода из цикла при обнаружении свойства

• Работает в устаревших браузерах

• Недостатки:
• Перебирает унаследованные свойства (требуется дополнительная проверка)
• Более многословный синтаксис
• Потенциально медленнее при проверке действительно пустых объектов

4. Object.entries()

• Преимущества:
• Современный и читаемый синтаксис
• Игнорирует унаследованные свойства

• Возможность использования в функциональном программировании

• Недостатки:
• Немного менее производительный, чем Object.keys()
• Не поддерживается в IE без полифилла
• Не обнаруживает неперечисляемые свойства

5. Object.getOwnPropertyNames()

• Преимущества:
• Обнаруживает все собственные свойства, включая неперечисляемые

• Подходит для глубокого анализа объектов

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

Михаил, тимлид фронтенд-команды Проверка на пустоту объектов обернулась для нас критическим инцидентом в продакшене. У нас было несколько микросервисов, и один из них начал возвращать пустые объекты вместо данных. Фронтенд должен был корректно обрабатывать это состояние. Для проверки использовался метод JSON.stringify(obj) === '{}', который казался простым и надежным. Однако сервис начал возвращать объекты с методами и значениями undefined, что приводило к неверной обработке. Мы быстро переписали код на Object.keys(obj).length === 0, что сразу решило проблему. Более того, метрики показали улучшение производительности критической страницы на 12%. С тех пор у нас есть правило: никогда не использовать JSON.stringify() для проверки структуры объектов, только для сериализации.

Сравнение производительности методов для пустых объектов

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

Ключевые выводы из результатов бенчмарков:

• Object.keys().length === 0 оказывается наиболее быстрым методом для проверки пустых объектов
• JSON.stringify() значительно медленнее остальных методов — почти в 4.4 раза медленнее базового метода
• Производительность Object.getOwnPropertyNames() близка к Object.keys(), что делает его хорошей альтернативой, когда необходимо учитывать неперечисляемые свойства
• Метод с использованием цикла for...in медленнее из-за необходимости проверки собственных свойств через hasOwnProperty

Однако важно помнить, что производительность — не единственный критерий выбора. Для большинства приложений разница в несколько миллисекунд на тысячу операций не будет заметна. Гораздо важнее выбрать метод, который правильно отражает ваше определение "пустого объекта" в конкретном контексте. 🚀

Также стоит учитывать, что производительность методов может отличаться в зависимости от:

• Версии JavaScript-движка
• Браузера или среды выполнения
• Размеры и структуры проверяемых объектов
• Наличия неперечисляемых свойств или прототипного наследования

Практические рекомендации по выбору оптимального метода

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

📊 В большинстве случаев: Object.keys()

const isEmpty = obj => obj && typeof obj === 'object' && Object.keys(obj).length === 0;

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

🔍 Когда важны неперечисляемые свойства: Object.getOwnPropertyNames()

const isCompletelyEmpty = obj => 
obj && typeof obj === 'object' && 
Object.getOwnPropertyNames(obj).length === 0;

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

⚠️ Для работы с наследованием: Комбинированный подход

function isEmptyWithoutInheritance(obj) {
if (!obj || typeof obj !== 'object') return false;

// Проверяем собственные перечисляемые свойства
if (Object.keys(obj).length > 0) return false;

// Проверяем, был ли объект создан без прототипа
return Object.getPrototypeOf(obj) === Object.prototype;
}

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

🚀 Для максимальной производительности в критических участках кода:

const isEmptyFast = obj => {
// Быстрая проверка на null/undefined
if (obj == null) return false;

// Для объектов используем быстрый метод
return Object.keys(obj).length === 0;
};

// Использование
if (isEmptyFast(criticalDataObject)) {
// Обработка пустого объекта
}

Этот вариант оптимизирован для частого использования в производительно-критичном коде.

🧪 При работе с нестандартными объектами (Map, Set):

function isEmpty(collection) {
if (collection == null) return false;

if (collection instanceof Map || collection instanceof Set) {
return collection.size === 0;
}

if (typeof collection === 'object') {
return Object.keys(collection).length === 0;
}

return false;
}

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

Общие рекомендации при проверке объектов на пустоту:

• Избегайте JSON.stringify() для проверки структуры объектов из-за низкой производительности и побочных эффектов
• Всегда учитывайте null и undefined в своих проверках, если объект может иметь такие значения
• Документируйте свое определение "пустоты" для команды, особенно если оно отличается от стандартного
• Используйте абстракцию — создайте единую функцию проверки и используйте ее последовательно во всем проекте
• Учитывайте контекст использования — для валидации форм и для обработки данных API могут потребоваться разные определения пустоты

И помните: выбор метода проверки — это компромисс между производительностью, читаемостью и точностью определения пустоты в контексте вашей задачи. 💡

В мире JavaScript проверка на пустой объект — это искусство баланса между точностью, производительностью и читаемостью кода. Object.keys() остается золотым стандартом для большинства сценариев, а специализированные методы следует применять только при наличии особых требований. Внедрите единый подход к проверке объектов в своей кодовой базе, и вы избавите себя от многих потенциальных ошибок и непредсказуемого поведения в будущем. Помните: код, который корректно обрабатывает крайние случаи, — признак профессионального разработчика.