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 };
obj["key"] !== undefined // false, but the key exists!

En su lugar, debería utilizar el in operador:

"key" in obj // true, regardless of the actual value

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

!("key" in obj) // true if "key" doesn't exist in object
!"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:

obj.hasOwnProperty("key") // true

Para comparar el rendimiento entre los métodos que se in, hasOwnProperty y la clave es undefined, mira esto punto de referencia

Respuesta rápida

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

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

El lento y confiable in 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á que usar tiene propiedad propia or in operador para saber si la clave está realmente allí. Pero, pero a que precio

así que te digo ...

in operador y tiene propiedad propia son "métodos" que utilizan el mecanismo del descriptor de propiedades 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 nombrados. Los valores del tipo 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 utilizará el mecanismo Javascript [[Get]]. ¡Eso es mucho más rápido!

punto de referencia

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

.

var result = "Impression" in array;

El resultado fue

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

var result = array.hasOwnProperty("Impression")

El resultado fue

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

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

El resultado fue

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

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 utilizará más tarde con un apropiado valor considere uso null referencia en lugar de undefined porque en el momento inicial la propiedad es confirmado carecer de valor.

Compare:

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

Asesorías

Evite los objetos con undefined valores. Verifique directamente siempre que sea posible y use null para inicializar valores de propiedad. De lo contrario, use el lento in operador o hasOwnProperty() método.

EDITAR: 12/04/2018 - NO ES RELEVANTE MÁS

Como ha comentado la gente, las versiones modernas de los motores Javascript (con la excepción de Firefox) han cambiado el enfoque de 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, p. Ej.

// 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 forma de comprobar si faltan claves. 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 de por qué 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
}

EL respuesta aceptada se refiere a Objeto. Tenga cuidado con el in operador on 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 averiguar si un elemento está en una matriz de JavaScript?

"key" in obj

Probablemente esté probando solo valores de atributos de objetos que son muy diferentes de las claves de matriz

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 propuesta de
2. 'theProperty'en obj
   Devolverá verdadero si la propiedad existe, sin importar su valor (incluso vacío)
3. obj.hasOwnProperty('theProperty')
   No comprueba la cadena del prototipo. (ya que todos los objetos tienen el toString método, 1 y 2 devolverán verdadero en él, mientras que 3 pueden devolver falso en él).

Referencia:

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

Si está utilizando underscore.js biblioteca, las operaciones de objeto / matriz se vuelven simples.

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

yourArray = {age: "10"}

_.has(yourArray, "age")

devoluciones verdadero

Pero,

_.has(yourArray, "invalidKey")

devoluciones false

Respuesta

if ("key" in myObj)
{
    console.log("key exists!");
}
else
{
    console.log("key doesn't exist!");
}

Explicación:

EL in El operador comprobará si la clave existe en el objeto. Si marcó si el valor no estaba definido: if (myObj["key"] === 'undefined'), podría tener problemas porque posiblemente podría existir una clave en su objeto con el undefined .

Por esa razón, es una práctica mucho mejor utilizar primero el in operador y luego compare el valor que está dentro de la clave una vez que sepa que existe.

Aquí hay una función auxiliar que encuentro bastante útil.

Este keyExists(key, search) se puede utilizar para buscar fácilmente una clave dentro de objetos o matrices.

Simplemente pásele la clave que desea encontrar y busque obj (el objeto o matriz) en el que desea encontrarlo.

function keyExists(key, search) {
        if (!search || (search.constructor !== Array && search.constructor !== Object)) {
            return false;
        }
        for (var i = 0; i < search.length; i++) {
            if (search[i] === key) {
                return true;
            }
        }
        return key in search;
    }

// How to use it:
// Searching for keys in Arrays
console.log(keyExists('apple', ['apple', 'banana', 'orange'])); // true
console.log(keyExists('fruit', ['apple', 'banana', 'orange'])); // false

