L’object è vuoto?

Qual è il modo più veloce per verificare se un object è vuoto o no?

C’è un modo più veloce e migliore di questo:

function count_obj(obj){ var i = 0; for(var key in obj){ ++i; } return i; } 

Suppongo che per vuoto intendi “non ha proprietà proprie”.

 // Speed up calls to hasOwnProperty var hasOwnProperty = Object.prototype.hasOwnProperty; function isEmpty(obj) { // null and undefined are "empty" if (obj == null) return true; // Assume if it has a length property with a non-zero value // that that property is correct. if (obj.length > 0) return false; if (obj.length === 0) return true; // If it isn't an object at this point // it is empty, but it can't be anything *but* empty // Is it empty? Depends on your application. if (typeof obj !== "object") return true; // Otherwise, does it have any properties of its own? // Note that this doesn't handle // toString and valueOf enumeration bugs in IE < 9 for (var key in obj) { if (hasOwnProperty.call(obj, key)) return false; } return true; } 

Esempi:

 isEmpty(""), // true isEmpty(33), // true (arguably could be a TypeError) isEmpty([]), // true isEmpty({}), // true isEmpty({length: 0, custom_property: []}), // true isEmpty("Hello"), // false isEmpty([1,2,3]), // false isEmpty({test: 1}), // false isEmpty({length: 3, custom_property: [1,2,3]}) // false 

Se devi solo gestire i browser ECMAScript5 , puoi utilizzare Object.getOwnPropertyNames invece del ciclo hasOwnProperty :

 if (Object.getOwnPropertyNames(obj).length > 0) return false; 

Ciò assicurerà che anche se l'object ha solo proprietà non enumerabili , isEmpty ti darà comunque i risultati corretti.

Per ECMAScript5 (non ancora supportato in tutti i browser), puoi usare:

 Object.keys(obj).length === 0 

EDIT : Nota che probabilmente dovresti usare la soluzione ES5 invece di questo dato che il supporto ES5 è molto diffuso al giorno d’oggi. Funziona comunque con jQuery.


Facile e cross-browser è usando jQuery.isEmptyObject :

 if ($.isEmptyObject(obj)) { // do something } 

Altro: http://api.jquery.com/jQuery.isEmptyObject/

Hai bisogno di jquery però.

Underscore e lodash hanno ciascuna una funzione isEmpty() comoda, se non ti dispiace aggiungere una libreria extra.

 _.isEmpty({}); 

Mettiamo questo bambino a letto; 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 oggetti vuoti
  • JSON.stringify (obj) .length è sempre il più lento (non sorprende)
  • Object.getOwnPropertyNames (obj) .length richiede più tempo di Object.keys (obj) .length può essere molto più lungo su alcuni sistemi.

Le prestazioni in linea di fondo, 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; } 

Risultati sotto nodo:

  • primo risultato: return (Object.keys(obj).length === 0)
  • secondo risultato: for (var x in obj) { return false; }... for (var x in obj) { return false; }...
  • terzo risultato: for (var x in obj) { if (obj.hasOwnProperty(x)) return false; }... for (var x in obj) { if (obj.hasOwnProperty(x)) return false; }...
  • risultato: return ('{}' === JSON.stringify(obj))

Test per l’object con 0 chiavi 0,00018 0,000015 0,000015 0,000324

Test per object con 1 chiave 0.000346 0.000458 0.000577 0.000657

Test per object con 2 chiavi 0.000375 0.00046 0.000565 0.000773

Test per oggetti con 3 chiavi 0.000406 0.000476 0.000577 0.000904

Test per l’object con 4 chiavi 0,000435 0,000487 0,000589 0,001031

Test per l’object con 5 chiavi 0,000465 0,000501 0,000604 0,001148

Test per l’object con 6 chiavi 0,000492 0,000511 0,000618 0,001269

Test per l’object con 7 chiavi 0.000528 0.000527 0.000637 0.00138

Test di oggetti con 8 chiavi 0,000565 0,000538 0,000647 0,00159

Test per l’object con 100 chiavi 0,003718 0,00243 0,002535 0,01381

Test per oggetti con 1000 chiavi 0.0337 0.0193 0.0194 0.1337

Nota che se il tipico caso d’uso verifica un object non vuoto con poche chiavi e raramente riesci a testare oggetti vuoti o oggetti con 10 o più chiavi, considera l’opzione Object.keys (obj) .length. – altrimenti vai con l’implementazione più generica (per … in …).

Nota che Firefox sembra avere un supporto più veloce per Object.keys (obj) .length e Object.getOwnPropertyNames (obj) .length, rendendolo una scelta migliore per qualsiasi object non vuoto, ma comunque quando si tratta di oggetti vuoti, il ( per … in …) è semplicemente 10 volte più veloce.

