arrays check key - Vérifier si une clé existe dans un objet JavaScript?





9 Answers

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, est-ce qu'elle retournera false? Ou jeter une erreur?

L'accès direct à une propriété manquante à l'aide d'un style de tableau (associatif) ou d'un style d'objet renvoie une constante non définie .

Le lent et fiable dans l' opérateur et la méthode hasOwnProperty

Comme les gens l'ont déjà mentionné, vous pouvez 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 l'opérateur pour savoir si la clé est réellement présente. Mais à quel prix?

alors je vous dis ...

Les opérateurs in et hasOwnProperty sont des "méthodes" qui utilisent le mécanisme Property Descriptor en Javascript (similaire à la réflexion Java en langage Java).

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

Le type Property Descriptor 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, le nom de chaque champ étant un nom d'attribut et sa valeur étant une valeur d'attribut correspondante, comme indiqué au 8.6.1. De plus, n'importe quel champ peut être présent ou absent.

D'autre part, l'appel d'une méthode d'objet ou d'une clé 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

.

Utilisation de l' opérateur
var result = "Impression" in array;

Le résultat était

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

Le résultat était

16,021,758 ±0.45% ops/sec     91% slower
Accéder directement 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éder directement 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 pour affecter à une propriété la valeur undefined ?

Cette question me laisse perplexe. En Javascript, il existe au moins deux références pour les objets absents afin d'é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, à court terme, l'absence confirmée de valeur. Par ailleurs, undefined est une valeur inconnue (non définie). S'il existe une propriété qui sera utilisée ultérieurement avec une valeur appropriée , envisagez d'utiliser la référence null au lieu de undefined car, dans l'instant initial, il est confirmé que la propriété n'a pas 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

Évitez les objets avec des valeurs undefined . Vérifiez directement chaque fois que possible et utilisez null pour initialiser les valeurs de propriété. Sinon, utilisez l'opérateur lent ou la méthode hasOwnProperty() .

EDIT: 12/04/2018 - N'EST PLUS PERTINENT

Comme les gens l'ont commenté, les versions modernes des moteurs Javascript (à l'exception de Firefox) ont modifié l'approche des propriétés d'accès. La mise en œuvre actuelle est plus lente que la précédente dans ce cas particulier, mais les différences entre clé d'accès et objet sont négligeables.

in object length

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, est-ce qu'elle retournera false? Ou jeter une erreur?







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

  1. !! obj.la propriété
    Convertira la valeur en bool. retourne TRUE pour tout sauf la valeur 'false'
  2. 'theProperty' dans obj
    Retourne true si la propriété existe, quelle que soit sa valeur (même vide)
  3. obj.hasOwnProperty ('la propriété')
    Ne vérifie pas la chaîne de prototypes. (Puisque tous les objets ont la méthode 'toString', 1 et 2 renverront true dessus, alors que 3 peut renvoyer false.)

Référence:

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




Réponse:

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

Explication:

L'opérateur in va vérifier si la clé existe dans l'objet. Si vous avez coché 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 la valeur undefined .

Pour cette raison, il est préférable de commencer par utiliser l'opérateur in , puis de comparer la valeur contenue dans la clé une fois que vous savez déjà qu'elle existe.




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



Nous pouvons utiliser - hasOwnProperty.call(obj, key);

Le underscore.js -

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

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



Pour ceux qui ont lodash inclus dans leur projet:
Il existe une méthode lodash _.get qui essaie d’obtenir des clés "profondes":

Obtient la valeur sur le chemin de l'objet. Si la valeur résolue n'est pas définie, la valeur par défaut est renvoyée à sa place.

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>

Ceci vérifiera efficacement si cette clé, quelle que soit sa profondeur , est définie et ne générera pas d'erreur qui pourrait nuire au flux de votre programme si cette clé n'est pas définie.




Ces exemples peuvent démontrer les différences entre différentes manières. J'espère que cela vous aidera à choisir celui qui répond le mieux à vos besoins:

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



Nouvelle solution géniale avec JavaScript Destructuring :

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

Vérifiez les autres utilisations de JavaScript Destructuring




Related