Там нет простого способа сделать это. Вы должны будете явно перекрыть свойства:

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

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

Он использует функциональные возможности 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 с демонстрацией и простым тестом.

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

Вы можете проверить количество клавиш 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() и проверить результат на пустую строку значений.

Использование Object.keys(obj).length(как было предложено выше для ECMA 5+) в 10 раз медленнее для пустых объектов! придерживайтесь опции старой школы (для... in).

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

• (для... in...) - самый быстрый вариант использования!
• Object.keys(obj).length в 10 раз медленнее для пустых объектов
• JSON.stringify(obj).length всегда самый медленный (не удивительный)
• Object.getOwnPropertyNames(obj).length занимает больше времени, чем 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;
}

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

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

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

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

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

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

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

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

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

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

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

Если 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() в настоящее время.

Согласно спецификации ES2017 для Object.entries(), проверка проста с использованием любого современного browser--

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

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

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

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

JSFiddler

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

Попробуйте Destructuring

const a = {};
const { b } = a;
const emptryOrNot = (b) ? 'not Empty' : 'empty';
console.log(emptryOrNot)

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

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

JQuery api

У меня есть легкое (но не общее) решение для этого сценария:

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

Позвольте мне привести пример: есть объект, который, если его не пусто, должен иметь свойство с именем "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');

console.log(objectname.isEmpty());

Интересно, почему ни один из тел не назвал решение ниже.

if(myObject != null){
  // not null; your code here
}