Dopo una richiesta AJAX, a volte la mia applicazione può restituire un oggetto vuoto, come:
var a = {};
Come posso verificare se è così?
if( Object.entries(a).length > 0){ //do }
Dopo una richiesta AJAX, a volte la mia applicazione può restituire un oggetto vuoto, come:
var a = {};
Come posso verificare se è così?
if( Object.entries(a).length > 0){ //do }
Risposte:
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
_.isEmpty({}); // true
Hoek.deepEqual({}, {}); // true
Ext.Object.isEmpty({}); // true
angular.equals({}, {}); // true
R.isEmpty({}); // true
Object.keys(new Date()).length === 0
; quindi questa risposta può essere fuorviante.
(new Date()).constructor === Date
, o, al contrario, ({}).constructor === Object
.
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.constructor
può essere facilmente forgiato. Esempio: function Foo() {} Foo.prototype.constructor = Object; (new Foo()).constructor === Object // true
.
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;
}
isEmpty()
, quindi dovrebbe tornare false
se ha una proprietà
Per quelli di voi che hanno lo stesso problema ma usano jQuery, è possibile usare jQuery.isEmptyObject .
underscore.js
Questa è la mia soluzione preferita:
var obj = {};
return Object.keys(obj).length; //returns 0 if empty or an integer > 0 if non-empty
Object.keys(new Date()).length === 0
; quindi questa risposta può essere fuorviante.
new Date()
non è un oggetto. nd = new Date(); nd.constructor === Object;
risultati in false
.
Puoi usare Underscore.js .
_.isEmpty({}); // true
if(Object.getOwnPropertyNames(obj).length === 0){
//is empty
}
vedi http://bencollier.net/2011/04/javascript-is-an-object-empty/
Object.getOwnPropertyNames(new Date()).length === 0
; quindi questa risposta può essere fuorviante.
Che ne dici di usare JSON.stringify? È quasi disponibile in tutti i browser moderni.
function isEmptyObject(obj){
return JSON.stringify(obj) === '{}';
}
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) !== '{}'
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;
}
C'è un modo semplice se sei su un browser più recente.
Object.keys(obj).length == 0
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 key
con un valore che di nuovo come una proprietà denominata length
che non è zero. Orribile!
Object.keys(new Date()).length === 0
; quindi questa risposta può essere fuorviante.
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
for-in
(A, J, L, M) sono le più velociJSON.stringify
(B, K) sono lenteObject
(N) è lentaDi seguito nello snippet sono presentate 15 soluzioni. Se desideri eseguire il test delle prestazioni sul tuo computer, fai clic QUI .
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:
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?
È possibile verificare il conteggio delle chiavi dell'oggetto:
if (Object.keys(a).length > 0) {
// not empty
}
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.
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.
toSource()
non è standard e non funziona in IE o Opera (e potenzialmente in altri browser che non ho controllato)
toSource
proprietà nella sezione 15.2.4; secondo MDC, è stato introdotto in JS1.3 (ovvero Netscape Navigator 4.06), ma NON è in ECMA-262, 3a edizione!
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.
Ho creato una funzione completa per determinare se l'oggetto è vuoto.
Utilizza Object.keys
dalla 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).
/**
* 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!
Object.keys(new Date()).length === 0
; quindi questa risposta può essere fuorviante.
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;
Aggiornare
O
è possibile utilizzare l'implementazione jQuery di isEmptyObject
function isEmptyObject(obj) {
var name;
for (name in obj) {
return false;
}
return true;
}
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
Secondo la specifica ES2017 su Object.entries () , il controllo è semplice utilizzando qualsiasi browser moderno--
Object.entries({}).length === 0
Object.keys
o Object.values
?
function isEmpty(obj) {
for(var i in obj) { return false; }
return true;
}
Object
con un metodo attraverso la catena di prototipi, perché è enumerabile e l' for in
istruzione scorre attraverso le proprietà enumerabili.
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/
Vorrei verificare se ha almeno una chiave. Basterebbe dirmi che non è vuoto.
typeof obj !== "undefined" && Boolean(Object.keys(obj)[0])
false
valore? il risultato sarà false
che non è corretto.
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.Keys
metodo 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
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
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
if (!obj && obj !== 0)
.
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.
Object.keys(new Date()).length === 0
; quindi questa risposta può essere fuorviante.
Se jQuery e il browser web non sono disponibili, c'è anche una funzione isEmpty in underscore.js.
_.isEmpty({}) // returns true
Inoltre, non presuppone che il parametro di input sia un oggetto. Per un elenco o una stringa o undefined, girerà anche la risposta corretta.
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 {}
La risposta corretta è:
const isEmptyObject = obj =>
Object.getOwnPropertyNames(obj).length === 0 &&
Object.getOwnPropertySymbols(obj).length === 0 &&
Object.getPrototypeOf(obj) === Object.prototype;
Questo verifica che:
Object.prototype
.In altre parole, l'oggetto è indistinguibile da quello creato con {}
.
Oltre alla risposta di Thevs:
var o = {};
alert($.toJSON(o)=='{}'); // true
var o = {a:1};
alert($.toJSON(o)=='{}'); // false
è jquery + jquery.json
$.isEmptyObject()
, utilizza , non sprecare cicli con conversioni non ovvie.
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()