objetos - recorrer objeto json javascript




¿Cómo pruebo un objeto JavaScript vacío? (20)

  1. Sólo una solución. ¿Puede su servidor generar alguna propiedad especial en caso de que no haya datos?

    Por ejemplo:

    var a = {empty:true};
    

    Luego puedes verificarlo fácilmente en tu código de devolución de llamada AJAX.

  2. Otra forma de comprobarlo:

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

EDITAR : Si usa cualquier biblioteca JSON (fe JSON.js), puede probar la función JSON.encode () y probar el resultado contra una cadena de valor vacía.

Después de una solicitud AJAX, a veces mi aplicación puede devolver un objeto vacío, como:

var a = {};

¿Cómo puedo comprobar si ese es el caso?


¡Advertencia! Cuidado con las limitaciones de 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 ) );

muestra

    Beware!! obj is NOT empty!

    obj = {  f:function(){}  }

    JSON.stringify( obj )

    returns

    {}

¿Qué hay de usar JSON.stringify? Está casi disponible en todos los navegadores modernos.

function isEmptyObject(obj){
    return JSON.stringify(obj) === '{}';
}

Además de la respuesta de Thevs:

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

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

es jquery + jquery.json


El siguiente ejemplo muestra cómo probar si un objeto de JavaScript está vacío, si por vacío significa que no tiene propiedades propias.

El script funciona en 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


Esta es mi solución preferida:

var obj = {};
return Object.keys(obj).length; //returns 0 if empty or an integer > 0 if non-empty

Hay una forma simple si estás en un navegador más nuevo. Object.keys(obj).length == 0


He creado una función completa para determinar si el objeto está vacío.

Utiliza la funcionalidad developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… de ECMAScript 5 (ES5) si es posible para lograr el mejor rendimiento (consulte la tabla de compatibilidad ) y utiliza el enfoque más compatible para motores más antiguos (navegadores).

Solución

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

Aquí está la Gist de este código.

Y aquí está el JSFiddle con demostración y una prueba simple.

Espero que ayude a alguien. ¡Aclamaciones!


La mejor manera que encontré:

function isEmpty(obj)
{
    if (!obj)
    {
        return true;
    }

    if (!(typeof(obj) === 'number') && !Object.keys(obj).length)
    {
        return true;
    }

    return false;
}

Trabaja para:

    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

La respuesta correcta es:

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

Esto comprueba que:

  • El objeto no tiene propiedades propias (independientemente de la posibilidad de enumeración).
  • El objeto no tiene símbolos de propiedad propios.
  • El prototipo del objeto es exactamente Object.prototype .

En otras palabras, el objeto es indistinguible de uno creado con {} .


Mi toma:

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

Simplemente, no creo que todos los navegadores implementen Object.keys() actualmente.


No hay una manera fácil de hacer esto. Tendrás que recorrer las propiedades explícitamente:

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

    return true;
}

Si el soporte de ECMAScript 5 está disponible, puede usar Object.keys() lugar:

function isEmpty(obj) {
    return Object.keys(obj).length === 0;
}

Otra forma simple, pura JS :)

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


Para aquellos de ustedes que tienen el mismo problema pero usan jQuery, pueden usar jQuery .



Si jQuery y el navegador web no están disponibles, también hay una función isEmpty en underscore.js.

_.isEmpty({}) // returns true

Además, no asume que el parámetro de entrada sea un objeto. Para una lista o cadena o indefinido, también se convertirá en la respuesta correcta.


jQuery tiene una función especial isEmptyObject() para este caso:

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

Lea más en jQuery


Sugar.JS proporciona objetos extendidos para este propósito. El código es limpio y simple:

Hacer un objeto extendido:

a = Object.extended({})

Compruebe su tamaño:

a.size()


puede usar este código simple que no usó jQuery u otras bibliotecas

var a=({});

//check is an empty object
if(JSON.stringify(a)=='{}') {
    alert('it is empty');
} else {
    alert('it is not empty');
}

La clase JSON y sus funciones ( analizar y clasificar ) son muy útiles, pero tienen algunos problemas con IE7 que puede solucionar con este simple código http://www.json.org/js.html .

Otra forma simple (la manera más simple):
se puede usar de esta manera sin usar jQuery o el objeto 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) {
  for(var i in obj) { return false; }
  return true;
}




json