ECMA 5

, для хранения элементов jQuery, но, как я уже сказал в начале это отличает его от простых переменных и делает его намного более простым для понимания (представьте, что вы путаете его с простой переменной и ищите все, чтобы понять, что оно содержит).

var a = {};

Как я могу проверить, так ли это?

библиотеку дат с открытым исходным кодом JavaScript «. :

// because Object.entries(new Date()).length === 0;
// we have to do some additional check
Object.entries(obj).length === 0 && obj.constructor === Object

Pre-ECMA 5: :

// because Object.keys(new Date()).length === 0;
// we have to do some additional check
Object.keys(obj).length === 0 && obj.constructor === Object

Hoek

function isEmpty(obj) {
  for(var prop in obj) {
    if(obj.hasOwnProperty(prop)) {
      return false;
    }
  }

  return JSON.stringify(obj) === JSON.stringify({});
}

jQuery :

jQuery.isEmptyObject({}); // true

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

_.isEmpty({}); // true

Underscore :

_.isEmpty({}); // true

ExtJS

Hoek.deepEqual({}, {}); // true

AngularJS (версия 1)

Ext.Object.isEmpty({}); // true

Поддержка ECMAScript 5

angular.equals({}, {}); // true

Ramda

R.isEmpty({}); // true

Нет простого способа сделать это. Вам придется явно зацикливать свойства:

function isEmpty(obj) {
    for(var prop in obj) {
        if(obj.hasOwnProperty(prop))
            return false;
    }

    return true;
}

Вот мое решение. Как сказал Энди Э., отвечая на вопрос доступна, вместо нее можно использовать : { *} Вы можете использовать Object.keys() http://bencollier.net/2011/04/javascript-is-an-object-empty/

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

Как насчет использования JSON.stringify? Это почти доступно во всех современных браузерах. Underscore.js Глядя на вывод

_.isEmpty({}); // true
if(Object.getOwnPropertyNames(obj).length === 0){
  //is empty
}

, поэтому ваш код будет работать только после загрузки окна, когда все ресурсы имеют был загружен. В этот момент jQuery ( Http://bencollier.net/2011/ 04 / javascript-is-a-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

Я создал полную функцию, чтобы определить, является ли объект пустым.

Конечно, никто из этого обсуждения не ответил прямо на то, что 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 с демонстрацией и простым тестом.

Надеюсь, это кому-нибудь поможет. Ура!

Вы можете проверить количество ключей объекта:

if (Object.keys(a).length > 0) {
    // not empty
}
  1. Просто обходной путь. Может ли ваш сервер генерировать какое-то специальное свойство в случае отсутствия данных?

    Также смотрите

    var a = {empty:true};
    

    . Затем вы можете легко проверить это в коде обратного вызова AJAX. ,

  2. Еще один способ проверить это:

    if (a.toSource() === "({})")  // then 'a' is empty
    

I Вместо этого используйте любой из методов, ранее упомянутых другими: свойство : если вы используете какую-либо библиотеку JSON (например, JSON.js), тогда вы можете попробовать функцию JSON.encode () и проверить результат по пустой строке значения.

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

Протестировано под Node, Chrom, Firefox и IE 9, становится очевидным, что для большинства случаев использования:

  • (для … in …) — самый быстрый вариант для использования!
  • Object.keys (obj) .length в 10 раз медленнее для пустых объектов
  • JSON.stringify (obj) .length всегда самый медленный (не удивительно)
  • Object.getOwnPropertyNames (obj). длина занимает больше, чем Object.keys (obj) .length может быть намного длиннее в некоторых системах.

Производительность снизу, используйте:

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;
}

См. Подробные результаты тестирования и тестовый код на Не работает в IE8, если родительский объект obj не поддерживает

Я использую это.

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;

отсюда

Update

или

вы можете использовать jQuery-реализацию isEmptyObject

