В JavaScript проверка объекта на пустоту – это не просто частая задача, а важный элемент валидации и обработки данных. Объект считается пустым, если в нём нет собственных перечисляемых свойств. Это определение исключает унаследованные свойства и свойства с неперечисляемыми дескрипторами.
Наиболее надёжный способ – использование функции Object.keys(). Она возвращает массив собственных перечисляемых свойств объекта. Если длина этого массива равна нулю, объект можно считать пустым: Object.keys(obj).length === 0. Этот метод игнорирует прототипные свойства, что делает его предпочтительным в большинстве случаев.
Если требуется учесть также символы, стоит применять Object.getOwnPropertySymbols() и объединить результат с Object.keys(). Проверка будет точнее: Object.keys(obj).length === 0 && Object.getOwnPropertySymbols(obj).length === 0. Это особенно актуально при работе с библиотеками или фреймворками, которые могут использовать символы как ключи.
Некорректный подход – использовать сравнение с пустым объектом, например obj === {}. Такой способ всегда возвращает false, так как в JavaScript объекты сравниваются по ссылке, а не по содержимому.
Проверка на пустой объект с помощью метода Object.keys()
Метод Object.keys() возвращает массив собственных перечисляемых свойств объекта. Если массив пуст, объект не содержит ни одного собственного ключа.
const obj = {};
const isEmpty = Object.keys(obj).length === 0;
console.log(isEmpty); // true
- Подходит только для объектов, не содержащих унаследованные свойства.
- Игнорирует свойства с символами в качестве ключей.
- Не работает с
nullиundefined, нужно предварительно проверить тип.
function isObjectEmpty(value) {
return (
value &&
typeof value === 'object' &&
!Array.isArray(value) &&
Object.keys(value).length === 0
);
}
Функция исключает null, массивы и возвращает true только для действительно пустых объектов.
- Не используйте
JSON.stringify(obj) === '{}'– это менее эффективно. - Проверка через
Object.getOwnPropertyNames()охватывает больше типов свойств, но работает аналогично.
Использование метода JSON.stringify() для проверки объекта
Метод JSON.stringify() позволяет преобразовать объект в строку. Если объект пуст, результатом будет строка "{}". Это можно использовать для простой проверки:
JSON.stringify(obj) === "{}"
Проверка подходит для объектов без вложенных свойств, геттеров, символов и нестандартных типов данных. Метод игнорирует свойства с типом undefined, функции и символы. Например, объект {a: undefined, b: () => {}, [Symbol()]: 123} после сериализации станет "{}", хотя не является пустым в полном смысле.
Не используйте JSON.stringify() для проверки массивов и объектов с нестандартной структурой. Также учтите, что при наличии циклических ссылок метод выбросит ошибку. Для надёжной проверки перед сериализацией используйте try/catch:
let isEmpty = false;
try {
isEmpty = JSON.stringify(obj) === "{}";
} catch (e) {
isEmpty = false;
}
Этот подход полезен при быстрой проверке простых объектов, но требует осторожности из-за особенностей сериализации.
Проверка объекта через цикл for.in
Один из прямых способов определить, пуст ли объект – использовать цикл for…in. Этот цикл перебирает перечисляемые свойства объекта, включая унаследованные.
Чтобы исключить ложные срабатывания на унаследованные свойства, необходимо применять метод hasOwnProperty внутри цикла:
function isEmpty(obj) {
for (let key in obj) {
if (obj.hasOwnProperty(key)) {
return false;
}
}
return true;
}
Без проверки hasOwnProperty цикл может вернуть false для объекта без собственных свойств, если его прототип был изменён. Это особенно актуально в случае, когда объект создан не через {}, а, например, через Object.create с нестандартным прототипом.
Метод подходит для среды, где не используются современные функции вроде Object.keys, и нужен контроль над полным перебором свойств. Однако для массивов, функций и других типов объектов лучше использовать другие подходы, так как for...in может вести себя непредсказуемо из-за перечисления нестандартных свойств.
Как проверить объект с помощью метода Object.entries()
Метод Object.entries() возвращает массив пар ключ-значение из переданного объекта. Для проверки объекта на пустоту достаточно оценить длину этого массива.
Пример:
const obj = {};
const isEmpty = Object.entries(obj).length === 0;
console.log(isEmpty); // true
Если объект не содержит собственных перечисляемых свойств, Object.entries() вернёт пустой массив. Это надёжный способ, который учитывает только собственные свойства, игнорируя унаследованные.
При проверке объекта, содержащего вложенные структуры, метод работает только на первом уровне:
const nested = { a: {} };
console.log(Object.entries(nested).length === 0); // false
Значение { a: {} } считается непустым, поскольку у него есть ключ a. Для рекурсивной проверки потребуется дополнительная логика.
Object.entries() – предпочтительный метод для лаконичной и читаемой проверки, особенно в ситуациях, где нужно одновременно получить доступ к ключам и значениям.
Проверка на пустоту через использование метода Object.getOwnPropertyNames()
Метод Object.getOwnPropertyNames(obj) возвращает массив всех собственных перечисляемых и неперечисляемых свойств объекта, включая те, которые недоступны через for…in или Object.keys(). Это делает его полезным в случаях, когда важно учитывать наличие скрытых свойств.
Для проверки объекта на пустоту достаточно сравнить длину возвращаемого массива с нулём:
function isEmpty(obj) {
return Object.getOwnPropertyNames(obj).length === 0;
}
Такой подход особенно эффективен при работе с объектами, в которых свойства могут быть неперечисляемыми, например, созданными с помощью Object.defineProperty() с флагом enumerable: false. Пример:
const obj = {};
Object.defineProperty(obj, 'hidden', {
value: 42,
enumerable: false
});
console.log(Object.getOwnPropertyNames(obj)); // ['hidden']
console.log(Object.keys(obj)); // []
В этом случае Object.keys() не обнаружит свойство, в то время как Object.getOwnPropertyNames() его учтёт. Поэтому, если требуется строго учитывать все собственные свойства объекта, включая неперечисляемые, использование Object.getOwnPropertyNames() предпочтительнее.
Как избежать ошибок при проверке объекта на пустоту
Частая ошибка – считать, что объект пустой, если он не равен null или undefined. Однако даже объект без свойств не равен null. Для надёжной проверки используйте Object.keys(obj).length === 0, предварительно убедившись, что obj действительно объект и не null.
Не используйте JSON.stringify(obj) === '{}' – эта проверка медленнее и ненадёжна, особенно если объект содержит нестандартные свойства, символы или вложенные структуры.
Избегайте прямого сравнения с литералом: obj === {} всегда возвращает false, потому что создаётся новый объект. Вместо этого сравнивайте количество собственных свойств:
function isEmptyObject(obj) {
return obj && typeof obj === 'object' && !Array.isArray(obj) &&
Object.keys(obj).length === 0;
}
Также важно исключить массивы, функции и другие типы:
function isPlainEmptyObject(obj) {
return Object.prototype.toString.call(obj) === '[object Object]' &&
Object.keys(obj).length === 0;
}
Не полагайтесь на for...in – он проходит по унаследованным свойствам. Чтобы избежать этого, используйте Object.hasOwn или Object.prototype.hasOwnProperty.call внутри цикла, если проверка через итерацию необходима.
Загрузка...
