una - saber si un objeto esta vacio javascript

¿Cómo verifico si un objeto tiene una propiedad en JavaScript?

Question

¿Cómo verifico si un objeto tiene una propiedad en JavaScript?

Considerar:

x = {''key'': 1};
if ( x.hasOwnProperty(''key'') ) {
    //Do this
}

¿Es esa la mejor manera de hacerlo?

Answer 1

¿Qué pasa?

var x = {''key'': 1};

if (''key'' in x) {
    console.log(''has'');
}

Answer 2

Bien, parece que tuve la respuesta correcta a menos que, si no quieres las propiedades heredadas:

if (x.hasOwnProperty(''key''))

Aquí hay algunas otras opciones para incluir propiedades heredadas:

if (x.key) // Quick and dirty, but it does the same thing as below.

if (x.key !== undefined)

Answer 3

Con Underscore.js o ( aún mejor ) lodash :

_.has(x, ''key'');

Que llama a Object.prototype.hasOwnProperty , pero (a) es más corto de escribir, y (b) usa "una referencia segura a hasOwnProperty " (es decir, funciona incluso si hasOwnProperty se sobrescribe).

En particular, lodash define _.has como:

   function has(object, key) {
      return object ? hasOwnProperty.call(object, key) : false;
   }
   // hasOwnProperty = Object.prototype.hasOwnProperty

Answer 4

Con el riesgo de una votación masiva, aquí hay otra opción para un caso específico. :)

Si desea probar un miembro en un objeto y quiere saber si se ha establecido en algo diferente a:

