Come testare un oggetto JavaScript vuoto?


3111

Dopo una richiesta AJAX, a volte la mia applicazione può restituire un oggetto vuoto, come:

var a = {};

Come posso verificare se è così?


7
Usi lo script JSON.js? O qualsiasi altra libreria JSON. Quindi è possibile utilizzare la funzione JSON.encode () per convertire var in stringa e quindi testarlo.
Il

if( Object.entries(a).length > 0){ //do }
Muhammad Shahzad,

Risposte:


5428

ECMA 5+ :

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

Si noti, tuttavia, che ciò crea un array non necessario (il valore restituito di keys).

Pre-ECMA 5:

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

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

jQuery :

jQuery.isEmptyObject({}); // true

lodash :

_.isEmpty({}); // true

Sottolineatura :

_.isEmpty({}); // true

Hoek

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

ExtJS

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

AngularJS (versione 1)

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

Ramda

R.isEmpty({}); // true

22
Ecco il test delle prestazioni tra jQuery e il carattere di sottolineatura jsperf.com/isempty-vs-isemptyobject/6
Mikhail

20
Object.keys(new Date()).length === 0; quindi questa risposta può essere fuorviante.
cjbarth,

6
Invece di stringifying cose che si possono anche approfittare di questo fatto: (new Date()).constructor === Date, o, al contrario, ({}).constructor === Object.
John Nelson,

2
angular.equals ({}, {});
Jeremy A. West,

11
Object.keys()non controlla le proprietà o i simboli non enumerabili. Devi usare Object.getOwnPropertyNames()e Object.getOwnPropertySymbols()invece. Inoltre, Object.getPrototypeOf()è il modo corretto di ottenere il prototipo di un oggetto. obj.constructorpuò essere facilmente forgiato. Esempio: function Foo() {} Foo.prototype.constructor = Object; (new Foo()).constructor === Object // true.
Jesse,

863

Non esiste un modo semplice per farlo. Dovrai ricorrere esplicitamente alle proprietà:

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

    return true;
}

Se è disponibile il supporto ECMAScript 5 , è possibile utilizzare Object.keys()invece:

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

56
Funziona bene, o più semplicemente: function isEmpty (object) {for (var i in object) {return true; } return false; }
Nicholas Kreidberg,

36
Vero e falso non dovrebbero essere invertiti in questa funzione?
namtax,

25
@namtax: no - la funzione è chiamata isEmpty(), quindi dovrebbe tornare falsese ha una proprietà
Christoph

6
oggetto vuoto estenderà la classe Oggetto predefinita ma se il prototipo oggetto viene modificato la tua funzione semplificata non verrà considerata: Object.prototype.a = 'hi'; var obj = {}; alert (obj.a); // genera "hi" isEmpty (obj) // restituisce false
venimus l'

29
Non dovresti usare il secondo esempio poiché è O (n) complessità temporale e O (n) complessità spaziale, mentre il primo è O (1).
Brian,

572

Per quelli di voi che hanno lo stesso problema ma usano jQuery, è possibile usare jQuery.isEmptyObject .


43
HEY! Ho appena trascorso alcune ore a eseguire il debug dei problemi di IE 8 solo per scoprire che è stato jQuery.isEmptyObject a causare il problema. Restituisce vero se l'oggetto è vuoto.
MFD3000,

162
Perché pubblichi una risposta che include jQuery se la domanda non riguarda affatto jQuery?
Eru,

47
So che è un vecchio commento, ma mi chiedo la tua domanda @ MFD3000, perché il docu dice: restituisce vero, se l'oggetto è vuoto (come indica il nome)
Александр Фишер

21
includere jQuery per un compito così basilare non è ciò che definirei la risposta giusta. È vero che oggigiorno jQuery è quasi onnipresente, ma non dobbiamo dimenticare che è costruito su un linguaggio molto capace.
Pablo Mescher,

54
Tipico snobismo di JS in questi commenti. Tutti sanno che un'enorme percentuale di JavaScript sul Web è scritta su jQuery, quindi è perfettamente accettabile fornire una soluzione qui per jQuery se ha già un metodo integrato per testare gli oggetti. È probabile che migliaia di sviluppatori in cerca di aiuto troveranno utile questa risposta. Nessuno ha detto che è l'unico modo per farlo. underscore.js
Noto

