it-swarm.com.de

Prüfen, ob ein Schlüssel in einem JavaScript-Objekt vorhanden ist?

Wie überprüfe ich, ob ein bestimmter Schlüssel in einem JavaScript-Objekt oder -Array vorhanden ist?

Wenn ein Schlüssel nicht existiert und ich versuche, darauf zuzugreifen, wird er falsch zurückgegeben? Oder einen Fehler werfen?

2417
Adam Ernst

Das Überprüfen auf Undefiniertheit ist keine genaue Methode, um zu prüfen, ob ein Schlüssel vorhanden ist. Was ist, wenn der Schlüssel existiert, der Wert jedoch tatsächlich undefined ist?

var obj = { key: undefined };
obj["key"] != undefined // false, but the key exists!

Verwenden Sie stattdessen den Operator in:

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

Wenn Sie prüfen möchten, ob ein Schlüssel nicht vorhanden ist, denken Sie daran, Klammern zu verwenden:

!("key" in obj) // true if "key" doesn't exist in object
!"key" in obj   // ERROR!  Equivalent to "false in obj"

Wenn Sie insbesondere die Eigenschaften der Objektinstanz (und nicht die geerbten Eigenschaften) testen möchten, verwenden Sie hasOwnProperty:

obj.hasOwnProperty("key") // true

Für den Leistungsvergleich zwischen den Methoden, die in, hasOwnProperty sind, und dem Schlüssel undefined, siehe diesen benchmark

3361
Ates Goral

Es wird undefined zurückgegeben.

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

undefined ist ein spezieller konstanter Wert. So können Sie sagen, z.

// note the three equal signs so that null won't be equal to undefined
if( aa["goodbye"] === undefined ) {
    // do something
}

Dies ist wahrscheinlich der beste Weg, um nach fehlenden Schlüsseln zu suchen. Wie in einem Kommentar unten ausgeführt, ist es theoretisch möglich, dass der tatsächliche Wert undefined sein soll. Ich habe das nie tun müssen und kann mir keinen Grund dafür ausdenken, warum ich das je wollte. Aber der Vollständigkeit halber können Sie den Operator in verwenden

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

Die akzeptierte Antwort bezieht sich auf Object . Verwenden Sie den Operator in on Array , um Daten anstelle von Schlüsseln zu suchen:

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

So testen Sie vorhandene Elemente in einem Array: Finden Sie am besten heraus, ob sich ein Element in einem JavaScript-Array befindet?

24
handle
"key" in obj

Testet wahrscheinlich nur Objektattributwerte, die sich stark von Array-Schlüsseln unterscheiden

20
user2320522

Drei Möglichkeiten, um zu überprüfen, ob eine Eigenschaft in einem Javascript-Objekt vorhanden ist:

  1. !! obj.theProperty
    Konvertiert den Wert in bool. gibt TRUE für alle außer den Wert 'false' zurück
  2. 'theProperty' in obj
    Gibt true zurück, wenn die Eigenschaft vorhanden ist, unabhängig von ihrem Wert (auch leer).
  3. obj.hasOwnProperty ('theProperty')
    Die Prototypkette wird nicht geprüft. (Da alle Objekte die Methode 'toString' haben, geben 1 und 2 den Wert true zurück, während 3 den Wert false zurückgeben kann.)

Referenz: 

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

20
Lavi Avigdor

Wenn Sie underscore.js library verwenden, werden Objekt-/Array-Operationen einfacher. 

In Ihrem Fall kann die Methode _.has verwendet werden. Beispiel:

yourArray = {age: "10"}

_.has(yourArray, "age")

gibt true zurück 

Aber,

_.has(yourArray, "invalidKey")

gibt false zurück

13
vatsal

Antworten:

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

Erklärung:

Der Operator in prüft, ob der Schlüssel im Objekt vorhanden ist. Wenn Sie überprüft haben, ob der Wert nicht definiert war: if (myObj["key"] === 'undefined'), könnten Probleme auftreten, da möglicherweise ein Schlüssel in Ihrem Objekt mit dem Wert undefined vorhanden ist.

