Após uma solicitação AJAX, às vezes meu aplicativo pode retornar um objeto vazio, como:
var a = {};
Como posso verificar se é esse o caso?
if( Object.entries(a).length > 0){ //do }
Após uma solicitação AJAX, às vezes meu aplicativo pode retornar um objeto vazio, como:
var a = {};
Como posso verificar se é esse o caso?
if( Object.entries(a).length > 0){ //do }
Respostas:
ECMA 5+ :
// because Object.keys(new Date()).length === 0;
// we have to do some additional check
Object.keys(obj).length === 0 && obj.constructor === Object
Observe, no entanto, que isso cria uma matriz desnecessária (o valor de retorno de keys
).
Pré-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
; então essa resposta pode ser enganosa.
(new Date()).constructor === Date
ou vice-versa ({}).constructor === Object
.
Object.keys()
não verifica propriedades não enumeráveis ou símbolos. Você precisa usar Object.getOwnPropertyNames()
e em Object.getOwnPropertySymbols()
vez disso. Além disso, Object.getPrototypeOf()
é a maneira correta de obter o protótipo de um objeto. obj.constructor
pode ser facilmente forjado. Exemplo: function Foo() {} Foo.prototype.constructor = Object; (new Foo()).constructor === Object // true
.
Não há maneira fácil de fazer isso. Você terá que fazer um loop sobre as propriedades explicitamente:
function isEmpty(obj) {
for(var prop in obj) {
if(obj.hasOwnProperty(prop))
return false;
}
return true;
}
Se o suporte ao ECMAScript 5 estiver disponível, você poderá usar Object.keys()
:
function isEmpty(obj) {
return Object.keys(obj).length === 0;
}
isEmpty()
, então ele deve retornar false
se ele tem uma propriedade
Para aqueles que têm o mesmo problema, mas usam o jQuery, você pode usar o jQuery.isEmptyObject .
underscore.js
...
Esta é a minha solução preferida:
var obj = {};
return Object.keys(obj).length; //returns 0 if empty or an integer > 0 if non-empty
Object.keys(new Date()).length === 0
; então essa resposta pode ser enganosa.
new Date()
não é um objeto. nd = new Date(); nd.constructor === Object;
resulta em false
.
Você pode usar o Underscore.js .
_.isEmpty({}); // true
if(Object.getOwnPropertyNames(obj).length === 0){
//is empty
}
consulte http://bencollier.net/2011/04/javascript-is-an-object-empty/
Object.getOwnPropertyNames(new Date()).length === 0
; então essa resposta pode ser enganosa.
Que tal usar JSON.stringify? Está quase disponível em todos os navegadores modernos.
function isEmptyObject(obj){
return JSON.stringify(obj) === '{}';
}
Acabei de encontrar uma situação semelhante. Eu não queria usar JQuery e queria fazer isso usando Javascript puro.
E o que fiz foi usar a seguinte condição e funcionou para mim.
var obj = {};
if(JSON.stringify(obj) === '{}') { //This will check if the object is empty
//Code here..
}
Para não igual a, use o seguinte: JSON.stringify(obj) !== '{}'
Confira este JSFiddle
Pergunta antiga, mas só tinha o problema. Incluir JQuery não é realmente uma boa idéia se seu único objetivo é verificar se o objeto não está vazio. Em vez disso, entre no código do JQuery e você obterá a resposta:
function isEmptyObject(obj) {
var name;
for (name in obj) {
if (obj.hasOwnProperty(name)) {
return false;
}
}
return true;
}
Existe uma maneira simples se você estiver em um navegador mais recente.
Object.keys(obj).length == 0
Object.keys
é um método padrão, mas os objetos não possuem uma propriedade de chaves. Portanto, esse código reportará qualquer objeto como vazio, exceto que acidentalmente possui uma propriedade nomeada key
com um valor que novamente como uma propriedade nomeada length
que não é zero. Horrível!
Object.keys(new Date()).length === 0
; então essa resposta pode ser enganosa.
Hoje 2020.01.17 realizo testes no MacOs HighSierra 10.13.6 no Chrome v79.0, Safari v13.0.4 e Firefox v72.0, para soluções escolhidas.
Conclusões
for-in
(A, J, L, M) são mais rápidasJSON.stringify
(B, K) são lentasObject
(N) é lentaAbaixo no snippet são apresentadas 15 soluções. Se você deseja executar o teste de desempenho em sua máquina, clique AQUI .
O uso de Object.keys (obj) .length (como sugerido acima para ECMA 5+) é 10 vezes mais lento para objetos vazios! continue com a opção old school (for ... in).
Testado no Node, Chrome, Firefox e IE 9, fica evidente que, na maioria dos casos de uso:
Em termos de desempenho, use:
function isEmpty(obj) {
for (var x in obj) { return false; }
return true;
}
ou
function isEmpty(obj) {
for (var x in obj) { if (obj.hasOwnProperty(x)) return false; }
return true;
}
Veja resultados detalhados e código de teste em O objeto está vazio?
Object.keys
é lento, mas menos código. Em uma página pequena, onde isso é chamado ... talvez 10 vezes ... Isso ainda será mais lento, considerando o tempo de análise adicional do código adicional?
Você pode verificar a contagem das chaves do objeto:
if (Object.keys(a).length > 0) {
// not empty
}
Apenas uma solução alternativa. Seu servidor pode gerar alguma propriedade especial no caso de não haver dados?
Por exemplo:
var a = {empty:true};
Em seguida, você pode verificá-lo facilmente no seu código de retorno de chamada AJAX.
Outra maneira de verificar isso:
if (a.toSource() === "({})") // then 'a' is empty
EDIT : Se você usar qualquer biblioteca JSON (fe JSON.js), poderá tentar a função JSON.encode () e testar o resultado em relação à cadeia de valor vazia.
toSource()
é não-padrão e não funciona no IE ou Opera (e potencialmente outros navegadores eu não verificar)
toSource
propriedade na seção 15.2.4; de acordo com o MDC, foi introduzido no JS1.3 (ou seja, Netscape Navigator 4.06), mas NÃO está no ECMA-262, 3ª edição!
toSource()
é uma maneira horrível de fazer isso (como está JSON.encode()
). Ele precisa criar uma string que represente todo o objeto para verificar se está vazio. Existe a sobrecarga de converter coisas em seqüências de caracteres, mas além disso, será necessário converter um milhão de coisas se o seu objeto tiver um milhão de propriedades, enquanto apenas a observação de uma delas permitirá que você saiba que ela não está vazia.
Eu criei uma função completa para determinar se o objeto está vazio.
Ele usa Object.keys
da funcionalidade ECMAScript 5 (ES5), se possível, para obter o melhor desempenho (consulte a tabela de compatibilidade ) e fallbacks para a abordagem mais compatível para mecanismos mais antigos (navegadores).
/**
* 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;
}
}
Aqui está a essência deste código.
E aqui está o JSFiddle com demonstração e um teste simples.
Espero que ajude alguém. Felicidades!
Object.keys(new Date()).length === 0
; então essa resposta pode ser enganosa.
Eu estou usando isso.
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;
}
Por exemplo:
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;
Atualizar
OU
você pode usar a implementação jQuery de isEmptyObject
function isEmptyObject(obj) {
var name;
for (name in obj) {
return false;
}
return true;
}
O exemplo a seguir mostra como testar se um objeto JavaScript está vazio, se por vazio significa que não temos propriedades próprias.
O script funciona no 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
De acordo com a ES2017 especificação sobre Object.entries () , a verificação é simples de usar qualquer browser-- moderna
Object.entries({}).length === 0
Object.keys
ou Object.values
?
function isEmpty(obj) {
for(var i in obj) { return false; }
return true;
}
Object
com um método através da cadeia de protótipos, porque isso é enumerável e a for in
instrução faz um loop através de propriedades enumeráveis.
O jQuery possui uma função especial isEmptyObject()
para este caso:
jQuery.isEmptyObject({}) // true
jQuery.isEmptyObject({ foo: "bar" }) // false
Leia mais em http://api.jquery.com/jQuery.isEmptyObject/
Gostaria de verificar se tem pelo menos uma chave. Seria o suficiente para me dizer que não está vazio.
typeof obj !== "undefined" && Boolean(Object.keys(obj)[0])
false
valor? o resultado será false
incorreto.
Sob o capô, todos os métodos de verificação vazia em todas as bibliotecas usam a lógica de verificação de chaves de objetos. É uma maneira estranha de torná-lo compreensível, que você pode colocar em um método, descrito aqui .
for(key in obj){
//your work here.
break;
}
Que evoluiu no ES5 , agora você pode simplesmente verificar o comprimento das chaves do objeto, usando o Object.Keys
método que leva seu objeto como parâmetro:
if(Object.keys(obj).length > 0){
//do your work here
}
Ou se você estiver usando o Lodash (você deve estar) então.
_.isEmpty(obj) //==true or false
você pode usar esse código simples que não usou jQuery ou outras bibliotecas
var a=({});
//check is an empty object
if(JSON.stringify(a)=='{}') {
alert('it is empty');
} else {
alert('it is not empty');
}
A classe JSON e suas funções ( análise e stringify ) são muito úteis, mas tem alguns problemas com o IE7 que podem ser corrigidos com este código simples http://www.json.org/js.html .
Outra maneira simples (maneira mais simples):
você pode usar dessa maneira sem usar o objeto jQuery ou 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
Melhor maneira que eu encontrei:
function isEmpty(obj)
{
if (!obj)
{
return true;
}
if (!(typeof(obj) === 'number') && !Object.keys(obj).length)
{
return true;
}
return false;
}
Trabalha 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
if (!obj && obj !== 0)
.
Minha vez:
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
Acho que nem todos os navegadores implementam Object.keys()
atualmente.
Object.keys(new Date()).length === 0
; então essa resposta pode ser enganosa.
Se o jQuery e o navegador da web não estiverem disponíveis, também haverá uma função isEmpty no underscore.js.
_.isEmpty({}) // returns true
Além disso, ele não assume que o parâmetro de entrada seja um objeto. Para uma lista ou sequência ou indefinida, ela também girará a resposta correta.
Embargo! Cuidado com as limitações do 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 ) );
exibe
Cuidado !! obj NÃO está vazio! obj = {f: function () {}} JSON.stringify (obj) retorna {}
A resposta correta é:
const isEmptyObject = obj =>
Object.getOwnPropertyNames(obj).length === 0 &&
Object.getOwnPropertySymbols(obj).length === 0 &&
Object.getPrototypeOf(obj) === Object.prototype;
Isso verifica se:
Object.prototype
.Em outras palavras, o objeto é indistinguível de um criado com {}
.
Além da resposta de Thevs:
var o = {};
alert($.toJSON(o)=='{}'); // true
var o = {a:1};
alert($.toJSON(o)=='{}'); // false
é jquery + jquery.json
$.isEmptyObject()
, não perca ciclos com conversões não óbvias.
O Sugar.JS fornece objetos estendidos para esse fim. O código é limpo e simples:
Faça um objeto estendido:
a = Object.extended({})
Verifique o tamanho:
a.size()