276

Questa è la mia soluzione preferita:

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


3
@Jero Franzani: no non lo fa
nikoskip,

La lunghezza Object.keys ({}). È 10 volte più lenta dell'opzione (per ... in ...) - Suggerisco di evitarlo come un modo per testare se un oggetto è vuoto.
davidhadas,

10
Object.keys(new Date()).length === 0; quindi questa risposta può essere fuorviante.
cjbarth,

new Date()non è un oggetto. nd = new Date(); nd.constructor === Object;risultati in false.
dal

204

Puoi usare Underscore.js .

_.isEmpty({}); // true

19
Oppure potresti usare lodash è vuoto ( lodash.com/docs#isEmpty ), ma in che modo differisce dall'uso di una soluzione jQuery? Devi comunque installare una libreria aggiuntiva. Penso che l'intenzione sia una soluzione javascript alla vaniglia.
tfmontague,

10
È diverso se si desidera utilizzare JS sul back-end con Node.js. Poche persone vorranno utilizzare jQuery (una libreria front-end utilizzata principalmente per manipolazioni DOM) sul back-end.
Nahn,

3
Il carattere di sottolineatura di @tfmontague è molto comune nelle app dei nodi, quasi onnipresente come jQ sul lato client. Avevo già richiesto il trattino basso ma non mi rendevo conto che aveva questa funzione
rw-nandemo,

5
Underscore viene sostituito con lodash. Usa quello invece.
Demisx,

2
Fai solo attenzione con i tipi di data, isEmpty restituisce sempre vero per la data, vedi github.com/jashkenas/underscore/issues/445
mentat

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

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


5
Ciò include le proprietà non enumerabili, nel caso ti interessi.

La lunghezza Object.getOwnPropertyNames ({}). È 10 volte più lenta dell'opzione (per ... in ...) - Suggerisco di evitarlo come modo per testare se un oggetto è vuoto.
davidhadas,

4
Object.getOwnPropertyNames(new Date()).length === 0; quindi questa risposta può essere fuorviante.
cjbarth,

80

Che ne dici di usare JSON.stringify? È quasi disponibile in tutti i browser moderni.

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

23
return (JSON.stringify (obj) == '{}')
Vic

26
Questo è lento e la velocità conta per questo tipo di utilità. Test rapido perf qui: jsperf.com/empty-object-test

1
Questa è un'opzione molto lenta - suggerisco di usare invece l'opzione (per ... in)
davidhadas,

2
E non funziona per oggetti che contengono funzioni.
Felix Kling,

1
Emetterà anche un errore se c'è un riferimento circolare nell'oggetto. Quindi è lento, inaffidabile e può generare errori e rompere tutto il resto. Nessun motivo per usarlo mai.
Burak,

62

Mi sono appena imbattuto in una situazione simile. Non volevo usare JQuery e volevo farlo usando solo Javascript.

E quello che ho fatto è stato utilizzare la seguente condizione e ha funzionato per me.

var obj = {};
if(JSON.stringify(obj) === '{}') { //This will check if the object is empty
   //Code here..
}

Per non uguale a, utilizzare questo: JSON.stringify(obj) !== '{}'

Dai un'occhiata a questo JSFiddle


4
Fallirà per gli oggetti con riferimenti circolari poiché JSON.stringify genera specificamente un'eccezione per loro.
Pedro Montoto García,

1
@ PedroMontotoGarcía Ok e in che modo un oggetto vuoto avrà un riferimento circolare?
KthProg,

8
Se l'oggetto non è vuoto (e dovrebbe funzionare anche per loro).
Pedro Montoto García,

Questo sembra essere già stato menzionato da @Ateszki ed è uno dei modi più lenti per verificare se un oggetto non è vuoto.
Cwadding,

Oh sì .. mi è mancato. Mi sono imbattuto in una situazione in cui volevo ottenere questo javascript e, dopo un po 'di riflessione, ho capito in questo modo. @Ateszki, anche se ho pensato come hai fatto. :-) A proposito, ci sono state molte risposte su questo, e quindi ho perso la tua risposta.
Anish Nair,

60

Vecchia domanda, ma ho appena avuto il problema. Includere JQuery non è davvero una buona idea se il tuo unico scopo è verificare se l'oggetto non è vuoto. Invece, approfondisci il codice di JQuery e otterrai la risposta:

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

5
Questo è utile solo se qualche altro processo non ha aggiunto un prototipo all'oggetto base. Per renderlo veramente praticabile, devi testare obj.hasOwnProperty (nome)
mpemburn

1
Ciò non aggiunge nulla alla risposta di Christoph del 2009.
Dan Dascalescu,

39

C'è un modo semplice se sei su un browser più recente. Object.keys(obj).length == 0


1
Da dove viene la keysproprietà?

2
È un metodo standard in ECMAScript 5.1
scarica il

1
In che modo il commento sopra può avere 4 voti? Sì, Object.keysè un metodo standard ma gli oggetti non hanno una proprietà keys. Quindi questo codice riporterà qualsiasi oggetto come vuoto, tranne per il fatto che per caso ha una proprietà denominata keycon un valore che di nuovo come una proprietà denominata lengthche non è zero. Orribile!
scravy

Object.keys(new Date()).length === 0; quindi questa risposta può essere fuorviante.
cjbarth,

11
@scravy Object è la classe Object. L'oggetto ha un metodo statico chiamato 'chiavi' che accetta un oggetto come argomento. Questo metodo restituisce una matrice di stringhe in cui le stringhe sono nomi di proprietà. developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
Sgnl

35

Prestazione

Oggi 2020.01.17 eseguo test su MacO HighSierra 10.13.6 su Chrome v79.0, Safari v13.0.4 e Firefox v72.0, per le soluzioni scelte.

conclusioni

  • soluzioni basate su for-in (A, J, L, M) sono le più veloci
  • soluzioni basate su JSON.stringify (B, K) sono lente
  • sorprendentemente anche la soluzione basata su Object(N) è lenta

inserisci qui la descrizione dell'immagine

Dettagli

Di seguito nello snippet sono presentate 15 soluzioni. Se desideri eseguire il test delle prestazioni sul tuo computer, fai clic QUI .

inserisci qui la descrizione dell'immagine


molto di questo non ha senso perché stai basando tutto su un ritorno di falso e / o vero. A volte la programmazione necessita di un'istruzione if o di un operatore ternario. FYI
Christian Matthew,

1
È la risposta migliore, grazie, la prima soluzione funziona come un incantesimo
Carlos Jesus Arancibia Taborga,

33

L'uso di Object.keys (obj) .length (come suggerito sopra per ECMA 5+) è 10 volte più lento per gli oggetti vuoti! continua con l'opzione vecchia scuola (per ... in).

Testato sotto Nodo, Chrome, Firefox e IE 9, diventa evidente che per la maggior parte dei casi d'uso:

  • (per ... in ...) è l'opzione più veloce da usare!
  • Object.keys (obj) .length è 10 volte più lento per gli oggetti vuoti
  • JSON.stringify (obj) .length è sempre il più lento (non sorprendente)
  • Object.getOwnPropertyNames (obj) .length richiede più tempo di Object.keys (obj) .length può essere molto più lungo su alcuni sistemi.

In conclusione, utilizzare:

function isEmpty(obj) { 
   for (var x in obj) { return false; }
   return true;
}

o

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

Vedi i risultati dei test dettagliati e il codice di test in È l'oggetto vuoto?


Object.keysè lento, ma meno codice. Su una piccola pagina, dove viene chiamato ... forse 10 volte ... Sarà ancora più lento considerando il tempo di analisi aggiuntivo del codice aggiuntivo?
yankee,

32

È possibile verificare il conteggio delle chiavi dell'oggetto:

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

8
Perché dovresti aggiungere un commento per una risposta che è già stata data e dare una risposta peggiore? stackoverflow.com/a/32108184/4229159 ed è la prima risposta di aprile
Alejandro Vales,

Come se avessi un oggetto molto grande e lo facessi su ogni loop solo per vedere se l'oggetto era vuoto?
StefansArya,

27
  1. Solo una soluzione alternativa. Il tuo server può generare proprietà speciali in caso di assenza di dati?

    Per esempio:

    var a = {empty:true};

    Quindi puoi facilmente controllarlo nel tuo codice di callback AJAX.

  2. Un altro modo per verificarlo:

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

EDIT : Se si utilizza una libreria JSON (fe JSON.js), è possibile provare la funzione JSON.encode () e testare il risultato con una stringa di valore vuota.


6
toSource()non è standard e non funziona in IE o Opera (e potenzialmente in altri browser che non ho controllato)
Christoph

4
@Thevs: forse hai una copia diversa della versione corrente di ECMA-262, ma la mia non elenca una toSourceproprietà nella sezione 15.2.4; secondo MDC, è stato introdotto in JS1.3 (ovvero Netscape Navigator 4.06), ma NON è in ECMA-262, 3a edizione!
Christoph,

4
@Thevs: beh, almeno 2 importanti produttori di browser non l'hanno implementato, quindi non è di fatto uno standard di fatto, e poiché non è in ECMA-262, non è nemmeno uno reale ...
Christoph

4
Anche quando funziona, toSource()è un modo orribile per farlo (così com'è JSON.encode()). Deve creare una stringa che rappresenti l'intero oggetto per controllare solo se è vuoto. C'è il sovraccarico di convertire cose in stringhe, ma inoltre dovrà convertire un milione di cose se il tuo oggetto ha un milione di proprietà, mentre in realtà guardarne una ti farà sapere che non è vuoto.
Jasper,

4
@Thevs il sovraccarico è più grande, anche se potrebbe essere (non sono sicuro che sia in ogni circostanza) nello stesso ordine di grandezza. Tuttavia, quella risposta implica il ritorno falso non appena viene trovata una proprietà diversa che rende la storia diversa tutti insieme ...
Jasper

25

Ho creato una funzione completa per determinare se l'oggetto è vuoto.

Utilizza Object.keysdalla funzionalità ECMAScript 5 (ES5) se possibile per ottenere le migliori prestazioni (vedere la tabella di compatibilità ) e fallback all'approccio più compatibile per i motori più vecchi (browser).

Soluzione

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

Ecco l' essenza di questo codice.

Ed ecco il JSFiddle con dimostrazione e un semplice test.

Spero che possa aiutare qualcuno. Saluti!


3
Questo non riesce per un nulloggetto.

Ciao @torazaburo! Grazie per aver preso un avviso! Ho aggiornato tutte le fonti con la corretta implementazione.
Slava Fomin II

1
La lunghezza Object.keys ({}). È 10 volte più lenta dell'opzione (per ... in ...) - Suggerisco di evitarlo come un modo per testare se un oggetto è vuoto.
davidhadas,

1
Object.keys(new Date()).length === 0; quindi questa risposta può essere fuorviante.
cjbarth,

19

Sto usando questo.

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

Per esempio:

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;

da qui

Aggiornare

O

è possibile utilizzare l'implementazione jQuery di isEmptyObject

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

Ciao. quando si verifica questa funzione con numero o valore booleano vero o falso si restituisce vero e questo non è un risultato corretto. isObjectEmpty (vero). isObjectEmpty (false). isObjectEmpty (1)
iman

2
Stiamo verificando se l'oggetto è vuoto, non se il tipo di dati è un oggetto. Nel tuo caso per verificare se si tratta di un oggetto, abbiamo bisogno di qualcosa del tipo if (typeof a === "object") {...}
kiranvj,

15

L'esempio seguente mostra come verificare se un oggetto JavaScript è vuoto, se per vuoto intendiamo che non ha proprietà proprie.

Lo script funziona su 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


15

Secondo la specifica ES2017 su Object.entries () , il controllo è semplice utilizzando qualsiasi browser moderno--

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

3
C'è qualche vantaggio nell'utilizzare questo sopra Object.keyso Object.values?
faintsignal

@faintsignal usando quelli vanno benissimo. Ho appena aggiunto voci come non l'ho trovato nei commenti.
Vikrant,

13
function isEmpty(obj) {
  for(var i in obj) { return false; }
  return true;
}

4
Ciò riporterà anche vero, quando, ad esempio, una libreria JavaScript si estende Objectcon un metodo attraverso la catena di prototipi, perché è enumerabile e l' for inistruzione scorre attraverso le proprietà enumerabili.
viam0Zah,

12

jQuery ha una funzione speciale isEmptyObject()per questo caso:

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

Maggiori informazioni su http://api.jquery.com/jQuery.isEmptyObject/


12

Vorrei verificare se ha almeno una chiave. Basterebbe dirmi che non è vuoto.

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

1
cosa succede se la prima chiave restituisce falsevalore? il risultato sarà falseche non è corretto.
Jimmy Obonyo Abor,

Ho provato per quello. Puoi fare un esempio funzionante?
Tudor Morar,

1
questo è breve e conciso, ma comporterà un errore di runtime se l'oggetto non è definito
Mrinmoy,

11

Sotto il cofano tutti i metodi di controllo vuoti in tutte le librerie usano la logica di controllo delle chiavi degli oggetti. È un modo strano per renderlo comprensibile, che puoi inserire in un metodo, descritto qui .

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

Che si è evoluto in ES5 , ora puoi semplicemente controllare la lunghezza delle chiavi dell'oggetto, usando il Object.Keysmetodo che prende il tuo oggetto come parametro:

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

O se stai usando Lodash (devi esserlo) allora.

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

Mentre è corretto come un modo strano di fare un'istruzione if - probabilmente confonderà qualcuno che manterrà il codice dopo di te.
Soren,

10


puoi usare questo semplice codice che non ha usato jQuery o altre librerie

var a=({});

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

La classe JSON e le sue funzioni ( analizzano e stringono ) sono molto utili ma presentano alcuni problemi con IE7 che è possibile risolvere con questo semplice codice http://www.json.org/js.html .

Altro modo semplice (modo più semplice):
è possibile utilizzare questo modo senza usare l' oggetto jQuery o 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.stringifyla soluzione ha esito negativo se l'oggetto contiene proprietà non stringibili come funzioni o "non definito", sebbene sia garantito che sia un caso limite.

10

Il modo migliore che ho trovato:

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

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

    return false;
}

Lavora per:

    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

3
Direi che 0 non è vuoto poiché in realtà è un numero. tutto il resto sembra buono ma la correzione è facile. nella prima istruzione if aggiungere questo. if (!obj && obj !== 0).
mjwrazor,

9

La mia opinione:

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

Solo, non penso che tutti i browser implementino Object.keys()attualmente.


2
Object.keys(new Date()).length === 0; quindi questa risposta può essere fuorviante.
cjbarth,

3
Dipende se si considera che una data è sempre "piena" nonostante non si espongano mai le chiavi. Ma sono d'accordo che se questo è il tuo piano, aggiungere qualche istanza supplementare di controllo per il costruttore Date è una buona opzione.
NiKo


7

Avvertimento! Fai attenzione ai limiti di 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 ) );

visualizza

    Attenzione !! obj NON è vuoto!

    obj = {f: function () {}}

    JSON.stringify (obj)

    ritorna

    {}

7

La risposta corretta è:

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

Questo verifica che:

  • L'oggetto non ha proprietà proprie (indipendentemente dall'enumerabilità).
  • L'oggetto non ha simboli di proprietà propri.
  • Il prototipo dell'oggetto è esattamente Object.prototype.

In altre parole, l'oggetto è indistinguibile da quello creato con {}.


6

Oltre alla risposta di Thevs:

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

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

è jquery + jquery.json


Non mi piace usare JSON perché non può funzionare con strutture di oggetti circolari.
Funziona

2
Se la tua pagina carica jQuery $.isEmptyObject(), utilizza , non sprecare cicli con conversioni non ovvie.
skierpage

6

Sugar.JS fornisce oggetti estesi per questo scopo. Il codice è pulito e semplice:

Crea un oggetto esteso:

a = Object.extended({})

Controlla le sue dimensioni:

a.size()
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.