web-dev-qa-db-fra.com

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

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?

javascriptarraysobject
2417
Adam Ernst

Vérifier l’indifférence n’est pas un moyen précis de vérifier si une clé existe. Que se passe-t-il 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 l'opérateur in:

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

Si vous voulez vérifier si une clé n'existe pas, pensez à 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 particulièrement tester 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 une comparaison des performances entre les méthodes in, hasOwnProperty et la clé est undefined, voir ceci benchmark

3361
Ates Goral

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. 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 souhaitiez que la valeur réelle soit undefined. Je n'ai jamais eu besoin de faire cela et je ne vois pas pourquoi je voudrais le faire, mais pour être complet, vous pouvez utiliser l'opérateur in.

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

Le réponse acceptée fait référence à Objet . Faites attention en utilisant l'opérateur in on 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: Le meilleur moyen de savoir si un élément est dans un tableau JavaScript?

24
handle
"key" in obj

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

20
user2320522

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. retourne TRUE pour tout sauf la valeur 'false'
  2. 'theProperty' dans obj
    Retournera 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 de prototypes. (Étant donné que 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

20
Lavi Avigdor

Si vous utilisez underscore.js library, 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")

retourne true 

Mais,

_.has(yourArray, "invalidKey")

retourne false

13
vatsal

Réponse: 

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

Explication:

L'opérateur in vérifiera 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 bien préférable d'utiliser d'abord l'opérateur in, puis de comparer la valeur contenue dans la clé une fois que vous savez déjà qu'elle existe.

12
Webeng

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 lui transmettre la clé que vous souhaitez rechercher et de rechercher 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;
}

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 des objets

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

Cela a été assez fiable et fonctionne bien sur plusieurs navigateurs.

9
jaredwilli

vanilla 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
5
Hajji Tarik

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

Le underscore.js way - 

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

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

C'est une vieille question, mais je suppose qu'il n'est jamais trop tard pour donner une réponse.

Imaginez que vous avez un objet "produits" et deux articles. Si vous voulez voir si un identifiant existe déjà dans cet objet, vous pouvez utiliser find () 

products = [
    {
        "id": 1,
        "name": "Name 1"
    },
    {
        "id": 2,
        "name": "Name 2"
    },
  ]

  item1 = 
    {
        "id": 3,
        "name": "Name 3",
    }



  item2 = 
    {
        "id": 1,
        "name": "Name 1",
    }



  if(products.find(x => x.id === item1.id)){
    console.log('id is in products');
  }else {
    console.log('id is not in products');
  }
  if(products.find(x => x.id === item2.id)){
    console.log('id is in products');
  }else {
    console.log('id is not in products');
  }

bûche:

id is not in products
id is in products
2
Admir

Le moyen le 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 renvoyée sous la forme true implique que la clé existe dans l'objet. 

2
shekhardtu

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é, bien que deep, soit définie et ne le sera pas jettera une erreur qui pourrait nuire au flux de votre programme si cette clé n'est pas définie.

1
vsync

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"]
1
Alexander

Si vous souhaitez rechercher une clé quelconque à n'importe quelle profondeur sur un objet et tenir compte des valeurs de Falsey, considérez cette ligne pour une fonction utilitaire:

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

0
Alex

yourArray.indexOf (yourArrayKeyName)> -1 

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

fruit.indexOf('Apple') > -1

vrai

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

fruit.indexOf('Apple1') > -1

faux

0
Anupam Maurya

Nouvelle solution géniale avec JavaScript Destructuring:

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

Ne vérifiez autre utilisation de JavaScript Destructuring

0
NAVIN
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';
0
sarea