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

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

Considerar:

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

¿Es esa la mejor manera de hacerlo?

Estoy realmente confundido por las respuestas que se han dado, la mayoría de ellas son completamente incorrectas. Por supuesto, puede tener propiedades de objeto que tengan valores indefinidos, nulos o falsos. Por lo tanto, simplemente reducir el control de la propiedad typeof this[property]o, lo que es peor, x.keyle 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 ese object.hasOwnPropertyes 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 más).

Si lo que está buscando es si un objeto tiene una propiedad que es iterable (cuando itera sobre las propiedades del objeto, aparecerá), entonces hacer: prop in objectle dará el efecto deseado.

Dado que usar hasOwnPropertyes probablemente lo que desea, y teniendo en cuenta 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 funcional para todos los navegadores, hasOwnPropertycon una advertencia: es incapaz de distinguir entre casos en los que hay una propiedad idéntica en el prototipo y en la instancia, simplemente supone que proviene del prototipo. Puede cambiarlo para que sea más indulgente o estricto, según su situación, pero al menos esto debería ser más útil.

Con Underscore.js o ( incluso mejor ) lodash:

_.has(x, 'key');

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

En particular, lodash define _.hascomo:

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

¿Qué pasa?

var x = {'key': 1};

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

Nota : lo siguiente es hoy en día bastante obsoleto 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 es anterior a estas dos cosas, al menos tan ampliamente implementadas (sí, es tan antigua). Tome lo siguiente como nota histórica.

Tenga en cuenta que undefined(desafortunadamente) no es 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.

Por lo tanto, un método más robusto es el 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 en realidad no undefinedesté definida, por ejemplo, al poner el código en una función que acepte un parámetro adicional, llamado , al que no se le pasa un valor. Para asegurarse de que no se le pase un valor, puede llamarlo usted mismo de inmediato, por ejemplo:undefined

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

if (x.key !== undefined)

Armin Ronacher parece que ya me ganó , 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 más seguro, pero la solución más lenta, como se ha señalado por Konrad Rudolph y Armin Ronacher sería la siguiente:

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

Puede usar el inoperador 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 - inciclo 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 for-inbucle. Además, si la propiedad enumerable sombrea una propiedad no enumerable del prototipo, no aparecerá en Internet Explorer 8 y versiones anteriores.

Si desea una lista de todas las propiedades de instancia, 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 apropiado. Sin embargo, tenga en cuenta que esta no siempre es 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 typeof x.keyaún devolvería verdadero (aunque la clave aún esté en el objeto).

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

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

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

Veamos un poco de confusión aquí. Primero, simplifiquemos asumiendo que hasOwnPropertyya existe; Esto es cierto para la gran mayoría de los navegadores actuales en uso.

hasOwnPropertydevuelve verdadero si el nombre del atributo que se le ha pasado se ha agregado al objeto. Es completamente 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 del prototipo tiene un atributo con el valor de indefinido? hasOwnPropertyserá falso por eso, y también lo será !== undefined. Todavía,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.

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

if ('prop' in obj) { }

En general, no debería 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 hash serían propiedades en el objeto, y 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".

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

Si no sabe qué tipo de objeto es, use: if (obj.hasOwnProperty(x))

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

Detalles

Evaluación de desempeño 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 de prototipos del objeto, así como el objeto en sí, no deberíamos usar la forma común: if (X in Obj)... es entre 2 y 6 veces más lento dependiendo del 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 de prototipos del objeto y asegurarse de que x es propiedad de Obj directamente, use 'if (obj.hasOwnProperty (x)) ...'.

De lo contrario, cuando se usa un objeto simple y no se preocupa por la cadena de prototipos del objeto, el uso if (typeof(obj[x]) !== 'undefined')...es la forma más segura y rápida.

Si usa un objeto simple como una tabla hash y nunca hace nada rizado, lo usaría if (obj[x])...porque me parece mucho más legible.

Que te diviertas.

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

Pero eso prueba las propiedades propias. Si desea verificar si tiene una propiedad que también se puede incluir, puede usarla typeof x.foo != 'undefined'.

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

}

Porque

if (x.key)

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

También puede usar el Reflectobjeto ES6 :

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

La documentación sobre MDN para Reflect.hasse puede encontrar aquí .

El Reflect.has()método estático funciona como el operador in como una función.

OK, parece que tuve la respuesta correcta a menos que no desee propiedades heredadas:

if (x.hasOwnProperty('key'))

Estas son 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)

No haga esto object.hasOwnProperty(key)), es realmente malo porque estos métodos pueden estar 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));

Otra forma relativamente simple es usar Object.keys. Esto devuelve un valor arrayque significa que obtienes 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 para navegadores. Debido a que esta pregunta es tan antigua, pensé agregar esto: es seguro de usar a partir de JS v1.8.5

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

Lo más probable es que, para lo que parece su pregunta, no desee 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.

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

Si desea probar un miembro en un objeto y desea 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
}

Solución ECMA Script 6 con reflect. Crear envoltura 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

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

Entonces, la 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"));

Puede usar los siguientes enfoques:

var obj = {a:1}
console.log('a' in obj)               //1
console.log(obj.hasOwnProperty('a'))  //2
console.log(Boolean(obj.a))         //3

La diferencia entre los siguientes enfoques es la siguiente:

1. En el primer y tercer enfoque, no solo buscamos en el objeto sino también en su cadena prototípica. Si el objeto no tiene la propiedad, pero la propiedad está presente en su cadena de prototipo, dará verdadero.

 var obj = {
      a:2,
      __proto__ :{b:2}
    }

    console.log('b' in obj)
    console.log(Boolean(obj.b))

2. El segundo enfoque verificará solo sus propias propiedades. Ex -

var obj = {
      a:2,
      __proto__ :{b:2}
    }

    console.log(obj.hasOwnProperty('b'))

3. La diferencia entre el primero y el tercero es que si hay una propiedad que tiene un valor indefinido, el tercer enfoque dará falso mientras que el primero dará verdadero.

var obj = {
      b : undefined
    }
    console.log(Boolean(obj.b))
    console.log('b' in obj);

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

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

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

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