// Searching for keys in Objects
console.log(keyExists('age', {'name': 'Bill', 'age': 29 })); // true
console.log(keyExists('title', {'name': 'Jason', 'age': 29 })); // false

Ha sido bastante confiable y funciona bien en todos los navegadores.

vainilla js

yourObjName.hasOwnProperty(key) : true ? false;

Si desea comprobar si el objeto tiene al menos una propiedad en es2015

Object.keys(yourObjName).length : true ? false

Solución ES6

usar Array#some y Object.keys. Volverá verdadero si la clave dada existe en el objeto o false si no es así.

var obj = {foo: 'one', bar: 'two'};
    
function isKeyInObject(obj, key) {
    var res = Object.keys(obj).some(v => v == key);
    console.log(res);
}

isKeyInObject(obj, 'foo');
isKeyInObject(obj, 'something');

Ejemplo de una línea.

console.log(Object.keys({foo: 'one', bar: 'two'}).some(v => v == 'foo'));

Nosotros podemos usar - hasOwnProperty.call(obj, key);

EL underscore.js camino -

if(_.has(this.options, 'login')){
  //key 'login' exists in this.options 
}

_.has = function(obj, key) {
  return hasOwnProperty.call(obj, key);
};

La forma más sencilla de comprobarlo es

"key" in object

por ejemplo:

var obj = {
  a: 1,
  b: 2,
}
"a" in obj // true
"c" in obj // false

Devuelve el valor como verdadero implica que la clave existe en el objeto.

Para aquellos que tienen lodash incluido en su proyecto:
Hay un lodash _.obtener método que intenta obtener claves "profundas":

Obtiene el valor en la ruta del objeto. Si el valor resuelto no está definido, el valor predeterminado se devuelve en su lugar.

var object = { 'a': [{ 'b': { 'c': 3 } }] };

console.log(
  _.get(object, 'a[0].b.c'),           // => 3
  _.get(object, ['a', '0', 'b', 'c']), // => 3
  _.get(object, 'a.b.c'),              // => undefined 
  _.get(object, 'a.b.c', 'default')    // => 'default'
)

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.4/lodash.min.js"></script>

Esto comprobará efectivamente si esa clave, sin embargo profundo, se define y no arrojar un error que podría dañar el flujo de su programa si esa clave no está definida.

Si desea verificar cualquier clave a cualquier profundidad en un objeto y tener en cuenta los valores falsos, considere esta línea para una función de utilidad:

var keyExistsOn = (o, k) => k.split(".").reduce((a, c) => a.hasOwnProperty(c) ? a[c] || 1 : false, Object.assign({}, o)) === false ? false : true;

Resultados

var obj = {
    test: "",
    locals: {
        test: "",
        test2: false,
        test3: NaN,
        test4: 0,
        test5: undefined,
        auth: {
            user: "hw"
        }
    }
}

keyExistsOn(obj, "")
> false
keyExistsOn(obj, "locals.test")
> true
keyExistsOn(obj, "locals.test2")
> true
keyExistsOn(obj, "locals.test3")
> true
keyExistsOn(obj, "locals.test4")
> true
keyExistsOn(obj, "locals.test5")
> true
keyExistsOn(obj, "sdsdf")
false
keyExistsOn(obj, "sdsdf.rtsd")
false
keyExistsOn(obj, "sdsdf.234d")
false
keyExistsOn(obj, "2134.sdsdf.234d")
false
keyExistsOn(obj, "locals")
true
keyExistsOn(obj, "locals.")
false
keyExistsOn(obj, "locals.auth")
true
keyExistsOn(obj, "locals.autht")
false
keyExistsOn(obj, "locals.auth.")
false
keyExistsOn(obj, "locals.auth.user")
true
keyExistsOn(obj, "locals.auth.userr")
false
keyExistsOn(obj, "locals.auth.user.")
false
keyExistsOn(obj, "locals.auth.user")
true

