Como verificar se o objeto tem alguma propriedade em JavaScript?

Supondo que eu declaro

var ad = {}; 

Como posso verificar se este objeto contém propriedades definidas pelo usuário?

Você pode percorrer as propriedades do seu objeto da seguinte maneira:

for(var prop in ad) {
    if (ad.hasOwnProperty(prop)) {
        // handle prop as required
    }
}

É importante usar o hasOwnProperty()método para determinar se o objeto tem a propriedade especificada como uma propriedade direta e não herdada da cadeia de protótipos do objeto.

Editar

Dos comentários: você pode colocar esse código em uma função e fazê-lo retornar falso assim que chegar à parte em que há o comentário

Teste de performance

Test Of Object.Keys vs For..In Ao testar qualquer propriedade

Você pode usar o Object.keysmétodo interno para obter uma lista de chaves em um objeto e testar seu comprimento.

var x = {};
// some code where value of x changes and than you want to check whether it is null or some object with values

if(Object.keys(x).length > 0){
 // Your code here if x has some properties  
}

Que tal criar uma função simples?

function isEmptyObject(obj) {
  for(var prop in obj) {
    if (Object.prototype.hasOwnProperty.call(obj, prop)) {
      return false;
    }
  }
  return true;
}

isEmptyObject({}); // true
isEmptyObject({foo:'bar'});  // false

A hasOwnPropertychamada de método diretamente no Object.prototypeé apenas para adicionar um pouco mais de segurança , imagine o seguinte usando uma obj.hasOwnProperty(...)chamada normal :

isEmptyObject({hasOwnProperty:'boom'});  // false

Nota: _{(para o futuro)} O método acima baseia-se na for...indeclaração, e esta itera apenas as propriedades enumeráveis , no ECMAScript Standard (3ª edição) atualmente mais implementado atualmente, o programador não tem como criar propriedades não enumeráveis .

No entanto, isso mudou agora com o ECMAScript 5th Edition , e somos capazes de criar propriedades não enumeráveis, não graváveis ​​ou não excluídas, para que o método acima possa falhar , por exemplo:

var obj = {};
Object.defineProperty(obj, 'test', { value: 'testVal', 
  enumerable: false,
  writable: true,
  configurable: true
});
isEmptyObject(obj); // true, wrong!!
obj.hasOwnProperty('test'); // true, the property exist!!

Uma solução ECMAScript 5 para esse problema seria:

function isEmptyObject(obj) {
  return Object.getOwnPropertyNames(obj).length === 0;
}

O Object.getOwnPropertyNamesmétodo retorna e Arraycontém os nomes de todas as propriedades próprias de um objeto, enumeráveis ​​ou não ; esse método está sendo implementado agora pelos fornecedores de navegadores, já está no Chrome 5 Beta e nas últimas versões do WebKit Nightly Builds.

Object.defineProperty também está disponível nesses navegadores e nas versões mais recentes do Firefox 3.7 Alpha.

Com o jQuery você pode usar:

$.isEmptyObject(obj); // Returns: Boolean

A partir do jQuery 1.4, esse método verifica as propriedades no próprio objeto e as propriedades herdadas dos protótipos (na medida em que ele não usa hasOwnProperty).

Com o ECMAScript 5th Edition em navegadores modernos (IE9 +, FF4 +, Chrome5 +, Opera12 +, Safari5 +), você pode usar o método Object.keys incorporado :

var obj = { blah: 1 };
var isEmpty = !Object.keys(obj).length;

Ou JavaScript antigo simples:

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

Os navegadores mais recentes (e node.js) suportam Object.keys (), que retorna uma matriz com todas as chaves no literal do seu objeto, para que você possa fazer o seguinte:

var ad = {}; 
Object.keys(ad).length;//this will be 0 in this case

Suporte ao navegador: Firefox 4, Chrome 5, Internet Explorer 9, Opera 12, Safari 5

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

Se você estiver usando underscore.js, poderá usar a função _.isEmpty :

var obj = {};
var emptyObject = _.isEmpty(obj);

Se você estiver disposto a usar o lodash , poderá usar o somemétodo

_.some(obj) // returns true or false

Veja este pequeno exemplo de jsbin

for (var hasProperties in ad) break;
if (hasProperties)
    ... // ad has properties

Se você precisar estar seguro e verificar os protótipos de objetos (eles são adicionados por determinadas bibliotecas e não existem por padrão):

