После запроса AJAX иногда мое приложение может возвращать пустой объект, например:
var a = {};
Как я могу проверить, является ли это случай?
// because Object.keys(new Date()).length === 0;
// we have to do some additional check
Object.entries(obj).length === 0 && obj.constructor === Object
// because Object.keys(new Date()).length === 0;
// we have to do some additional check
Object.keys(obj).length === 0 && obj.constructor === Object
Pre-ECMA 5:
function isEmpty(obj) {
for(var prop in obj) {
if(obj.hasOwnProperty(prop))
return false;
}
return JSON.stringify(obj) === JSON.stringify({});
}
jQuery.isEmptyObject({}); // true
_.isEmpty({}); // true
_.isEmpty({}); // true
Hoek.deepEqual({}, {}); // true
Ext.Object.isEmpty({}); // true
angular.equals({}, {}); // true
R.isEmpty({}); // true
Object.keys(...).length
действительно проверяет, что объект пуст, но возвращаемое значение 0
не является исключительным для пустых объектов {}
; он также возвращает 0
для []
, ""
, 0
, 1
, function(){}
, и я уверен, что есть еще больше примеров.
var data = {}; Object.keys(data).length;
хотя data = {"a": []}
возвращает 1, что звучит правильно. Лучше всего при работе с вызовами REST
, когда ответ REST может обрабатываться на data = {"success": "lorem ipsum"}
противном случае используйте data = {"success": "lorem ipsum"}
или data = {"error": "lorem ipsum"}
.
Там нет простого способа сделать это. Вы должны будете явно перекрыть свойства:
function isEmpty(obj) {
for(var prop in obj) {
if(obj.hasOwnProperty(prop))
return false;
}
return true;
}
Если доступна поддержка ECMAScript 5, вы можете вместо этого использовать Object.keys()
:
function isEmpty(obj) {
return Object.keys(obj).length === 0;
}
Для тех из вас, кто имеет ту же проблему, но использует jQuery, вы можете использовать jQuery.isEmptyObject.
Это мое предпочтительное решение:
var obj = {};
return Object.keys(obj).length; //returns 0 if empty or an integer > 0 if non-empty
Вы можете использовать Underscore.js.
_.isEmpty({}); // true
if(Object.getOwnPropertyNames(obj).length === 0){
//is empty
}
см. http://bencollier.net/2011/04/javascript-is-an-object-empty/
Как насчет использования JSON.stringify? Он доступен почти во всех современных браузерах.
function isEmptyObject(obj){
return JSON.stringify(obj) === '{}';
}
Старый вопрос, но у него была проблема. Включение JQuery на самом деле не является хорошей идеей, если ваша единственная цель - проверить, не объект ли пуст. Вместо этого, просто в код JQuery, и вы получите ответ:
function isEmptyObject(obj) {
var name;
for (name in obj) {
if (obj.hasOwnProperty(name)) {
return false;
}
}
return true;
}
Я столкнулся с подобной ситуацией. Я не хотел использовать JQuery и хотел сделать это, используя чистый Javascript.
И что я сделал, использовал следующее условие, и это сработало для меня.
var obj = {};
if(JSON.stringify(obj) === '{}') { //This will check if the object is empty
//Code here..
}
Для не равных, используйте это: JSON.stringify(obj) !== '{}'
Посмотрите JSFiddle
Существует простой способ, если вы находитесь в более новом браузере.
Object.keys(obj).length == 0
keys
?
Я создал полную функцию, чтобы определить, является ли объект пустым.
Он использует функциональные возможности Object.keys
из ECMAScript 5 (ES5), если это возможно, для достижения максимальной производительности (см. Таблицу совместимости) и откат к наиболее совместимому подходу для более старых механизмов (браузеров).
/**
* Returns true if specified object has no properties,
* false otherwise.
*
* @param {object} object
* @returns {boolean}
*/
function isObjectEmpty(object)
{
if ('object' !== typeof object) {
throw new Error('Object must be specified.');
}
if (null === object) {
return true;
}
if ('undefined' !== Object.keys) {
// Using ECMAScript 5 feature.
return (0 === Object.keys(object).length);
} else {
// Using legacy compatibility mode.
for (var key in object) {
if (object.hasOwnProperty(key)) {
return false;
}
}
return true;
}
}
Вот суть этого кода.
А вот и JSFiddle с демонстрацией и простым тестом.
Надеюсь, это кому-нибудь поможет. Ура!
null
объекта.
Вы можете проверить количество клавиш Object:
if (Object.keys(a).length > 0) {
// not empty
}
Просто обходной путь. Может ли ваш сервер генерировать какое-то особое свойство в случае отсутствия данных?
Например:
var a = {empty:true};
Затем вы можете легко проверить его в коде обратного вызова AJAX.
Еще один способ проверить:
if (a.toSource() === "({})") // then 'a' is empty
ИЗМЕНИТЬ: Если вы используете какую-либо библиотеку JSON (например, JSON.js), вы можете попробовать функцию JSON.encode() и проверить результат на пустую строку значений.
toSource()
является стандартным и не работает в IE или Opera (и, возможно, в других браузерах, которые я не проверял)
Использование Object.keys(obj).length(как было предложено выше для ECMA 5+) в 10 раз медленнее для пустых объектов! придерживайтесь опции старой школы (для... in).
Протестировано под Node, Chrom, Firefox и IE 9, становится очевидным, что для большинства случаев использования:
Эффект нижней линии, используйте:
function isEmpty(obj) {
for (var x in obj) { return false; }
return true;
}
или
function isEmpty(obj) {
for (var x in obj) { if (obj.hasOwnProperty(x)) return false; }
return true;
}
См. подробные результаты тестирования и тестовый код на Является ли объект пустым?
Я использую это.
function isObjectEmpty(object)
{
var isEmpty = true;
for(keys in object)
{
isEmpty = false;
break; // exiting since we found that the object is not empty
}
return isEmpty;
}
Например:
var myObject = {}; // Object is empty
var isEmpty = isObjectEmpty(myObject); // will return true;
// populating the object
myObject = {"name":"John Smith","Address":"Kochi, Kerala"};
// check if the object is empty
isEmpty = isObjectEmpty(myObject); // will return false;
Обновление
ИЛИ
вы можете использовать реализацию jQuery isEmptyObject
function isEmptyObject ( obj ) {
var name;
for ( name in obj ) {
return false;
}
return true;
}
В следующем примере показано, как проверить, является ли объект JavaScript пустым, если пустым мы не имеем никаких собственных свойств.
Скрипт работает на ES6.
const isEmpty = (obj) => {
if (obj === null ||
obj === undefined ||
Array.isArray(obj) ||
typeof obj !== 'object'
) {
return true;
}
return Object.getOwnPropertyNames(obj).length === 0;
};
console.clear();
console.log('-----');
console.log(isEmpty('')); // true
console.log(isEmpty(33)); // true
console.log(isEmpty([])); // true
console.log(isEmpty({})); // true
console.log(isEmpty({ length: 0, custom_property: [] })); // false
console.log('-----');
console.log(isEmpty('Hello')); // true
console.log(isEmpty([1, 2, 3])); // true
console.log(isEmpty({ test: 1 })); // false
console.log(isEmpty({ length: 3, custom_property: [1, 2, 3] })); // false
console.log('-----');
console.log(isEmpty(new Date())); // true
console.log(isEmpty(Infinity)); // true
console.log(isEmpty(null)); // true
console.log(isEmpty(undefined)); // true
function isEmpty(obj) {
for(var i in obj) { return false; }
return true;
}
Object
с помощью метода через цепочку прототипов, потому что это перечислимо, а оператор for in
проходит через перечисляемые свойства.
Лучший способ, которым я нашел:
function isEmpty(obj)
{
if (!obj)
{
return true;
}
if (!(typeof(obj) === 'number') && !Object.keys(obj).length)
{
return true;
}
return false;
}
Работает для:
t1: {} -> true
t2: {0:1} -: false
t3: [] -> true
t4: [2] -> false
t5: null -> true
t6: undefined -> true
t7: "" -> true
t8: "a" -> false
t9: 0 -> true
t10: 1 -> false
if (!obj && obj !== 0)
.
вы можете использовать этот простой код, который не использовал jQuery или другие библиотеки
var a=({});
//check is an empty object
if(JSON.stringify(a)=='{}') {
alert('it is empty');
} else {
alert('it is not empty');
}
Класс JSON и его функции (parse и stringify) очень полезны, но есть некоторые проблемы с IE7, которые вы можете исправить с помощью этого простой код http://www.json.org/js.html.
Другой простой способ (простейший способ):
вы можете использовать этот способ без использования jQuery или объекта JSON.
var a=({});
function isEmptyObject(obj) {
if(typeof obj!='object') {
//it is not object, so is not empty
return false;
} else {
var x,i=0;
for(x in obj) {
i++;
}
if(i>0) {
//this object has some properties or methods
return false;
} else {
//this object has not any property or method
return true;
}
}
}
alert(isEmptyObject(a)); //true is alerted
JSON.stringify
неудачно, если объект содержит не строковые свойства, такие как функции или «неопределенные», хотя это и является крайним случаем.
jQuery имеет специальную функцию isEmptyObject()
для этого случая:
jQuery.isEmptyObject({}) // true
jQuery.isEmptyObject({ foo: "bar" }) // false
Подробнее о http://api.jquery.com/jQuery.isEmptyObject/
Я бы пошел для проверки, если у него есть хотя бы один ключ. Этого было бы достаточно, чтобы сказать мне, что он не пустой.
typeof obj !== "undefined" && Boolean(Object.keys(obj)[0])
false
значение? результат будет false
что неверно.
Если jQuery и веб-браузер недоступны, в underscore.js также есть функция isEmpty.
_.isEmpty({}) // returns true
Кроме того, он не предполагает, что входным параметром является объект. Для списка или строки или undefined он также вернет правильный ответ.
Мой прием:
function isEmpty(obj) {
return !Object.keys(obj).length > 0;
}
var a = {a:1, b:2}
var b = {}
console.log(isEmpty(a)); // false
console.log(isEmpty(b)); // true
Просто, я не думаю, что все браузеры реализуют Object.keys()
в настоящее время.
Object.keys(new Date()).length === 0
; поэтому этот ответ может вводить в заблуждение.
Согласно спецификации ES2017 для Object.entries(), проверка проста с использованием любого современного browser--
Object.entries({}).length === 0
Object.keys
или Object.values
?
Правильный ответ:
const isEmptyObject = obj =>
Object.getOwnPropertyNames(obj).length === 0 &&
Object.getOwnPropertySymbols(obj).length === 0 &&
Object.getPrototypeOf(obj) === Object.prototype;
Это проверяет, что:
Object.prototype
. Другими словами, объект неотличим от объекта, созданного с помощью {}
.
Простая петля:
var is_empty = true;
for(var i in obj) {
is_empty = false;
break;
}
Протест! Остерегайтесь ограничений JSON.
javascript:
obj={ f:function(){} };
alert( "Beware!! obj is NOT empty!\n\nobj = { f:function(){} }" +
"\n\nJSON.stringify( obj )\n\nreturns\n\n" +
JSON.stringify( obj ) );
отображает
Beware!! obj is NOT empty! obj = { f:function(){} } JSON.stringify( obj ) returns {}
Sugar.JS предоставляет расширенные объекты для этой цели. Код чист и прост:
Сделайте расширенный объект:
a = Object.extended({})
Проверьте размер:
a.size()
В дополнение к ответу Thevs:
var o = {};
alert($.toJSON(o)=='{}'); // true
var o = {a:1};
alert($.toJSON(o)=='{}'); // false
it jquery + jquery.json
$.isEmptyObject()
, не тратьте циклы с неочевидными конверсиями.
Другой альтернативой является использование is.js (14kB) в отличие от jquery (32kB), lodash (50kB) или underscore (16.4kB). is.js оказалась самой быстрой библиотекой среди вышеупомянутых библиотек, которая может быть использована для определения того, пустой объект.
http://jsperf.com/check-empty-object-using-libraries
Очевидно, что все эти библиотеки не совсем одинаковы, поэтому, если вам нужно легко манипулировать DOM, тогда jquery все равно может быть хорошим выбор или если вам нужно больше, чем просто проверка типа, тогда lodash или underscore может быть хорошо. Что касается is.js, вот синтаксис:
var a = {};
is.empty(a); // true
is.empty({"hello": "world"}) // false
Подобно подчеркиванию и lodash _.isObject()
, это относится не только к objects
, но также относится к arrays
и strings
.
Под капотом эта библиотека использует Object.getOwnPropertyNames
, которая похожа на Object.keys
, но Object.getOwnPropertyNames
является более тщательной, так как она вернет перечислимые и неперечислимые свойства, как описано здесь.
is.empty = function(value) {
if(is.object(value)){
var num = Object.getOwnPropertyNames(value).length;
if(num === 0 || (num === 1 && is.array(value)) || (num === 2 && is.arguments(value))){
return true;
}
return false;
} else {
return value === '';
}
};
Если вы не хотите вводить библиотеку (это понятно), и вы знаете, что вы проверяете объекты (а не массивы или строки), то следующая функция должна соответствовать вашим потребностям.
function isEmptyObject( obj ) {
return Object.getOwnPropertyNames(obj).length === 0;
}
Это немного быстрее, чем is.js, но только потому, что вы не проверяете, является ли это объектом.
Я не могу поверить, что через два года программирования js он никогда не щелкнул, что пустые объекты и массив не являются ложными, самое странное, что это никогда меня не поймало.
это вернет true
, если вход по умолчанию ложный или пустой объект или массив. обратная функция trueish
http://codepen.io/synthet1c/pen/pjmoWL
function falsish( obj ){
if( (typeof obj === 'number' && obj > 0) || obj === true ){
return false;
}
return !!obj
? !Object.keys( obj ).length
: true;
}
function trueish( obj ){
return !falsish( obj );
}
falsish({}) //=> true
falsish({foo:'bar'}) //=> false
falsish([]) //=> true
falsish(['foo']) //=> false
falsish(false) //=> true
falsish(true) //=> false
// the rest are on codepen
([[]])
isEmpty = function(obj) {
if (obj == null) return true;
if (obj.constructor.name == "Array" || obj.constructor.name == "String") return obj.length === 0;
for (var key in obj) if (isEmpty(obj[key])) return true;
return false;
}
Это проверит пустоту String, Array или Object (Карты).
Использование:
var a = {"a":"xxx","b":[1],"c":{"c_a":""}}
isEmpty(a); // true, because a.c.c_a is empty.
isEmpty("I am a String"); //false
этот один код строки помогает
var a = {}; //if empty returns false
(Object.getOwnPropertyNames != undefined ? Object.getOwnPropertyNames(a).length != 0 : (function(){for(var key in a) break; return (key != null) && (key != undefined);})()) //Returns False
var a = {b:2} //if not empty returns true
(Object.getOwnPropertyNames != undefined ? Object.getOwnPropertyNames(a).length != 0 : (function(){for(var key in a) break; return (key != null) && (key != undefined);})()) //Returns true
Object.getOwnPropertyNames реализовано в ECMA-5. приведенная выше строка работает в более старых браузерах с резервной функцией.
Между тем у нас может быть одна функция, которая проверяет все "пустые", как null, undefined, '', '', {}, [].
var isEmpty = function(data) {
if(typeof(data) === 'object'){
if(JSON.stringify(data) === '{}' || JSON.stringify(data) === '[]'){
return true;
}else if(!data){
return true;
}
return false;
}else if(typeof(data) === 'string'){
if(!data.trim()){
return true;
}
return false;
}else if(typeof(data) === 'undefined'){
return true;
}else{
return false;
}
}
Используйте случаи и результаты.
console.log(isEmpty()); // true
console.log(isEmpty(null)); // true
console.log(isEmpty('')); // true
console.log(isEmpty(' ')); // true
console.log(isEmpty(undefined)); // true
console.log(isEmpty({})); // true
console.log(isEmpty([])); // true
console.log(isEmpty(0)); // false
console.log(isEmpty('Hey')); // false
Object.keys()
Попробуйте Destructuring
const a = {};
const { b } = a;
const emptryOrNot = (b) ? 'not Empty' : 'empty';
console.log(emptryOrNot)
a
Под капотом все пустые методы проверки во всех библиотеках используют логику проверки ключей объекта. Это странный способ сделать его понятным, который вы можете поместить в метод, описанный здесь.
for(key in obj){
//your work here.
break;
}
Разработанный в ES5, проще говоря, вы можете проверить длину ключей объекта, используя метод Object.Keys
который принимает ваш объект в качестве параметра:
if(Object.keys(obj).length > 0){
//do your work here
}
Или если вы используете Lodash (вы должны быть) тогда.
_.isEmpty(obj) //==true or false
Это то, что я придумал, чтобы определить, есть ли в объекте какие-либо ненулевые значения.
function isEmpty(obj: Object): Boolean {
for (const prop in obj) {
if (obj.hasOwnProperty(prop)) {
if (obj[prop] instanceof Object) {
const rtn = this.isEmpty(obj[prop]);
if (rtn === false) {
return false;
}
} else if (obj[prop] || obj[prop] === false) {
return false;
}
}
}
return true;
}
Странно, я не вижу здесь сравнения значений (может быть, пропустил так много решений). Я хотел бы рассмотреть случай, когда объект считается пустым, если все его значения не определены:
const isObjectEmpty = ( obj ) => Object.values( obj ).every( val => typeof val === "undefined" );
isObjectEmpty({ foo: undefined, bar: undefined }): // true
isObjectEmpty({ foo: false, bar: null }): // false
Таким образом, мы можем расширить, допустим, объекты options только тогда, когда предоставлены подпараметры
function onSubmit({ fullPage, width, height }) {
const baseOptions = { fullPage },
clip = { width, height },
options = isObjectEmpty( clip ) ? baseOptions : { ...baseOptions, clip };
//...
}
Вы также можете использовать этот object-empty компонент с открытым исходным кодом, чтобы определить, является ли ссылка obj
пустой.
Примеры:
empty([]) // => true
empty({}) // => true
empty(1) // => false
empty('') // => false
empty('foo') // => true
Вы также можете использовать этот пакет NPM.
Вы можете определить свой собственный прототип объекта непосредственно перед его использованием или в начале вашего кода.
Определение должно выглядеть так:
Object.prototype.hasOwnProperties = function()
{
for (var k in this)
{
if ( this.hasOwnProperty(k) )
{
return true;
}
}
return false;
}
Вот пример использования:
var a = {};
while ( a.status !== "finished" )
{
if ( status === "processing" )
{
a.status = "finished";
}
if ( status === "starting" )
{
a.status = "processing";
}
if ( !a.hasOwnProperties() )
{
a.status = "starting";
}
}
Наслаждайтесь!: -)
Я возвращал пустой ответ JSON для вызова AJAX, а в IE8 jQuery.isEmptyObject() корректно не проверялся. Я добавил дополнительную проверку, которая кажется улавливает ее должным образом.
.done(function(data)
{
// Parse json response object
var response = jQuery.parseJSON(data);
// In IE 8 isEmptyObject doesn't catch the empty response, so adding additional undefined check
if(jQuery.isEmptyObject(response) || response.length === 0)
{
//empty
}
else
{
//not empty
}
});
В jQuery 1.4 isEmptyObject()
метод проверяет как свойства самого объекта, так и свойства, унаследованные от прототипов (в том, что он не использует hasOwnProperty). Аргумент всегда должен быть простым JavaScript-объектом, поскольку другие типы объектов (элементы DOM, примитивные строки/числа, объекты-хосты) могут не давать согласованных результатов в браузерах. Чтобы определить, является ли объект обычным JavaScript-объектом, используйте $.isPlainObject()
.
jQuery.isPlainObject({}) // true
jQuery.isPlainObject( "test" ) // false
У меня есть легкое (но не общее) решение для этого сценария:
если вы знаете конкретное имя свойства для своего объекта, вы можете легко проверить, существует ли это свойство. Таким образом, вы знаете, что этот объект пуст или нет, и вам не нужно будет проходить все свойства или использовать библиотеку.
Позвольте мне привести пример: есть объект, который, если его не пусто, должен иметь свойство с именем "myProperty". Затем вы можете проверить его как:
if(myObject['myProperty']){
alert("NOT EMPTY");
}else{
alert("EMPTY")
}
это не общее решение, но оно делает все, что мне нужно на самом деле, так как большинство раз я знаю, чего ожидать в объекте, который выполняет пустую проверку.
Добавлена версия isEmpty() для прототипа объекта:
// As a prototype:
Object.prototype.isEmpty = function() {
for(var i in this)
return false;
return true;
}
// As a function
function objectIsEmpty(obj) {
for (var i in obj) return false;
return true;
}
var obj = {};
if (obj.isEmpty()) console.log('empty');
if (objectIsEmpty(obj)) console.log('empty');
Object.hasOwnProperty
, эта функция всегда будет возвращать true
(функция называется isEmpty
, но возвращает true, когда она не пуста, кстати ...). Кроме того, функция не будет вызывать себя автоматически. Добавить ()
после obj.isEmpty
.
console.log(objectname.isEmpty());
Интересно, почему ни один из тел не назвал решение ниже.
if(myObject != null){
// not null; your code here
}