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




key in (17)

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?


Answers

Voici une fonction d'aide que je trouve assez utile

Cette keyExists(key, search) peut être utilisée 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.


Le moyen le plus simple de vérifier est

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

par exemple:

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

Si la valeur renvoyée est vraie, cela signifie que la clé existe dans l'objet.


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

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


Solution ES6

using Array#some et Object.keys . Il retournera vrai si la clé donnée existe dans l'objet ou faux 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'));



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.


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

"key" in object

Résultats

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

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


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 par souci d'exhaustivité, vous pouvez utiliser l'opérateur in

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

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")

retourne vrai

Mais,

_.has(yourArray, "invalidKey")

retourne faux


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

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

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.


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 comparer les performances entre les méthodes utilisées, hasOwnProperty et la clé n’est undefined , voir le présent document de jsben.ch/#/WqlIl


"key" in obj

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


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.


Ce n’est certes pas le meilleur, mais j’étais juste en train de faire preuve de créativité et d’ajouter au répertoire.

Ne pas utiliser ce

Object.defineProperty(Array.prototype, 'exists', {
  value: function(element, index) {

    var index = index || 0

    return index === this.length ? -1 : this[index] === element ? index : this.exists(element, ++index)
  }
})


// Outputs 1
console.log(['one', 'two'].exists('two'));

// Outputs -1
console.log(['one', 'two'].exists('three'));

console.log(['one', 'two', 'three', 'four'].exists('four'));





javascript arrays object