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

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
}

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?

"key" in obj

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

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

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

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.

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.

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

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

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

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

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. 

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.

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

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

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.

yourArray.indexOf (IhrArrayKeyName)> -1

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

fruit.indexOf('Apple') > -1

wahr

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

fruit.indexOf('Apple1') > -1

false

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

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