function isEmptyObject ( obj ) {
        var name;
        for ( name in obj ) {
            return false;
        }
        return true;
    }

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

. в три раза быстрее использовать .pop.

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;
}

jQuery имеет специальную функцию isEmptyObject() для этого случая:

jQuery.isEmptyObject({}) // true
jQuery.isEmptyObject({ foo: "bar" }) // false

Подробнее на http://api.jquery.com/jQuery.isEmptyObject/

вы можете использовать этот простой код, который не использовал 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

Лучший способ, который я нашел:

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

Справочная ссылка

typeof obj !== "undefined" && Boolean(Object.keys(obj)[0])

Мое мнение:

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().

Если jQuery и веб-браузер недоступны, в underscore.js также есть функция isEmpty.

_.isEmpty({}) // returns true

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

Согласно ES2017 спецификации на вы можете используйте что-то вроде этого проверка проста с использованием любого современного браузера —

Object.entries({}).length === 0

Caveat! Остерегайтесь ограничений JSON.

javascript:
  obj={  f:function(){}  };
  alert( "Beware!! obj is NOT empty!nnobj = {  f:function(){}  }"   
               "nnJSON.stringify( obj )nnreturnsnn"  
                        JSON.stringify( obj ) );

отображает

    Beware!! obj is NOT empty!

    obj = {  f:function(){}  }

    JSON.stringify( obj )

    returns

    {}

Правильный ответ:

const isEmptyObject = obj =>
  Object.getOwnPropertyNames(obj).length === 0 &&
  Object.getOwnPropertySymbols(obj).length === 0 &&
  Object.getPrototypeOf(obj) === Object.prototype;

это может считаться лучшей практикой. Это проверяет, что:

  • Объект не имеет собственных свойств (независимо от перечисляемости).
  • Объект не имеет собственных символов свойств.
  • Прототип объекта в точности Object.prototype Глядя на вывод

Другими словами, объект неотличим от объекта, созданного с помощью {} Глядя на вывод

. В дополнение к ответу Thevs:

var o = {};
alert($.toJSON(o)=='{}'); // true

var o = {a:1};
alert($.toJSON(o)=='{}'); // false

это jquery. Jquery.json

Sugar.JS предоставляет расширенные объекты для этой цели. Код прост и понятен:

Создайте расширенный объект:

a = Object.extended({})

Проверьте его размер:

a.size()

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

for(key in obj){
   //your work here.
 break;
}

, который развился в ES5 , теперь просто вы можете проверить длину ключей объекта, используя метод Object.Keys, который принимает ваш объект в качестве параметра:

if(Object.keys(obj).length > 0){
 //do your work here
}

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

 _.isEmpty(obj) //==true or false

Другая альтернатива — использовать И, наконец, первые 20 синих тегов p меняются на зеленые (14 КБ) вместо jQuery (32 КБ), Если второй аргумент не задан, он вернет пустой объект с первым аргументом, который будет использоваться в качестве прототипа возвращаемого объекта (первый объект, который будет использоваться в прототипе возвращаемого объекта цепь). Это выдает ошибку «undefined не является функцией …» Underscore (16,4 КБ). is.js оказалась самой быстрой библиотекой среди вышеупомянутых библиотек, которую можно использовать для определения, является ли объект пустым.

http://jsperf.com/check-empty-object-using-libraries

Очевидно, что все эти библиотеки не совсем одинаковы, так что если вам нужно легко манипулировать DOM, тогда jQuery может быть хорошим выбор или если вам нужно больше, чем просто проверка типов, тогда Если второй аргумент не задан, он вернет пустой объект с первым аргументом, который будет использоваться в качестве прототипа возвращаемого объекта (первый объект, который будет использоваться в прототипе возвращаемого объекта цепь). или Underscore может быть хорошим. Что касается И, наконец, первые 20 синих тегов p меняются на зеленые, вот синтаксис:

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 === '';
    }
};

