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

Question

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

Si une clé n'existe pas et que j'essaie d'y accéder, le système retournera-t-il false ? Ou lancera-t-il une erreur ?

Answer 1

Vérifier l'absence de définition n'est pas un moyen précis de vérifier l'existence d'une clé. Que se passe-t-il si la clé existe mais que la valeur est en réalité 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   // Do not do this! It is equivalent to "false in obj"

Ou, si vous voulez tester particulièrement les propriétés de l'instance de l'objet (et non les propriétés héritées), utilisez hasOwnProperty :

obj.hasOwnProperty("key") // true

Pour comparer les performances des méthodes qui sont in , hasOwnProperty et la clé est undefined voir ceci repère

Answer 2

Réponse rapide

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

L'accès direct à une propriété manquante en utilisant le style tableau (associatif) ou le style objet renverra un message de type indéfini constant.

La lenteur et la fiabilité sur opérateur et hasOwnProperty méthode

Comme on l'a déjà mentionné ici, on peut avoir un objet dont la propriété est associée à une constante "indéfinie".

 var bizzareObj = {valid_key:  undefined};

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

alors, je vous dis...

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

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

Le type 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 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 indiqué au point 8.6.1. En outre, tout champ peut être présent ou absent.

D'autre part, l'appel d'une méthode ou d'une clé d'objet utilisera le mécanisme Javascript [[Get]]. C'est beaucoup plus rapide !

Point de repère

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

.

Utilisation de sur opérateur

var result = "Impression" in array;

Le résultat a été

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

Utilisation de hasOwnProperty

var result = array.hasOwnProperty("Impression")

Le résultat a été

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

Accès direct aux éléments (style parenthèses)

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

Le résultat a été

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

Accès direct aux éléments (style objet)

var result = array.Impression  === undefined;

Le résultat a été

168,303,172 ±0.20%     fastest

EDIT : Quelle est la raison pour laquelle on assigne à une propriété l'élément undefined valeur ?

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

null est la valeur primitive qui représente l'absence intentionnelle de toute valeur d'objet, ou en bref, le confirmé le manque de valeur. D'un autre côté, undefined est une valeur inconnue (non définie). S'il y a une propriété qui sera utilisée plus tard avec une balise approprié valeur considérer utilisation null au lieu de undefined car au moment initial, la propriété est confirmé de manquer de valeur.

Comparez :

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

Conseils

éviter les objets avec undefined valeurs. Vérifiez directement chaque fois que possible et utilisez null pour initialiser les valeurs des propriétés. Sinon, utilisez la méthode lente in opérateur ou hasOwnProperty() méthode.

EDIT : 12/04/2018 - N'EST PLUS D'ACTUALITÉ

Comme d'autres l'ont fait remarquer, les versions modernes des moteurs Javascript (à l'exception de firefox) ont modifié l'approche des 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.

Answer 3

Il retournera 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. Vous pouvez donc 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 la meilleure façon de vérifier si des clés manquent. Cependant, comme le souligne un commentaire ci-dessous, il est théoriquement possible que vous souhaitiez que la valeur réelle soit undefined . Je n'ai jamais eu besoin de le faire et je ne vois pas pourquoi je voudrais le faire, mais par souci d'exhaustivité, vous pouvez utiliser l'attribut in opérateur

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

Answer 4

"key" in obj

Est susceptible de tester uniquement les valeurs d'attributs d'objets qui sont très différentes des clés de tableaux.

Answer 5

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

1. !!obj.theProperty
   Convertit la valeur en bool. true pour tous, sauf le false valeur
2. ' theProperty ' dans obj
   Retournera vrai si la propriété existe, quelle que soit sa valeur (même vide).
3. obj.hasOwnProperty('theProperty')
   Ne vérifie pas la chaîne de prototypes. (puisque tous les objets ont l'attribut toString 1 et 2 renverront vrai sur cette méthode, tandis que 3 pourra y renvoyer faux).

Référence :

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