Pregunta ¿Cómo puedo verificar si un objeto tiene una propiedad en JavaScript?


¿Cómo puedo verificar 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?


1180
2017-09-25 19:27


origen


Respuestas:


Estoy realmente confundido por las respuestas que se han dado, la mayoría son simplemente incorrectas. Por supuesto, puede tener propiedades de objetos que tengan valores indefinidos, nulos o falsos. Así que simplemente reduciendo el control de propiedad a typeof this[property] o, peor aún, x.key le dará resultados completamente engañosos.

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 de prototipos), entonces object.hasOwnProperty es el camino a seguir. Todos los navegadores modernos lo admiten. (Faltaba en las versiones anteriores de Safari - 2.0.1 y anteriores, pero esas versiones del navegador rara vez se usan).

Si lo que estás buscando es que un objeto tenga una propiedad que sea iterable (cuando iteres sobre las propiedades del objeto, aparecerá) y luego haciendo: prop in object le dará su efecto deseado.

Desde el uso hasOwnProperty es probablemente lo que desea, y considerando que es posible que desee 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 de trabajo, navegador cruzado, para hasOwnProperty, con una advertencia: no puede distinguir entre casos en los que una propiedad idéntica se encuentra en el prototipo y en la instancia; simplemente 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.


1202
2017-09-25 21:52



Con Underscore.js o (aun mejor) lodash:

_.has(x, 'key');

Qué llamadas Object.prototype.hasOwnProperty, pero (a) es más corto de escribir, y (b) utiliza "una referencia segura para 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

235
2017-07-03 17:01



Nota: el siguiente es actualmente obsoleto en gran parte gracias al modo estricto, y hasOwnProperty. La solución correcta es usar el modo estricto y verificar la presencia de una propiedad usando obj.hasOwnProperty. Esta respuesta precede ambas cosas, al menos tan ampliamente implementadas (sí, es así de viejo). Tome lo siguiente como una nota histórica.


Tener en cuenta que undefined es (desafortunadamente) no una palabra reservada en JavaScript si no está utilizando 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 asegurar que undefined es actualmente indefinido, p. poniendo el código en una función que acepta un parámetro adicional, llamado undefined, eso no se pasa un valor. Para asegurarse de que no haya pasado un valor, puede llamarlo usted mismo de inmediato, p. Ej .:

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

108
2017-09-25 19:48



¿Qué pasa?

var x = {'key': 1};

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

93
2018-02-02 17:56



if (x.key !== undefined)

Armin Ronacher parece que ya tiene vencerme, 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 se señaló por Konrad Rudolph y Armin Ronacher sería:

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

35
2017-09-25 19:32



Puedes usar el in operador 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 usando un for - in bucle, y luego verifique 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 una for-in lazo. Además, si la propiedad enumerable está sombreando una propiedad no enumerable del prototipo, no se mostrará en Internet Explorer 8 y antes

Si desea una lista de todas las propiedades de 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. De lo contrario, devolverá el tipo de propiedad adecuado. Sin embargo, tenga en cuenta que esto no siempre es una forma válida de verificar si un objeto tiene una propiedad o no, porque podría tener una propiedad que está configurada como indefinida, en cuyo caso, utilizando typeof x.key aún devolvería verdadero (aunque la clave todavía esté en el objeto).

Actualización: puede verificar si existe una propiedad comparando con la propiedad javascript indefinida

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

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


30
2018-03-30 06:18



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

hasOwnProperty devuelve verdadero si el nombre de atributo que se le ha pasado se ha agregado al objeto. Es completamente independiente del valor real asignado a él, 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 prototipos tiene un atributo con el valor de indefinido? hasOwnProperty será falso, y también lo será !== undefined. Todavía, for..in todavía lo mostrará 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 ha sido adjuntado a un objeto o algo en su cadena de prototipo.


23
2017-09-26 09:16



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

if ('prop' in obj) { }

En general, no debería importar si la propiedad proviene 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 hash serían propiedades en el objeto y evitará las propiedades adicionales aportadas por el prototipo.

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


14
2018-05-21 15:57