Vea también este paquete de NPM: https://www.npmjs.com/package/has-deep-value

Si bien esto no necesariamente verifica si existe una clave, sí verifica la veracidad de un valor. Cual undefined y null caer bajo.

Boolean(obj.foo)

Esta solución funciona mejor para mí porque uso mecanografiado y uso de cadenas como esta 'foo' in obj or obj.hasOwnProperty('foo') comprobar si existe una clave o no no me proporciona intellisense.

const object1 = {
  a: 'something',
  b: 'something',
  c: 'something'
};

const key = 's';

// Object.keys(object1) will return array of the object keys ['a', 'b', 'c']

Object.keys(object1).indexOf(key) === -1 ? 'the key is not there' : 'yep the key is exist';

En el mundo de la 'matriz' podemos ver los índices como una especie de claves. ¿Qué es sorprendente el in El operador (que es una buena opción para el objeto) también funciona con matrices. El valor devuelto para la clave no existente es undefined

let arr = ["a","b","c"]; // we have indexes: 0,1,2
delete arr[1];           // set 'empty' at index 1
arr.pop();               // remove last item

console.log(0 in arr,  arr[0]);
console.log(1 in arr,  arr[1]);
console.log(2 in arr,  arr[2]);

yourArray.indexOf (yourArrayKeyName)> -1

fruit = ['apple', 'grapes', 'banana']

fruit.indexOf('apple') > -1

verdadero

fruit = ['apple', 'grapes', 'banana']

fruit.indexOf('apple1') > -1

false

Este ejemplo puede demostrar las diferencias entre diferentes formas. Espero que te ayude a elegir el más adecuado para tus necesidades:

// Lets create object `a` using create function `A`
function A(){};
A.prototype.onProtDef=2;
A.prototype.onProtUndef=undefined;
var a=new A();
a.ownProp = 3;
a.ownPropUndef = undefined;

// Let's try different methods:

a.onProtDef; // 2
a.onProtUndef; // undefined
a.ownProp; // 3
a.ownPropUndef; // undefined
a.whatEver; // undefined
a.valueOf; // ƒ valueOf() { [native code] }

a.hasOwnProperty('onProtDef'); // false
a.hasOwnProperty('onProtUndef'); // false
a.hasOwnProperty('ownProp'); // true
a.hasOwnProperty('ownPropUndef'); // true
a.hasOwnProperty('whatEver'); // false
a.hasOwnProperty('valueOf'); // false

'onProtDef' in a; // true
'onProtUndef' in a; // true
'ownProp' in a; // true
'ownPropUndef' in a; // true
'whatEver' in a; // false
'valueOf' in a; // true (on the prototype chain - Object.valueOf)

Object.keys(a); // ["ownProp", "ownPropUndef"]

Una solución rápida y fácil es convertir su objeto a json, luego podrá realizar esta sencilla tarea:

const allowed = {
    '/login' : '',
    '/register': '',
    '/resetpsw': ''
};
console.log('/login' in allowed); //returns true

Si usa una matriz, la clave del objeto se convertirá en números enteros, por ejemplo, 0,1,2,3, etc., por lo que siempre será falso

Encadenamiento opcional El operador también se puede utilizar para esto.

 ?.

hechicería: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Optional_chaining

const adventurer = {
  name: 'Alice',
  cat: {
    name: 'Dinah'
  }
};

const dogName = adventurer.dog?.name;
console.log(dogName);
// expected output: undefined

Nueva solución impresionante con Desestructuración de JavaScript:

let obj = {
    "key1": "value1",
    "key2": "value2",
    "key3": "value3",
};

let {key1, key2, key3, key4} = obj;

// key1 = "value1"
// key2 = "value2"
// key3 = "value3"
// key4 = undefined

// Can easily use `if` here on key4
if(!key4) { console.log("key not present"); } // Key not present

Comprobar otro uso de JavaScript Desestructuración