I miei 2 centesimi sono che Object.keys (obj) .length è una pessima idea dato che crea un object di chiavi solo per contare quante chiavi ci sono dentro, piuttosto che distruggerlo! Per creare quell’object ha bisogno di passare in rassegna i tasti … quindi perché usarlo e non l’opzione (per … in …) 🙂

 var a = {}; function timeit(func,count) { if (!count) count = 100000; var start = Date.now(); for (i=0;i 

Modo elegante: utilizzare le chiavi

 var myEmptyObj = {}; var myFullObj = {"key":"value"}; console.log(Object.keys(myEmptyObj).length); //0 console.log(Object.keys(myFullObj).length); //1 

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys

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

Sorpreso di vedere così tante risposte deboli su una domanda JS così elementare … La risposta top non va bene anche per questi motivi:

  1. genera una variabile globale
  2. restituisce true su undefined
  3. usa for...in cui è estremamente lento da solo
  4. funzione dentro for...in è inutile – return false senza hasOwnProperty magic funzionerà hasOwnProperty

In effetti c’è una soluzione più semplice:

 function isEmpty(value){ return Boolean(value && typeof value == 'object') && !Object.keys(value).length; }); 

https://lodash.com/docs#isEmpty è molto utile:

 _.isEmpty({}) // true _.isEmpty() // true _.isEmpty(null) // true _.isEmpty("") // true 
 var x= {} var y= {x:'hi'} console.log(Object.keys(x).length===0) console.log(Object.keys(y).length===0) true false 

http://jsfiddle.net/j7ona6hz/1/

Quanto è grave questo?

 function(obj){ for(var key in obj){ return false; // not empty } return true; // empty } 

Non c’è bisogno di una biblioteca.

 function(){ //must be within a function var obj = {}; //the object to test for(var isNotEmpty in obj) //will loop through once if there is a property of some sort, then return alert('not empty')//what ever you are trying to do once return alert('empty'); //nope obj was empty do this instead; } 

Potrebbe essere un po ‘hacky. Puoi provare questo

 if (JSON.stringify(data).length === 2) { // Do something } 

Non sono sicuro se c’è qualche svantaggio di questo metodo.

onliner veloce per oggetti “dizionario”:

 function isEmptyDict(d){for (var k in d) return false; return true} 

È ansible scrivere un fallback se Array.isArray e Object.getOwnPropertyNames non sono disponibili

 XX.isEmpty = function(a){ if(Array.isArray(a)){ return (a.length==0); } if(!a){ return true; } if(a instanceof Object){ if(a instanceof Date){ return false; } if(Object.getOwnPropertyNames(a).length == 0){ return true; } } return false; } 

Immagina di avere gli oggetti qui sotto:

 var obj1= {}; var obj2= {test: "test"}; 

Non dimenticare che NON possiamo usare === firmare per testare l’uguaglianza di un object quando ottengono l’ereditarietà, quindi se usi ECMA 5 e la versione superiore di javascript, la risposta è semplice, puoi usare la funzione seguente:

 function isEmpty(obj) { //check if it's an Obj first var isObj = obj !== null && typeof obj === 'object' && Object.prototype.toString.call(obj) === '[object Object]'; if (isObj) { for (var o in obj) { if (obj.hasOwnProperty(o)) { return false; break; } } return true; } else { console.error("isEmpty function only accept an Object"); } } 

quindi il risultato come di seguito:

 isEmpty(obj1); //this returns true isEmpty(obj2); //this returns false isEmpty([]); // log in console: isEmpty function only accept an Object 

ecco un buon modo per farlo

 function isEmpty(obj) { if (Array.isArray(obj)) { return obj.length === 0; } else if (typeof obj === 'object') { for (var i in obj) { return false; } return true; } else { return !obj; } } 
 var hasOwnProperty = Object.prototype.hasOwnProperty; function isArray(a) { return Object.prototype.toString.call(a) === '[object Array]' } function isObject(a) { return Object.prototype.toString.call(a) === '[object Object]' } function isEmpty(a) { if (null == a || "" == a)return!0; if ("number" == typeof a || "string" == typeof a)return!1; var b = !0; if (isArray(a)) { if (!a.length)return!0; for (var c = 0; c < a.length; c++)isEmpty(a[c]) || (b = !1); return b } if (isObject(a)) { for (var d in a)hasOwnProperty.call(a, d) && (isEmpty(a[d]) || (b = !1)); return b } return!0 } 

Potrebbe essere tu puoi usare questa decisione:

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

Ho modificato il codice di Sean Vieira in base alle mie esigenze. null e undefined non contano come object e numeri, valori booleani e stringhe vuote restituiscono false.

 'use strict'; // Speed up calls to hasOwnProperty var hasOwnProperty = Object.prototype.hasOwnProperty; var isObjectEmpty = function(obj) { // null and undefined are not empty if (obj == null) return false; if(obj === false) return false; if(obj === true) return false; if(obj === "") return false; if(typeof obj === "number") { return false; } // Assume if it has a length property with a non-zero value // that that property is correct. if (obj.length > 0) return false; if (obj.length === 0) return true; // Otherwise, does it have any properties of its own? // Note that this doesn't handle // toString and valueOf enumeration bugs in IE < 9 for (var key in obj) { if (hasOwnProperty.call(obj, key)) return false; } return true; }; exports.isObjectEmpty = isObjectEmpty; 

un object è un array associativo, aumentato con un prototipo.

Il metodo Object.is () determina se due valori hanno lo stesso valore.

confronto di oggetti: –

 Object.is('LOL', 'LOL');// true Object.is(console, console);// true Object.is(null, null);// true Object.is('ROFL', 'LOL');// false Object.is([], []);// false Object.is(0, -0);// false Object.is(NaN, 0/0);// true if (!Object.is) { // do something } 
 funtion isEmpty(o,i) { for(i in o) { return!1 } return!0 } 
 if (Object.getOwnPropertyNames(obj1).length > 0) { alert('obj1 is empty!'); } 

ecco la mia soluzione

 function isEmpty(value) { if(Object.prototype.toString.call(value) === '[object Array]') { return value.length == 0; } else if(value != null && typeof value === 'object') { return Object.getOwnPropertyNames(value).length == 0; } else { return !(value || (value === 0)); } } 

chears