¿Cómo verifico si existe una clave particular en un objeto o matriz de JavaScript?

Si no existe una clave e intento acceder a ella, ¿devolverá falso? O arrojar un error?

Verificar la indefinición no es una forma precisa de probar si existe una clave. ¿Qué pasa si la clave existe pero el valor es realmente undefined?

var obj = { key: undefined };
console.log(obj["key"] !== undefined); // false, but the key exists!

En su lugar, debe utilizar el in operador:

var obj = { key: undefined };
console.log("key" in obj); // true, regardless of the actual value

Si desea verificar si una clave no existe, recuerde usar paréntesis:

var obj = { not_key: undefined };
console.log(!("key" in obj)); // true if "key" doesn't exist in object
console.log(!"key" in obj);   // Do not do this! It is equivalent to "false in obj"

O, si desea probar particularmente las propiedades de la instancia del objeto (y no las propiedades heredadas), use hasOwnProperty:

var obj = { key: undefined };
console.log(obj.hasOwnProperty("key")); // true

Para la comparación de rendimiento entre los métodos que se in, hasOwnProperty y la clave es undefinedver esta punto de referencia:

Respuesta rápida

¿Cómo verifico si existe una clave particular en un objeto o matriz de JavaScript? Si no existe una clave y trato de acceder a ella, ¿devolverá falso? O arrojar un error?

Acceder directamente a una propiedad que falta utilizando el estilo de matriz (asociativo) o el estilo de objeto devolverá un indefinido constante.

El lento y confiable en operador y tiene propiedad propia método

Como la gente ya ha mencionado aquí, podría tener un objeto con una propiedad asociada con una constante “indefinida”.

 var bizzareObj = {valid_key:  undefined};

En ese caso, tendrás que usar tiene propiedad propia o en operador para saber si la llave está realmente allí. Pero, pero a que precio

pues te digo…

en operador y tiene propiedad propia son “métodos” que utilizan el mecanismo Property Descriptor en Javascript (similar a la reflexión de Java en el lenguaje Java).

http://www.ecma-international.org/ecma-262/5.1/#sec-8.10

El tipo de descriptor de propiedad se utiliza para explicar la manipulación y reificación de los atributos de propiedad con nombre. Los valores del tipo de descriptor de propiedad son registros compuestos por campos con nombre donde el nombre de cada campo es un nombre de atributo y su valor es un valor de atributo correspondiente como se especifica en 8.6.1. Además, cualquier campo puede estar presente o ausente.

Por otro lado, llamar a un método o clave de objeto usará Javascript [[Get]]mecanismo. ¡Eso es mucho más rápido!

Punto de referencia

http://jsperf.com/checking-if-a-key-exists-in-a-javascript-array

.

Utilizando en operador

var result = "Impression" in array;

el resultado fue

12,931,832 ±0.21% ops/sec      92% slower 

Uso de hasOwnProperty

var result = array.hasOwnProperty("Impression")

el resultado fue

16,021,758 ±0.45% ops/sec     91% slower

Acceso a elementos directamente (estilo de corchetes)

var result = array["Impression"] === undefined

el resultado fue

168,270,439 ±0.13 ops/sec     0.02% slower 

Acceso a elementos directamente (estilo de objeto)

var result = array.Impression  === undefined;

el resultado fue

168,303,172 ±0.20%     fastest

EDITAR: ¿Cuál es la razón para asignar a una propiedad el undefined ¿valor?

Esa pregunta me desconcierta. En Javascript, hay al menos dos referencias para objetos ausentes para evitar problemas como este: null y undefined.

null es el valor primitivo que representa la ausencia intencional de cualquier valor de objeto, o en términos cortos, el confirmado falta de valor Por otro lado, undefined es un valor desconocido (no definido). Si hay una propiedad que se usará más adelante con un adecuado valor considerar uso null referencia en lugar de undefined porque en el momento inicial la propiedad es confirmado carecer de valor.

Comparar:

var a = {1: null}; 
console.log(a[1] === undefined); // output: false. I know the value at position 1 of a[] is absent and this was by design, i.e.:  the value is defined. 
console.log(a[0] === undefined); // output: true. I cannot say anything about a[0] value. In this case, the key 0 was not in a[].

Consejo

Evite los objetos con undefined valores. Compruebe directamente siempre que sea posible y utilice null para inicializar valores de propiedad. De lo contrario, utilice la lenta in operador o hasOwnProperty() método.

EDITAR: 04/12/2018 – YA NO ES RELEVANTE

Como ha comentado la gente, las versiones modernas de los motores Javascript (con la excepción de Firefox) han cambiado el enfoque para las propiedades de acceso. La implementación actual es más lenta que la anterior para este caso particular, pero la diferencia entre la clave de acceso y el objeto es despreciable.

regresará undefined.

var aa = {hello: "world"};
alert( aa["hello"] );      // popup box with "world"
alert( aa["goodbye"] );    // popup box with "undefined"

undefined es un valor constante especial. Entonces puedes decir, por ejemplo

// note the three equal signs so that null won't be equal to undefined
if( aa["goodbye"] === undefined ) {
    // do something
}

Esta es probablemente la mejor manera de comprobar si faltan llaves. Sin embargo, como se señala en un comentario a continuación, es teóricamente posible que desee que el valor real sea undefined. Nunca he necesitado hacer esto y no puedo pensar en una razón por la que querría hacerlo, pero solo para completar, puede usar el in operador

// this works even if you have {"goodbye": undefined}
if( "goodbye" in aa ) {
    // do something
}

"key" in obj

Es probable que solo pruebe valores de atributos de objetos que son muy diferentes de las claves de matriz

La respuesta aceptada se refiere a Objeto. Cuidado con usar el in operador en Formación para encontrar datos en lugar de claves:

("true" in ["true", "false"])
// -> false (Because the keys of the above Array are actually 0 and 1)

Para probar elementos existentes en una matriz: ¿La mejor manera de encontrar si un elemento está en una matriz de JavaScript?

Tres formas de verificar si una propiedad está presente en un objeto javascript:

1. !!obj.theProperty

   Convertirá valor a bool. devoluciones true para todos menos el false valor

2. ‘theProperty‘ en objeto

   Devolverá verdadero si la propiedad existe, sin importar su valor (incluso vacío)

3. obj.hasOwnProperty('theProperty')

   No comprueba la cadena de prototipos. (ya que todos los objetos tienen la toString método, 1 y 2 devolverán verdadero, mientras que 3 puede devolver falso).

Referencia:

http://book.mixu.net/node/ch5.html

Si estás usando guión bajo.js biblioteca entonces las operaciones de objeto/matriz se vuelven simples.

En su caso, se puede usar el método _.has. Ejemplo:

yourArray = {age: "10"}

_.has(yourArray, "age")

devoluciones cierto

Pero,

_.has(yourArray, "invalidKey")

devoluciones falso