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

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

можно использовать подчеркивания.js.

_.isEmpty({}); // true

if(Object.getOwnPropertyNames(obj).length === 0){
  //is empty
}

см.http://bencollier.net/2011/04/javascript-is-an-object-empty/

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

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 с демонстрацией и простой тест.

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

1. просто обходной путь. Может ли ваш сервер генерировать какое-то специальное свойство в случае отсутствия данных?

   например:

   var a = {empty:true};
   

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

2. другой способ проверить это:

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

редактировать: Если вы используете любую библиотеку JSON (f.e. JSON.js) тогда вы можете попробовать JSON.функция encode () и проверка результата на пустую строку значений.

Использование Объекта.ключи(объект).длина (как предложено выше для ECMA 5+) в 10 раз медленнее для пустых объектов! продолжайте использовать опцию old school (for...in).

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

• (...в...) самый быстрый вариант использовать!

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

if (Object.keys(a).length > 0) {
    // not empty
}

еще один простой, чистый способ JS:)

if (JSON.stringify(pathParams) === '{}')

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

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

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 класс и его функции (парсить и преобразовать в строки) очень полезны, но имеют некоторые проблемы с IE7 что вы можете исправить это с помощью этого простого кода http://www.json.org/js.html.

другой простой способ (самый простой способ) :
вы можете использовать этот путь без использования jQuery или JSON

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

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

в следующем примере показано, как проверить, является ли объект 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

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

_.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

просто, я не думаю, что все браузеры реализуют .

простые петли:

var is_empty = true;
for(var i in obj) {
    is_empty = false;
    break;
}

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

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

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

это jquery + jquery.в JSON

нюанс! Остерегайтесь limitiations в 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

    {}

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

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

a = Object.extended({})

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

a.size()

Другой альтернативой является использование есть.js (14kB) в отличие от в jQuery (32 КБ), лодашь (50kB), или подчеркивание (16.4 КБ). есть.js оказалась самой быстрой библиотекой среди вышеупомянутых библиотек, которая может использоваться для определения пустоты объекта.

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

очевидно, что все эти библиотеки не совсем то же самое, так что если вы нужно легко манипулировать DOM тогда в jQuery все еще может быть хорошим выбором, или если вам нужно больше, чем просто проверка типа потом лодашь или подчеркивание может быть хорошо. Что касается есть.js, вот синтаксис:

var a = {};
is.empty(a); // true
is.empty({"hello": "world"}) // false

как подчеркивание и лодаш _.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;
}

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

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

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

Это проверяет, что:

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

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

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

Boolean(Object.keys(obj)[0])