Aus diesem Grund ist es viel besser, zuerst den Operator in zu verwenden und dann den Wert innerhalb des Schlüssels zu vergleichen, sobald Sie wissen, dass er existiert.

12
Webeng

Hier ist eine Hilfsfunktion, die ich sehr nützlich finde

Mit dieser keyExists(key, search) können Sie einen Schlüssel in Objekten oder Arrays einfach nachschlagen! 

Übergeben Sie einfach den Schlüssel, den Sie suchen, und suchen Sie nach obj (dem Objekt oder Array), in dem Sie es suchen möchten.

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;
}

Wie man es benutzt:

Suchen nach Schlüsseln in Arrays

keyExists('Apple', ['Apple', 'banana', 'orange']); // true
keyExists('fruit', ['Apple', 'banana', 'orange']); // false

Suchen nach Schlüsseln in Objekten

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

Es ist ziemlich zuverlässig und funktioniert gut über Browser.

9
jaredwilli

ES6-Lösung

mit Array#some und Object.keys. Es wird true zurückgegeben, wenn der angegebene Schlüssel im Objekt vorhanden ist, oder false if tut es nicht.

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

Einzeiliges Beispiel.

console.log(Object.keys({foo: 'one', bar: 'two'}).some(v => v == 'foo'));
5
kind user

vanille Js

yourObjName.hasOwnProperty(key) : true ? false;

Wenn Sie prüfen möchten, ob das Objekt mindestens eine Eigenschaft in es2015 hat

Object.keys(yourObjName).length : true ? false
5
Hajji Tarik

Wir können verwenden - hasOwnProperty.call(obj, key);

Die 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

Dies ist eine alte Frage, aber ich denke nie zu spät, um eine Antwort zu geben.

Stellen Sie sich vor, Sie haben ein Objekt "Produkte" und zwei Artikel. Wenn Sie sehen möchten, ob die ID in diesem Objekt bereits vorhanden ist, können Sie find () verwenden. 

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

log:

id is not in products
id is in products
2
Admir

Der einfachste Weg zu überprüfen ist 

"key" in object

zum Beispiel: 

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

Rückgabewert als true impliziert, dass der Schlüssel im Objekt vorhanden ist. 

2
shekhardtu

Für diejenigen, die lodash in ihr Projekt aufgenommen haben:
Es gibt eine lodash _.get - Methode, die versucht, "tiefe" Schlüssel zu bekommen:

Ruft den Wert im Pfad des Objekts ab. Wenn der aufgelöste Wert undefiniert ist, wird Der defaultValue wird an seiner Stelle zurückgegeben.

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>


Dadurch wird effektiv geprüft, ob dieser Schlüssel, jedoch deep, definiert ist, und wird nicht einen Fehler auslösen, der den Ablauf Ihres Programms beeinträchtigen könnte, wenn dieser Schlüssel nicht definiert ist.

1
vsync

Dieses Beispiel kann die Unterschiede zwischen den verschiedenen Möglichkeiten aufzeigen. Ich hoffe, es hilft Ihnen, das Richtige für Ihre Bedürfnisse auszuwählen:

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

Wenn Sie nach einem beliebigen Schlüssel in einer beliebigen Tiefe eines Objekts suchen und Falsey-Werte berücksichtigen möchten, betrachten Sie diese Zeile für eine Hilfsfunktion:

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

Ergebnisse

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

Siehe auch dieses NPM-Paket: https://www.npmjs.com/package/has-deep-value

0
Alex

Während dies notwendigerweise prüft, ob ein Schlüssel existiert, prüft es die Richtigkeit eines Wertes. Welche undefined und null fallen unter.

Boolean(obj.foo)

Diese Lösung eignet sich am besten für mich, da ich TypeScript verwende und Zeichenfolgen wie 'foo' in obj Oder obj.hasOwnProperty('foo') verwende, um zu überprüfen, ob ein Schlüssel vorhanden ist oder nicht.

0
realappie

yourArray.indexOf (IhrArrayKeyName)> -1

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

fruit.indexOf('Apple') > -1

wahr


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

fruit.indexOf('Apple1') > -1

false

0
Anupam Maurya

Neue tolle Lösung mit 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

Überprüfen Sie andere Verwendung von 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