, поэтому в этих случаях имелось соответствие 1: 1.)

function isEmptyObject( obj ) {
    return Object.getOwnPropertyNames(obj).length === 0;
}

Это только немного быстрее, чем is.js, хотя только потому, что вы не проверяете, является ли это объектом.

, несколько абзацев под большой таблицей в начале этого раздела), где говорится:

, для хранения элементов jQuery, но, как я уже сказал в начале это отличает его от простых переменных и делает его намного более простым для понимания (представьте, что вы путаете его с простой переменной и ищите все, чтобы понять, что оно содержит).

var a = {};

Как я могу проверить, так ли это?

этот однострочный код помогает

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. вышеприведенная строка работает в старых браузерах с резервной функцией.

JSFiddler

    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;
    }

Это проверит пустоту строк, массивов или объектов (карт).

Использование:

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

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

это вернет 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

Между тем у нас может быть одна функция, которая проверяет все «пустые места», такие как 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

Try Destructuring

const a = {};
const { b } = a;
const emptryOrNot = (b) ? 'not Empty' : 'empty';
console.log(emptryOrNot)
export function isObjectEmpty(obj) {
  return (
    Object.keys(obj).length === 0 &&
    Object.getOwnPropertySymbols(obj).length === 0 &&
    obj.constructor === Object
  );
}

Это включает в себя проверку объектов, содержащих свойства символа.

Object.keys , не возвращает свойства символа.

Начиная с jQuery 1.4 метод isEmptyObject() проверяет как свойства самого объекта, так и свойства, унаследованные от прототипов (в том смысле, что он не использует hasOwnProperty). Аргумент всегда должен быть простым объектом JavaScript, поскольку другие типы объектов (элементы DOM, простые строки / числа, хост-объекты) могут не давать согласованных результатов в разных браузерах. Чтобы определить, является ли объект простым JavaScript-объектом, используйте $.isPlainObject() Глядя на вывод

jQuery.isPlainObject({}) // true

jQuery.isPlainObject( "test" ) // false

Jquery api

Я возвращал пустой 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
    }
});

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

Определение должно выглядеть следующим образом:

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";
  }
}

Enjoy! :-)

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

const isObjectEmpty = ( obj ) => Object.values( obj  ).every( val => typeof val === "undefined" );

isObjectEmpty({ foo: undefined, bar: undefined }): // true
isObjectEmpty({ foo: false, bar: null }): // false

Таким образом, мы можем расширять, скажем, объект параметров, только когда предоставляются подопции

function onSubmit({ fullPage, width, height }) {
const baseOptions = { fullPage },
      clip = { width, height },
      options = isObjectEmpty( clip ) ? baseOptions : { ...baseOptions, clip };
//...
}

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

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;
}

Чистый ванильный Javascript и полная обратная совместимость

function isObjectDefined (Obj) {
  if (Obj === null || typeof Obj !== 'object' ||
    Object.prototype.toString.call(Obj) === '[object Array]') {
    return false
  } else {
    for (var prop in Obj) {
      if (Obj.hasOwnProperty(prop)) {
        return true
      }
    }
    return JSON.stringify(Obj) !== JSON.stringify({})
  }
}

console.log(isObjectDefined()) // false
console.log(isObjectDefined('')) // false
console.log(isObjectDefined(1)) // false
console.log(isObjectDefined('string')) // false
console.log(isObjectDefined(NaN)) // false
console.log(isObjectDefined(null)) // false
console.log(isObjectDefined({})) // false
console.log(isObjectDefined([])) // false
console.log(isObjectDefined({a: ''})) // true

Чтобы действительно принять only {}, лучший способ сделать это в Javascript с использованием Lodash:

_.isEmpty(value) && _.isPlainObject(value)

Версия, добавляющая 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');
Понравилась статья? Поделиться с друзьями:
JavaScript & TypeScript
Adblock
detector