¿Comprobando si existe una clave en un objeto JavaScript?

¿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?

preguntado el 08 de julio de 09 a las 10:07

Todo (casi todo) en JavaScript es un objeto o se puede convertir como uno. Aquí es donde nacen las matrices pseudoasociativas, como señaló @PatrickM. -

este punto de referencia jsben.ch/#/WqlIl le ofrece una descripción general de las formas más habituales de realizar esta comprobación. -

una solución rápida, normalmente opto por property.key = property.key || 'some default value', en caso de que quiera que esa clave exista con algún valor -

23 Respuestas

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

Respondido 27 Feb 21, 00:02

Tener una propiedad con un valor indefinido definido manualmente no tiene ningún sentido. Realmente sería un oxímoron. - Joebert

Estoy convencido de que existen casos de uso para tener propiedades configuradas intencionalmente como indefinidas. - Ates Goral

Caso de uso válido: Gecko 1.9.1 [Firefox 3.5] no tiene la propiedad window.onhashchange. Gecko 1.9.2 [Firefox 3.6] tiene esta propiedad configurada como indefinida (hasta que cambie el hash). Para que la función detecte el historial de hash o la versión del navegador, se debe usar window.hasOwnProperty ("onhashchange"); - SamGoody

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

Comparando el acceso a claves en JS.

Usar in operador
var result = "Impression" in array;

El resultado fue

12,931,832 ±0.21% ops/sec      92% slower 
Usando hasOwnProperty
var result = array.hasOwnProperty("Impression")

El resultado fue

16,021,758 ±0.45% ops/sec     91% slower
Accediendo a elementos directamente (estilo corchetes)
var result = array["Impression"] === undefined

El resultado fue

168,270,439 ±0.13 ops/sec     0.02% slower 
Acceder 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 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.

Respondido 03 ago 20, 20:08

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
}

contestado el 18 de mayo de 19 a las 08:05

Si. Devuelve indefinido si se crea como un objeto o una matriz. - Nosredna

¿Qué pasa si la clave existe pero el valor en realidad no está definido? - Ates Goral

Debe usar === en lugar de == cuando se compara con undefined, de lo contrario, null comparará igual a undefined. - matthew crumley

El sistema 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?

contestado el 23 de mayo de 17 a las 12:05

"key" in obj

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

Respondido 29 Oct 13, 12:10

Este código también dará verdadero para una clave que está definida en el prototipo de Clase: función A () {}; A.prototype.b = 2; var a = new A (); Entonces 'b' en a es verdadero. Mientras que a.hasOwnProperty ('b') es, por supuesto, falso. - Alexander

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

Respondido el 04 de junio de 20 a las 13:06

!! obj.theProperty falla cuando el valor no está definido. Ex: var a = {a : undefined, b : null}; !!a.a **will return false** - ARJUN

de revisión: !!obj.theProperty no es una solución para comprobar si un objeto tiene una propiedad denominada theProperty. Falla por cualquier valor de propiedad falso, undefined, nulo, numérico 0 or NaNy la cuerda vacía "" - tractor

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

contestado el 29 de mayo de 14 a las 20:05

Respuesta

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

Explicación:

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

Respondido el 29 de junio de 16 a las 13:06

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

Este planteamiento de « 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.

contestado el 18 de mayo de 19 a las 11:05

Esto parece un poco confuso: en primer lugar, cuando se busca una matriz, este método busca una propuesta de, no una llave. En segundo lugar, ¿por qué iterar a través de una matriz como esta cuando puede usar la función incorporada? Array.indexOf ¿método? (si está buscando un valor, eso es) - Nick F.

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

Respondido el 25 de enero de 17 a las 15:01

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'));

respondido 26 mar '17, 16:03

Fallará para propiedades no numerables del objeto. - Sid

@Sid Dame un ejemplo. - amable usuario

Aqui tienes. let joshua = {nombre: 'Joshua', dirección: 'Londres'}; Object.defineProperty (joshua, 'isMarried', {valor: verdadero, enumerable: falso}); console.log ('isMarried' en Object.keys (joshua)) - Sid

Estoy aplicando su solución en mi objeto. ¿No debería ser cierto para la primera salida? console.log (Object.keys (joshua) .some (v => v == 'isMarried')); console.log (joshua.isMarried); - Sid

Lo siento, pero ¿verificó el resultado de la segunda declaración de la consola? Object.defineProperty es equivalente a establecer la propiedad mediante notación de puntos. - Sid

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

El sistema underscore.js camino -

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

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

Respondido el 02 de diciembre de 16 a las 15:12

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.

respondido 05 nov., 18:15

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.

respondido 29 mar '17, 15:03

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

Respondido 17 Oct 18, 13:10

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.

Respondido el 11 de diciembre de 19 a las 08:12

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';

Respondido 26 ago 19, 15:08

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]);

Respondido el 30 de enero de 20 a las 09:01

yourArray.indexOf (yourArrayKeyName)> -1

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

fruit.indexOf('apple') > -1

verdadero


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

fruit.indexOf('apple1') > -1

false

Respondido 19 Feb 19, 10:02

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"]

Respondido 21 Feb 18, 14:02

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

Respondido 01 Feb 21, 08:02

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

Respondido 26 Feb 21, 13:02

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

Respondido 31 ago 18, 19:08

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.