¿Cómo verificar si el objeto tiene alguna propiedad en JavaScript?

Asumiendo que declaro

var ad = {}; 

¿Cómo puedo verificar si este objeto contendrá propiedades definidas por el usuario?

Puede recorrer las propiedades de su objeto de la siguiente manera:

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

Es importante utilizar el hasOwnProperty()método para determinar si el objeto tiene la propiedad especificada como una propiedad directa y no se hereda de la cadena de prototipos del objeto.

Editar

De los comentarios: puede poner ese código en una función y hacer que devuelva falso tan pronto como llegue a la parte donde está el comentario

Prueba de rendimiento

Prueba de Object.Keys vs For..In Al probar cualquier propiedad

Puede usar el Object.keysmétodo incorporado para obtener una lista de claves en un objeto y probar su longitud.

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  
}

¿Qué hay de hacer una función simple?

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

La hasOwnPropertyllamada al método directamente en el Object.prototypees solo para agregar un poco más de seguridad , imagine lo siguiente usando una obj.hasOwnProperty(...)llamada normal :

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

Nota: _{(para el futuro)} El método anterior se basa en la for...indeclaración, y esta declaración solo itera sobre las propiedades enumerables , en el Estándar ECMAScript implementado actualmente más ampliamente (3a edición) el programador no tiene ninguna forma de crear propiedades no enumerables .

Sin embargo, esto ha cambiado ahora con ECMAScript 5th Edition , y podemos crear propiedades no enumerables, no editables o no eliminables, por lo que el método anterior puede fallar , por ejemplo:

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!!

Una solución ECMAScript 5 a este problema sería:

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

El Object.getOwnPropertyNamesmétodo devuelve un que Arraycontiene los nombres de todas las propiedades propias de un objeto, enumerable o no , este método está siendo implementado ahora por proveedores de navegadores, ya está en Chrome 5 Beta y las últimas versiones nocturnas de WebKit.

Object.defineProperty también está disponible en esos navegadores y en las últimas versiones de Firefox 3.7 Alpha.

Con jQuery puedes usar:

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

A partir de jQuery 1.4, este método verifica tanto las propiedades del objeto como las propiedades heredadas de los prototipos (ya que no utiliza hasOwnProperty).

Con ECMAScript 5th Edition en navegadores modernos (IE9 +, FF4 +, Chrome5 +, Opera12 +, Safari5 +) puede usar el método incorporado Object.keys :

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

O simplemente JavaScript antiguo:

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

Los navegadores más recientes (y node.js) admiten Object.keys () que devuelve una matriz con todas las claves en su objeto literal para que pueda hacer lo siguiente:

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

Soporte de 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

Si está utilizando underscore.js, puede usar la función _.isEmpty :

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

Si está dispuesto a usar lodash , puede usar el somemétodo.

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

Ver este pequeño ejemplo de jsbin

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

Si tiene que estar seguro y buscar prototipos de objetos (algunas bibliotecas los agregan y no están allí de forma predeterminada):

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

Miembro significa propiedad de miembro, variable de miembro, como quiera llamarlo> _>

El código anterior devolverá TODO, incluido toString ... Si solo desea ver si el prototipo del objeto se ha extendido:

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 si el miembro del objeto ficticio tiene el mismo tipo que el miembro de nuestro objeto de prueba. Si es una extensión, el tipo de miembro de dummyobject debe 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

Simple, funciona en todos los navegadores, y aunque técnicamente es un bucle para todas las teclas del objeto, NO recorre todas ellas ... o hay 0 y el bucle no se ejecuta o hay algunos y se rompe después del primer uno (porque todo lo que estamos comprobando es si hay CUALQUIER ... entonces, ¿por qué continuar?)

Respuesta muy tardía, pero así es como puedes manejarlo con prototipos.

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

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

Cuando esté seguro de que el objeto es definido por el usuario, la forma más fácil de determinar si UDO está vacío, sería el siguiente código:

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

Aunque este método es (por naturaleza) deductivo, es el más rápido y más rápido posible.

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

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

ps:! no lo use en objetos definidos por el navegador.

Respuesta tardía, pero algunos marcos manejan los objetos como enumerables. Por lo tanto, bob.js puede hacerlo así:

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

Puedes usar lo siguiente:

Doble explosión búsqueda de propiedades

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

hasOwnProperty Esto es algo que solía usar:

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

Sin embargo, JavaScript decidió no proteger el nombre del método, por lo que podría ser alterado.

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

utilería en 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
}

Sin embargo, no comprueba si es nulo.

Creo que esta es la mejor manera.

en 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:

El nombre existe en myObject

Aquí hay un enlace que entra en más detalles sobre el operador in: Determinar si existe una propiedad de objeto

Función 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

Ejemplos:

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

¿Qué tal esto?

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