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



7 Answers

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 une constante indéfinie .

L'opérateur lent et fiable et la méthode hasOwnProperty

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 l' opérateur pour savoir si la clé est vraiment là. Mais, mais à quel prix?

donc, je te dis ...

dans l' opérateur et hasOwnProperty sont des "méthodes" qui utilisent un mécanisme de descripteur de propriété dans 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

.

Utilisation dans l' 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'affecter à une propriété la valeur undefined ?

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, le manque de valeur confirmé . D'un autre côté, undefined est une valeur inconnue (non définie). S'il existe une propriété qui sera utilisée plus tard avec une valeur correcte , utilisez une référence null au lieu de undefined car, au moment 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 si possible et utilisez null pour initialiser les valeurs de propriété. Sinon, utilisez l'opérateur slow in ou la méthode hasOwnProperty() .

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.

Question

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?




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




Solution ES6

en utilisant Array#some et Object.keys . Cela retournera true si la clé existe dans l'objet ou false 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'));




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



Ces exemples peuvent démontrer les différences entre les différentes manières. J'espère que cela vous aidera à choisir le bon pour 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"]



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.




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 au chemin de l'objet. Si la valeur résolue est indé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>

Cela permettra de vérifier si cette clé, quelle que soit sa profondeur , est définie et ne déclenchera pas d'erreur susceptible de nuire au flux de votre programme si cette clé n'est pas définie.







Related