Question Vérifier si une clé existe dans un objet JavaScript?


Comment vérifier si une clé particulière existe dans un objet JavaScript ou un tableau?

Si une clé n'existe pas, et j'essaie d'y accéder, cela retournera-t-il faux? Ou jeter une erreur?


2221
2017-07-08 13:21


origine


Réponses:


La vérification d'undefined-ness n'est pas un moyen précis de tester si une clé existe. Que faire si la clé existe mais que la valeur est réellement undefined?

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

Vous devriez plutôt utiliser le in opérateur:

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

Si vous voulez vérifier si une clé n'existe pas, n'oubliez pas d'utiliser des parenthèses:

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

Ou, si vous souhaitez tester en particulier les propriétés de l'instance d'objet (et non les propriétés héritées), utilisez hasOwnProperty:

obj.hasOwnProperty("key") // true

Pour la comparaison des performances entre les méthodes qui sont in, hasOwnProperty et la clé est undefined, regarde ça référence


3074
2017-07-08 15:51



réponse rapide

Comment vérifier si une clé particulière existe dans un objet JavaScript ou un tableau?   Si une clé n'existe pas et que j'essaie d'y accéder, retournera-t-elle faux? Ou jeter une erreur?

Accéder directement à une propriété manquante en utilisant un style de tableau (associatif) ou un style d'objet renvoie un indéfini constant.

Le lent et fiable dans opérateur et hasOwnProperty méthode

Comme les gens l'ont déjà mentionné, vous pourriez avoir un objet avec une propriété associée à une constante "indéfinie".

 var bizzareObj = {valid_key:  undefined};

Dans ce cas, vous devrez utiliser hasOwnProperty ou dans opérateur pour savoir si la clé est vraiment là. Mais, mais à quel prix?

donc, je te dis ...

dans opérateur et hasOwnProperty sont des "méthodes" qui utilisent un mécanisme de Descripteur de Propriété en Javascript (similaire à la réflexion Java dans le langage Java).

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

Le type de descripteur de propriété est utilisé pour expliquer la manipulation et la réification des attributs de propriété nommés. Les valeurs du type de descripteur de propriété sont des enregistrements composés de champs nommés où le nom de chaque champ est un nom d'attribut et sa valeur est une valeur d'attribut correspondante comme spécifié au 8.6.1. De plus, n'importe quel champ peut être présent ou absent.

D'un autre côté, appeler une méthode ou une clé d'objet utilisera le mécanisme Javascript [[Get]]. C'est beaucoup plus rapide!

référence

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

Comparing key access in JS.

En utilisant dans opérateur
var result = "Impression" in array;

Le résultat était

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

Le résultat était

16,021,758 ±0.45% ops/sec     91% slower
Accès direct aux éléments (style des crochets)
var result = array["Impression"] === undefined

Le résultat était

168,270,439 ±0.13 ops/sec     0.02% slower 
Accès direct aux éléments (style d'objet)
var result = array.Impression  === undefined;

Le résultat était

168,303,172 ±0.20%     fastest

EDIT: Quelle est la raison d'attribuer à une propriété la undefined valeur?

Cette question me laisse perplexe. En Javascript, il y a au moins deux références pour les objets absents pour éviter les problèmes comme ceci: null et undefined.

null est la valeur primitive qui représente l'absence intentionnelle de toute valeur d'objet, ou à court terme, la confirmé manque de valeur. D'autre part, undefined est une valeur inconnue (non définie). S'il y a une propriété qui sera utilisée plus tard avec un correct valeur envisager l'utilisation null référence au lieu de undefined parce que dans le premier moment, la propriété est confirmé manquer de valeur.

Comparer:

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

Conseiller

Eviter les objets avec undefined valeurs. Vérifiez directement si possible et utilisez null initialiser les valeurs de propriété. Sinon, utilisez la lenteur in opérateur ou hasOwnProperty() méthode.

EDIT: 12/04/2018 - NON PERTINENT PLUS

Comme les gens l'ont remarqué, les versions modernes des moteurs Javascript (avec exception firefox) ont changé l'approche pour les propriétés d'accès. L'implémentation actuelle est plus lente que la précédente pour ce cas particulier mais la différence entre la clé d'accès et l'objet est négligeable.


224
2018-02-27 16:38



Il reviendra undefined.

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

undefined est une valeur constante spéciale. Donc, vous pouvez dire, par exemple.

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

C'est probablement le meilleur moyen de vérifier les clés manquantes. Cependant, comme indiqué dans un commentaire ci-dessous, il est théoriquement possible que vous vouliez avoir la valeur réelle undefined. Je n'ai jamais eu besoin de faire ça et je ne peux pas penser à une raison pour laquelle je ne le ferais jamais, mais juste pour être complet, vous pouvez utiliser le in opérateur

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

114
2017-07-08 13:24



le réponse acceptée fait référence à Objet. Méfiez-vous en utilisant le in opérateur sur Array pour trouver des données à la place des clés:

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

Pour tester les éléments existants dans un tableau: La meilleure façon de trouver si un élément est dans un tableau JavaScript?


22
2017-07-01 12:45



"key" in obj

Ne teste probablement que les valeurs d'attribut d'objet très différentes des clés de tableau


20
2018-04-25 15:45



Trois façons de vérifier si une propriété est présente dans un objet javascript:

  1. !! obj.theProperty
    Va convertir la valeur en bool. renvoie TRUE pour tous sauf la valeur 'false'
  2. 'theProperty' dans obj
    Va retourner vrai si la propriété existe, peu importe sa valeur (même vide)
  3. obj.hasOwnProperty ('theProperty')
    Ne vérifie pas la chaîne du prototype. (puisque tous les objets ont la méthode 'toString', 1 et 2 retourneront true, alors que 3 peut retourner false.)

Référence:

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


20
2017-11-12 09:19



Si vous utilisez underscore.js La bibliothèque puis les opérations objet / tableau deviennent simples.

Dans votre cas, la méthode _.has peut être utilisée. Exemple:

yourArray = {age: "10"}

_.has(yourArray, "age")

résultats vrai 

Mais,

_.has(yourArray, "invalidKey")

résultats faux


13
2018-05-29 19:37



Répondre:

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

Explication:

le in L'opérateur vérifiera si la clé existe dans l'objet. Si vous avez vérifié si la valeur n'était pas définie: if (myObj["key"] === 'undefined'), vous pourriez rencontrer des problèmes car une clé pourrait éventuellement exister dans votre objet avec le undefined valeur.

Pour cette raison, il est préférable d'utiliser d'abord in opérateur et comparez ensuite la valeur qui est à l'intérieur de la clé une fois que vous savez déjà qu'il existe.


10
2018-06-22 02:29



Voici une fonction d'aide que je trouve très utile

Ce keyExists(key, search) peut être utilisé pour rechercher facilement une clé dans des objets ou des tableaux!

Il suffit de passer la clé que vous voulez trouver et de rechercher obj (l'objet ou le tableau) dans lequel vous voulez le trouver.

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

Comment l'utiliser:

Recherche de clés dans les tableaux

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

Recherche de clés dans les objets

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

Cela a été plutôt fiable et fonctionne bien avec plusieurs navigateurs.


9
2018-03-05 12:56



vanila js

yourObjName.hasOwnProperty(key) : true ? false;

Si vous voulez vérifier si l'objet a au moins une propriété dans es2015

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

4
2018-01-25 15:39



 Solution ES6

en utilisant Array#some et Object.keys. Il reviendra vrai si la clé donnée existe dans l'objet ou faux si ce n'est pas le cas.

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

Exemple d'une ligne.

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


4
2018-03-26 15:45