var hasProperties = false;
for (var x in ad) {
    if (ad.hasOwnProperty(x)) {
        hasProperties = true;
        break;
    }
}
if (hasProperties)
    ... // ad has properties

for(var memberName in ad)
{
  //Member Name: memberName
  //Member Value: ad[memberName]
}

Membro significa propriedade de membro, variável de membro, como você quiser chamá-lo> _>

O código acima retornará TUDO, incluindo toString ... Se você quiser apenas ver se o protótipo do objeto foi estendido:

var dummyObj = {};  
for(var memberName in ad)
{
  if(typeof(dummyObj[memberName]) == typeof(ad[memberName])) continue; //note A
  //Member Name: memberName
  //Member Value: ad[memberName]

}

Nota A: Verificamos se o membro do objeto fictício tem o mesmo tipo que o membro do objeto de teste. Se for uma extensão, o tipo de membro do dummyobject deve ser "indefinido"

var hasAnyProps = false; for (var key in obj) { hasAnyProps = true; break; }
// as of this line hasAnyProps will show Boolean whether or not any iterable props exist

Simples, funciona em todos os navegadores e, embora tecnicamente seja um loop para todas as chaves do objeto, NÃO repassa todas elas ... ou há 0 e o loop não roda ou há algumas e quebra após a primeira um (porque tudo o que estamos verificando é se há QUALQUER ... então por que continuar?)

Resposta muito tardia, mas é assim que você pode lidar com isso com protótipos.

Array.prototype.Any = function(func) {
    return this.some(func || function(x) { return x });
}

Object.prototype.IsAny = function() {
    return Object.keys(this).Any();
}

Quando a certeza de que o objeto é definido pelo usuário, a maneira mais fácil de determinar se o UDO está vazio é o seguinte código:

isEmpty=
/*b.b Troy III p.a.e*/
function(x,p){for(p in x)return!1;return!0};

Embora esse método seja (por natureza) dedutivo, é o mais rápido e o mais rápido possível.

a={};
isEmpty(a) >> true

a.b=1
isEmpty(a) >> false 

ps:! não o use em objetos definidos pelo navegador.

Resposta tardia, mas algumas estruturas manipulam objetos como enumeráveis. Portanto, o bob.js pode fazer o seguinte:

var objToTest = {};
var propertyCount = bob.collections.extend(objToTest).count();

Você pode usar o seguinte:

Double bang !! pesquisa de propriedade

var a = !![]; // true
var a = !!null; // false

hasOwnProperty Isso é algo que eu costumava usar:

var myObject = {
  name: 'John',
  address: null
};
if (myObject.hasOwnProperty('address')) { // true
  // do something if it exists.
}

No entanto, o JavaScript decidiu não proteger o nome do método, para que pudesse ser adulterado.

var myObject = {
  hasOwnProperty: 'I will populate it myself!'
};

prop em myObject

var myObject = {
  name: 'John',
  address: null,
  developer: false
};
'developer' in myObject; // true, remember it's looking for exists, not value.

tipo de

if (typeof myObject.name !== 'undefined') {
  // do something
}

No entanto, ele não verifica se há nulo.

Eu acho que esse é o melhor caminho.

no operador

var myObject = {
  name: 'John',
  address: null
};

if('name' in myObject) {
  console.log("Name exists in myObject");
}else{
  console.log("Name does not exist in myObject");
}

resultado:

O nome existe em myObject

Aqui está um link que entra em mais detalhes sobre o operador in: Determinando se existe uma propriedade de objeto

Função ES6

/**
 * Returns true if an object is empty.
 * @param  {*} obj the object to test
 * @return {boolean} returns true if object is empty, otherwise returns false
 */
const pureObjectIsEmpty = obj => obj && obj.constructor === Object && Object.keys(obj).length === 0

Exemplos:

let obj = "this is an object with String constructor"
console.log(pureObjectIsEmpty(obj)) // empty? true

obj = {}
console.log(pureObjectIsEmpty(obj)) // empty? true

obj = []
console.log(pureObjectIsEmpty(obj)) // empty? true

obj = [{prop:"value"}]
console.log(pureObjectIsEmpty(obj)) // empty? true

obj = {prop:"value"}
console.log(pureObjectIsEmpty(obj)) // empty? false

Que tal agora?

var obj = {},
var isEmpty = !obj;
var hasContent = !!obj