Verificando se existe uma chave em um object JavaScript?

Como faço para verificar se uma chave particular existe em um object ou matriz JavaScript?

Se uma chave não existir e eu tentar acessá-la, ela retornará false? Ou jogue um erro?

A verificação da indefinição não é uma maneira precisa de testar se existe uma chave. E se a chave existir, mas o valor for realmente undefined ?

 var obj = { key: undefined }; obj["key"] != undefined // false, but the key exists! 

Você deve usar o operador in :

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

Se você quiser verificar se uma chave não existe, lembre-se de usar parênteses:

 !("key" in obj) // true if "key" doesn't exist in object !"key" in obj // ERROR! Equivalent to "false in obj" 

Ou, se você quiser testar particularmente as propriedades da instância do object (e não propriedades herdadas), use hasOwnProperty :

 obj.hasOwnProperty("key") // true 

Para comparação de desempenho entre os methods que estão in , hasOwnProperty e a chave é undefined , veja este benchmark

resposta rápida

Como faço para verificar se uma chave particular existe em um object ou matriz JavaScript? Se uma chave não existir e eu tentar acessá-la, ela retornará false? Ou jogue um erro?

Acessar diretamente uma propriedade ausente usando estilo de matriz (associativo) ou estilo de object retornará uma constante indefinida .

O método lento e confiável no operador e hasOwnProperty

Como as pessoas já mencionaram aqui, você poderia ter um object com uma propriedade associada a uma constante “indefinida”.

  var bizzareObj = {valid_key: undefined}; 

Nesse caso, você terá que usar o hasOwnProperty ou no operador para saber se a chave está realmente lá. Mas, mas a que preço?

então eu te digo

no operador e hasOwnProperty são “methods” que usam o mecanismo do Descritor de propriedades em JavaScript (semelhante à reflection Java na linguagem Java).

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

O tipo de descritor de propriedade é usado para explicar a manipulação e a reificação de atributos de propriedade nomeados. Valores do tipo Descritor de Propriedade são registros compostos de campos nomeados, em que o nome de cada campo é um nome de atributo e seu valor é um valor de atributo correspondente, conforme especificado em 8.6.1. Além disso, qualquer campo pode estar presente ou ausente.

Por outro lado, chamar um método ou chave de object usará o mecanismo Javascript [[Get]]. Isso é muito mais rápido!

referência

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

Comparando acesso chave em JS .

Usando no operador

 var result = "Impression" in array; 

O resultado foi

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

Usando hasOwnProperty

 var result = array.hasOwnProperty("Impression") 

O resultado foi

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

Acessando elementos diretamente (estilo de colchetes)

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

O resultado foi

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

Acessando elementos diretamente (estilo de object)

 var result = array.Impression === undefined; 

O resultado foi

 168,303,172 ±0.20% fastest 

EDIT: Qual é o motivo para atribuir a uma propriedade o valor undefined ?

Essa pergunta me intriga. Em Javascript, há pelo menos duas referências para objects ausentes para evitar problemas como este: null e undefined .

null é o valor primitivo que representa a ausência intencional de qualquer valor de object ou, em curto prazo, a falta de valor confirmada . Por outro lado, undefined é um valor desconhecido (não definido). Se houver uma propriedade que será usada posteriormente com um valor adequado, considere usar referência null vez de undefined porque no momento inicial a propriedade é confirmada como não tendo um 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, ie: 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[]. 

Aconselhar

Evite objects com valores undefined . Verifique diretamente sempre que possível e use null para inicializar os valores das propriedades. Caso contrário, use o operador slow in ou o método hasOwnProperty() .

EDIT: 12/04/2018 – NÃO RELEVANTE ANYMORE

Como as pessoas comentaram, as versões modernas dos mecanismos de Javascript (com exceção do firefox) mudaram a abordagem das propriedades de access. A implementação atual é mais lenta que a anterior para este caso em particular, mas a diferença entre a chave de access e o object é negligenciável.

Ele retornará undefined .

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

undefined é um valor constante especial. Então você pode dizer, por exemplo

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

Esta é provavelmente a melhor maneira de verificar a falta de chaves. No entanto, como é apontado em um comentário abaixo, é teoricamente possível que você queira que o valor real seja undefined . Eu nunca precisei fazer isso e não posso pensar em uma razão por que eu sempre quis, mas apenas por uma questão de completude, você pode usar o operador in

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

A resposta aceita refere-se ao object . Cuidado ao usar o operador in no Array para localizar dados em vez de chaves:

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