• ''''
• falso
• nulo
• indefinido
• 0 ...

entonces puedes usar:

var foo = {};
foo.bar = "Yes, this is a proper value!";
if (!!foo.bar) {
        // member is set, do something
}

Answer 5

Estoy realmente confundido por las respuestas que se han dado, la mayoría de ellas son totalmente incorrectas. Por supuesto, puede tener propiedades de objeto que tienen valores no definidos, nulos o falsos. Entonces, simplemente reduciendo la verificación de propiedad a tipo de typeof this[property] o, peor aún, x.key le dará resultados totalmente x.key .

Depende de lo que estés buscando. Si desea saber si un objeto contiene físicamente una propiedad (y no proviene de algún lugar de la cadena del prototipo), entonces object.hasOwnProperty es el camino a seguir. Todos los navegadores modernos lo soportan. (Faltaba en versiones anteriores de Safari - 2.0.1 y anteriores - pero esas versiones del navegador ya casi no se usan).

Si lo que está buscando es si un objeto tiene una propiedad en él que es iterable (cuando se repite en las propiedades del objeto, aparecerá), entonces: prop in object le dará el efecto deseado.

Dado que usar hasOwnProperty es probablemente lo que desea, y considerando que puede querer un método alternativo, le presento la siguiente solución:

var obj = {
    a: undefined,
    b: null,
    c: false
};

// a, b, c all found
for ( var prop in obj ) {
    document.writeln( "Object1: " + prop );
}

function Class(){
    this.a = undefined;
    this.b = null;
    this.c = false;
}

Class.prototype = {
    a: undefined,
    b: true,
    c: true,
    d: true,
    e: true
};

var obj2 = new Class();

// a, b, c, d, e found
for ( var prop in obj2 ) {
    document.writeln( "Object2: " + prop );
}

function hasOwnProperty(obj, prop) {
    var proto = obj.__proto__ || obj.constructor.prototype;
    return (prop in obj) &&
        (!(prop in proto) || proto[prop] !== obj[prop]);
}

if ( Object.prototype.hasOwnProperty ) {
    var hasOwnProperty = function(obj, prop) {
        return obj.hasOwnProperty(prop);
    }
}

// a, b, c found in modern browsers
// b, c found in Safari 2.0.1 and older
for ( var prop in obj2 ) {
    if ( hasOwnProperty(obj2, prop) ) {
        document.writeln( "Object2 w/ hasOwn: " + prop );
    }
}

Lo anterior es una solución hasOwnProperty , de navegador hasOwnProperty para hasOwnProperty , con una advertencia: no puede distinguir entre los casos en que una propiedad idéntica está en el prototipo y en la instancia, solo se supone que proviene del prototipo. Podría cambiarlo para que sea más indulgente o estricto, según su situación, pero al menos esto debería ser más útil.

Answer 6

Existe el método "hasOwnProperty" existe en el objeto, pero no se recomienda llamar directamente a este método porque puede ser que a veces el objeto sea nulo o exista alguna propiedad en el objeto como: { hasOwnProperty: false }

Así que mejor manera sería:

// good
var obj = {"bar": "here bar desc"}
console.log(Object.prototype.hasOwnProperty.call(obj, "bar"));

// best
const has = Object.prototype.hasOwnProperty; // cache the lookup once, in module scope.
console.log(has.call(obj, "bar"));

Answer 7

No haga este object.hasOwnProperty(key)) , es realmente malo porque estos métodos pueden verse sombreados por las propiedades del objeto en cuestión: considere { hasOwnProperty: false } - o, el objeto puede ser un objeto nulo (Object.create(null)) .

La mejor manera es hacer Object.prototype.hasOwnProperty.call(object, key) o:

const has = Object.prototype.hasOwnProperty; // cache the lookup once, in module scope.
/* or */
import has from ''has''; // https://www.npmjs.com/package/has
// ...
console.log(has.call(object, key));

Answer 8

Otra forma relativamente simple es usar Object.keys . Esto devuelve una array que significa que obtiene todas las características de una matriz.

var noInfo = {};
var info = {something: ''data''};

Object.keys(noInfo).length //returns 0 or false
Object.keys(info).length //returns 1 or true

Aunque estamos en un mundo con gran soporte de navegador. Debido a que esta pregunta es tan antigua, pensé que agregaría esto: es seguro de usar a partir de JS v1.8.5

Answer 9

Para probar objetos simples use: if (obj[x] !== undefined)

Si no sabe qué tipo de objeto se usa: if (obj.hasOwnProperty(x))

Todas las demás opciones son más lentas ..

Detalles

Evaluación de rendimiento de 100,000,000 ciclos bajo Nodejs a las 5 opciones sugeridas por otros aquí:

function hasKey1(k,o) { return (x in obj); }
function hasKey2(k,o) { return (obj[x]); }
function hasKey3(k,o) { return (obj[x] !== undefined); }
function hasKey4(k,o) { return (typeof(obj[x]) !== ''undefined''); }
function hasKey5(k,o) { return (obj.hasOwnProperty(x)); }

La evaluación nos dice que, a menos que queramos verificar específicamente la cadena del prototipo del objeto, así como el objeto en sí, no debemos usar la forma común: if (X in Obj)... Es entre 2 y 6 veces más lento dependiendo de la caso de uso

hasKey1 execution time: 4s 510.427785ms
hasKey2 execution time: 0s 904.374806ms
hasKey3 execution time: 0s 760.336193ms
hasKey4 execution time: 0s 935.19901ms
hasKey5 execution time: 2s 148.189608ms

En pocas palabras, si su Obj no es necesariamente un objeto simple y desea evitar verificar la cadena del prototipo del objeto y asegurarse de que x sea propiedad de Obj directamente, use ''if (obj.hasOwnProperty (x)) ...''.

De lo contrario, cuando use un objeto simple y no esté preocupado por la cadena de prototipo del objeto, usar if (typeof(obj[x]) !== ''undefined'')... es la forma más segura y rápida.

Si usas un objeto simple como una tabla hash y nunca haces nada rizado, usaría if (obj[x])... ya que lo encuentro mucho más legible.

Que te diviertas.

Answer 10

Por qué complicar demasiado las cosas cuando puedes hacer:

var isProperty =  (objectname.keyname || "") ? true : false;

Simple y claro para la mayoría de los casos ...

Answer 11

Puede usar el operador in para verificar si la propiedad existe en un objeto:

x = {''key'': 1};
alert("key" in x);

También puede recorrer todas las propiedades del objeto utilizando un bucle for - in , y luego verificar la propiedad específica:

for (prop in x) {
    if (prop == "key") {
        //Do something
    }
}

Debe considerar si esta propiedad de objeto es enumerable o no, porque las propiedades no enumerables no se mostrarán en un bucle for-in . Además, si la propiedad enumerable está siguiendo una propiedad no enumerable del prototipo, no se mostrará en Internet Explorer 8 y versiones anteriores.

Si desea una lista de todas las propiedades de la instancia, ya sean enumerables o no, puede usar

Object.getOwnPropertyNames(x);

Esto devolverá una matriz de nombres de todas las propiedades que existen en un objeto.

Finalmente, puede usar el operador typeof para verificar directamente el tipo de datos de la propiedad del objeto:

if (typeof x.key == "undefined") {
    alert("undefined");
}

Si la propiedad no existe en el objeto, devolverá la cadena indefinida. En caso contrario, devolverá el tipo de propiedad correspondiente. Sin embargo, tenga en cuenta que esta no es siempre una forma válida de verificar si un objeto tiene una propiedad o no, ya que podría tener una propiedad que está configurada como indefinida, en cuyo caso, el uso de typeof x.key seguiría siendo verdadero (aunque la clave aún está en el objeto).

Actualización: puede verificar si existe una propiedad comparándola con la propiedad javascript no definida

if (x.key === undefined) {
    alert("undefined");
}

Esto debería funcionar a menos que la clave se haya establecido específicamente como undefined en el objeto x

Answer 12

Sí, lo es :) Creo que también puedes hacer Object.prototype.hasOwnProperty.call(x, ''key'') que también debería funcionar si x tiene una propiedad llamada hasOwnProperty :)

Pero eso prueba las propiedades propias. Si desea comprobar si tiene una propiedad que también puede ser heredada, puede usar typeof x.foo != ''undefined'' .

Answer 13

Si está buscando una propiedad, entonces "NO". Usted quiere:

if (''prop'' in obj) { }

En general, no debe importarle si la propiedad proviene o no del prototipo o del objeto.

Sin embargo, debido a que usó ''clave'' en su código de muestra, parece que está tratando el objeto como un hash, en cuyo caso su respuesta tendría sentido. Todas las claves de hashes serían propiedades en el objeto, y usted evita las propiedades adicionales aportadas por el prototipo.

La respuesta de John Resig fue muy completa, pero pensé que no estaba clara. Especialmente con cuándo usar "prop ''en obj".

Answer 14

Si la clave que está verificando está almacenada en una variable , puede verificarla así:

x = {''key'': 1};
y = ''key'';
x[y];

Answer 15

Solución ECMA Script 6 con reflejo. Crear envoltorio como:

/**
Gets an argument from array or object.
The possible outcome:
- If the key exists the value is returned.
- If no key exists the default value is returned.
- If no default value is specified an empty string is returned.
@param obj    The object or array to be searched.
@param key    The name of the property or key.
@param defVal Optional default version of the command-line parameter [default ""]
@return The default value in case of an error else the found parameter.
*/
function getSafeReflectArg( obj, key, defVal) {
   "use strict";
   var retVal = (typeof defVal === ''undefined'' ? "" : defVal);
   if ( Reflect.has( obj, key) ) {
       return Reflect.get( obj, key);
   }
   return retVal;
}  // getSafeReflectArg

Answer 16

También puedes usar el objeto ES6 Reflect :

x = {''key'': 1};
Reflect.has( x, ''key''); // returns true

La documentación sobre MDN para Reflect.has se puede encontrar here .

El Reflect.has() estático Reflect.has() funciona como el developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… como una función.

Answer 17

Vamos a cortar algo de confusión aquí. Primero, simplifiquemos suponiendo que hasOwnProperty ya existe; Esto es cierto para la gran mayoría de los navegadores actuales en uso.

hasOwnProperty devuelve verdadero si el nombre del atributo que se le pasa se ha agregado al objeto. Es totalmente independiente del valor real que se le asigna, que puede ser exactamente undefined .

Por lo tanto:

var o = {}
o.x = undefined

var a = o.hasOwnProperty(''x'')  // a is true
var b = o.x === undefined // b is also true

Sin embargo:

var o = {}

var a = o.hasOwnProperty(''x'')  // a is now false
var b = o.x === undefined // b is still true

El problema es ¿qué sucede cuando un objeto en la cadena de prototipo tiene un atributo con el valor de indefinido? hasOwnProperty será falso para él, y también lo será !== undefined . Sin embargo, for..in todavía lo incluirá en la enumeración.

La conclusión es que no hay una forma de navegador cruzado (ya que Internet Explorer no expone __prototype__ ) para determinar que un identificador específico no se ha adjuntado a un objeto ni a nada en su cadena de prototipos.

Answer 18

hasOwnProperty "se puede usar para determinar si un objeto tiene la propiedad especificada como una propiedad directa de ese objeto; a diferencia del operador in , este método no comprueba la cadena del prototipo del objeto".

Entonces, lo más probable es que, por lo que parece por tu pregunta, no quieras usar hasOwnProperty, que determina si la propiedad existe como adjunta directamente al objeto en sí ,.

Si desea determinar si la propiedad existe en la cadena de prototipos que desea utilizar, como:

if( prop in object ){ // do something }

Espero que esto ayude.

Answer 19

usé esto que es mucho me ayudó si tienes un objeto dentro de un objeto

if(typeof(obj["key"])=="string"){
    alert("property");
}

Answer 20

object.hasOwnProperty(property) utilizar el método object.hasOwnProperty(property) . Devuelve verdadero si el objeto tiene la propiedad y falso si el objeto no lo tiene.

Answer 21

Nota : lo siguiente está hoy en día en gran parte obsoleto gracias al modo estricto, y tiene hasOwnProperty . La solución correcta es usar el modo estricto y verificar la presencia de una propiedad usando obj.hasOwnProperty . Esta respuesta es anterior a estas dos cosas, al menos tan ampliamente implementada (sí, es tan antigua). Tome lo siguiente como una nota histórica.

Tenga en cuenta que undefined (desafortunadamente) no es una palabra reservada en JavaScript si no está usando el modo estricto. Por lo tanto, alguien (alguien más, obviamente) podría tener la gran idea de redefinirlo, rompiendo su código.

Un método más robusto es por lo tanto lo siguiente:

if (typeof(x.attribute) !== ''undefined'')

Por otro lado, este método es mucho más detallado y también más lento. : - /

Una alternativa común es asegurarse de que undefined sea realmente no definido, por ejemplo, al colocar el código en una función que acepte un parámetro adicional, llamado undefined , que no pase un valor. Para asegurarse de que no se pasa un valor, puede llamarlo de inmediato, por ejemplo:

(function (undefined) {
    … your code …
    if (x.attribute !== undefined)
        … mode code …
})();

Answer 22

if (typeof x.key != "undefined") {

}

Porque

if (x.key)

falla si x.key resuelve en false (por ejemplo, x.key = "" ).

Answer 23

if (x.key !== undefined)

Armin Ronacher parece que ya me ha vencido , pero:

Object.prototype.hasOwnProperty = function(property) {
    return this[property] !== undefined;
};

x = {''key'': 1};

if (x.hasOwnProperty(''key'')) {
    alert(''have key!'');
}

if (!x.hasOwnProperty(''bar'')) {
    alert(''no bar!'');
}

Una solución más segura, pero más lenta, como lo señalan y Armin Ronacher sería:

Object.prototype.hasOwnProperty = function(property) {
    return typeof this[property] !== ''undefined'';
};