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 lancer une erreur?

La vérification de l'indéfini-ness n'est pas un moyen précis de tester si une clé existe. Et 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 devez plutôt utiliser l' inopérateur:

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

Si vous souhaitez 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

A titre de comparaison des performances entre les méthodes qui sont in, hasOwnPropertyet est la clé undefined, voir cette référence

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 lancer 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 .

La lente et fiable dans l' opérateur et hasOwnProperty méthode

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

 var bizzareObj = {valid_key:  undefined};

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

alors je vous le dis ...

in operator et hasOwnProperty sont des "méthodes" qui utilisent le mécanisme Property Descriptor 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 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 spécifié en 8.6.1. De plus, tout champ peut être présent ou absent.

D'un autre côté, l'appel d'une méthode ou d'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

.

var result = "Impression" in array;

Le résultat fut

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

var result = array.hasOwnProperty("Impression")

Le résultat fut

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

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

Le résultat fut

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

var result = array.Impression  === undefined;

Le résultat fut

168,303,172 ±0.20%     fastest

EDIT: Quelle est la raison pour attribuer à une propriété la undefinedvaleur?

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: nullet undefined.

nullest la valeur primitive qui représente l'absence intentionnelle de toute valeur d'objet, ou en bref, le manque de valeur confirmé . En revanche, undefinedest une valeur inconnue (non définie). S'il existe une propriété qui sera utilisée plus tard avec une valeur appropriée , considérez l'utilisation d'une nullréférence au lieu de undefinedparce qu'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 undefinedvaleurs. Vérifiez directement dans la mesure du possible et utilisez nullpour initialiser les valeurs des propriétés. Sinon, utilisez l' inopérateur ou la hasOwnProperty()méthode lente .

EDIT: 12/04/2018 - PLUS PERTINENT

Comme les gens l'ont commenté, les versions modernes des moteurs Javascript (à l'exception de 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.

Il reviendra undefined.

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

undefinedest 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 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 souhaitiez que la valeur réelle soit undefined. Je n'ai jamais eu besoin de faire cela et je ne peux pas penser à une raison pour laquelle je le souhaiterais, mais juste pour être complet, vous pouvez utiliser l' inopérateur

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

La réponse acceptée fait référence à Object . Attention à utiliser l' inopérateur sur Array pour rechercher des données au lieu de clés:

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

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

"key" in obj

Teste probablement uniquement des valeurs d'attribut d'objet très différentes des clés de tableau

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

1. !!obj.theProperty
   Convertira la valeur en bool. renvoie truepour tout sauf la falsevaleur
2. ' theProperty' dans obj
   Renvoie true si la propriété existe, quelle que soit sa valeur (même vide)
3. obj.hasOwnProperty('theProperty')
   Ne vérifie pas la chaîne prototype. (puisque tous les objets ont la toStringméthode, 1 et 2 retourneront true dessus, tandis que 3 peut retourner false dessus.)

Référence:

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

Si vous utilisez la bibliothèque underscore.js , 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")

renvoie vrai

Mais,

_.has(yourArray, "invalidKey")

renvoie faux

Réponse:

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

Explication:

L' inopé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 la undefinedvaleur.

Pour cette raison, il est bien préférable d'utiliser d'abord l' inopérateur, puis de comparer la valeur qui se trouve à l'intérieur de la clé une fois que vous savez déjà qu'elle existe.

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

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

Passez-lui simplement la clé que vous souhaitez rechercher et recherchez obj (l'objet ou le tableau) dans lequel vous souhaitez 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;
    }

// How to use it:
// Searching for keys in Arrays
console.log(keyExists('apple', ['apple', 'banana', 'orange'])); // true
console.log(keyExists('fruit', ['apple', 'banana', 'orange'])); // false

// Searching for keys in Objects
console.log(keyExists('age', {'name': 'Bill', 'age': 29 })); // true
console.log(keyExists('title', {'name': 'Jason', 'age': 29 })); // false

Il a été assez fiable et fonctionne bien entre les navigateurs.

vanila js

yourObjName.hasOwnProperty(key) : true ? false;

Si vous souhaitez vérifier si l'objet possède au moins une propriété dans es2015

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

Solution ES6

en utilisant Array#someet Object.keys. Il renverra true si une clé donnée existe dans l'objet ou false dans le cas contraire.

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

On peut utiliser - hasOwnProperty.call(obj, key);

La manière underscore.js -

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

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

La façon la plus simple de vérifier est

"key" in object

par exemple:

var obj = {
  a: 1,
  b: 2,
}
"a" in obj // true
"c" in obj // false

La valeur de retour true indique que la clé existe dans l'objet.

Pour ceux qui ont lodashinclus 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 n'est pas définie, la valeur par défaut est retourné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 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.

Bien que cela ne vérifie pas nécessairement si une clé existe, il vérifie la véracité d'une valeur. Qui undefinedet nulltomber sous.

Boolean(obj.foo)

Cette solution me convient le mieux, car j'utilise du texte dactylographié, et l'utilisation de chaînes de ce type 'foo' in objou obj.hasOwnProperty('foo')pour vérifier si une clé existe ou non ne me fournit pas d'intellisense.

Si vous voulez vérifier n'importe quelle clé à n'importe quelle profondeur sur un objet et tenir compte des valeurs de falsey, considérez cette ligne pour une fonction d'utilité:

var keyExistsOn = (o, k) => k.split(".").reduce((a, c) => a.hasOwnProperty(c) ? a[c] || 1 : false, Object.assign({}, o)) === false ? false : true;

Résultats

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

Voir également ce package NPM: https://www.npmjs.com/package/has-deep-value

const object1 = {
  a: 'something',
  b: 'something',
  c: 'something'
};

const key = 's';

// Object.keys(object1) will return array of the object keys ['a', 'b', 'c']

Object.keys(object1).indexOf(key) === -1 ? 'the key is not there' : 'yep the key is exist';

Dans le monde des tableaux, nous pouvons considérer les index comme une sorte de clé. Ce qui est surprenant, l' inopérateur (qui est un bon choix pour l'objet) fonctionne également avec les tableaux. La valeur renvoyée pour la clé non existante estundefined

let arr = ["a","b","c"]; // we have indexes: 0,1,2
delete arr[1];           // set 'empty' at index 1
arr.pop();               // remove last item

console.log(0 in arr,  arr[0]);
console.log(1 in arr,  arr[1]);
console.log(2 in arr,  arr[2]);

yourArray.indexOf (yourArrayKeyName)> -1

fruit = ['apple', 'grapes', 'banana']

fruit.indexOf('apple') > -1

vrai

fruit = ['apple', 'grapes', 'banana']

fruit.indexOf('apple1') > -1

faux

Ces exemples peuvent montrer les différences entre les différentes manières. J'espère que cela vous aidera à choisir celui qui convient à 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 impressionnante avec la déstructuration JavaScript :

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

Vérifiez les autres utilisations de JavaScript Destructuring