Para testar elementos existentes em uma matriz: Melhor maneira de descobrir se um item está em uma matriz JavaScript?

 "key" in obj 

Provavelmente está testando apenas valores de atributo de object que são muito diferentes das chaves do array

Três maneiras de verificar se uma propriedade está presente em um object javascript:

  1. !! obj.theProperty
    Vai converter o valor em bool. retorna TRUE para todos, exceto o valor “false”
  2. ‘theProperty’ em obj
    Retornará true se a propriedade existir, não importando seu valor (mesmo vazio)
  3. obj.hasOwnProperty (‘theProperty’)
    Não verifica a cadeia de protótipos. (como todos os objects têm o método ‘toString’, 1 e 2 retornarão true, enquanto 3 pode retornar false.)

Referência:

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

Se você estiver usando a biblioteca underscore.js , as operações object / matriz se tornarão simples.

No seu caso, o método _.has pode ser usado. Exemplo:

 yourArray = {age: "10"} _.has(yourArray, "age") 

retorna verdadeiro

Mas,

 _.has(yourArray, "invalidKey") 

retorna falso

Responda:

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

Explicação:

O operador in irá verificar se a chave existe no object. Se você verificou se o valor estava indefinido: if (myObj["key"] === 'undefined') , você poderia ter problemas porque uma chave poderia existir em seu object com o valor undefined .

Por essa razão, é muito melhor usar primeiro o operador in e comparar o valor que está dentro da chave, uma vez que você já sabe que ela existe.

Aqui está uma function auxiliar que eu acho bastante útil

Este keyExists(key, search) pode ser usado para procurar facilmente uma chave dentro de objects ou matrizes!

Apenas passe a chave que você quer encontrar, e procure por obj (o object ou array) que você quer encontrar.

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

Como usá-lo:

Procurando por chaves em matrizes

 keyExists('apple', ['apple', 'banana', 'orange']); // true keyExists('fruit', ['apple', 'banana', 'orange']); // false 

Procurando por chaves em objects

 keyExists('age', {'name': 'Bill', 'age': 29 }); // true keyExists('title', {'name': 'Jason', 'age': 29 }); // false 

Tem sido bastante confiável e funciona bem em vários navegadores.

vanila js

 yourObjName.hasOwnProperty(key) : true ? false; 

Se você quiser verificar se o object tem pelo menos uma propriedade em es2015

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

Solução ES6

usando Array#some e Object.keys . Ele retornará true se a chave existir no object ou false, se não existir.

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

Nós podemos usar – hasOwnProperty.call(obj, key);

O caminho underscore.js –

 if(_.has(this.options, 'login')){ //key 'login' exists in this.options } _.has = function(obj, key) { return hasOwnProperty.call(obj, key); }; 

Esta é uma pergunta antiga, mas acho que nunca é tarde para dar uma resposta.

Imagine que você tenha um object “produtos” e dois itens. Se você quiser ver se o id já existe neste object, você pode usar find ()

 products = [ { "id": 1, "name": "Name 1" }, { "id": 2, "name": "Name 2" }, ] item1 = { "id": 3, "name": "Name 3", } item2 = { "id": 1, "name": "Name 1", } if(products.find(x => x.id === item1.id)){ console.log('id is in products'); }else { console.log('id is not in products'); } if(products.find(x => x.id === item2.id)){ console.log('id is in products'); }else { console.log('id is not in products'); } 

registro:

 id is not in products id is in products 

Para aqueles que têm lodash incluído em seu projeto:
Existe um método lodash _.get que tenta obter chaves “profundas”:

Obtém o valor no caminho do object. Se o valor resolvido é indefinido, o defaultValue é retornado em seu 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, 'abc'), // => undefined _.get(object, 'abc', 'default') // => 'default' ) 
  

Embora isso necessariamente verifique se existe uma chave, ela verifica a veracidade de um valor. Quais undefined e null se enquadram.

Boolean(obj.foo)

Esta solução funciona melhor para mim porque eu uso typescript, e usando strings como 'foo' in obj ou obj.hasOwnProperty('foo') para verificar se uma chave existe ou não, não me fornece intellisense.

Este exemplo pode demonstrar as diferenças entre formas diferentes. Espero que ajude você a escolher o caminho certo para as suas necessidades:

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

Nova solução incrível com JavaScript Destructuring :

 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 

Verifique a outra utilização de JavaScript Destructuring