Hoe controleer ik of een bepaalde sleutel bestaat in een JavaScript-object of -array?

Als een sleutel niet bestaat en ik probeer er toegang toe te krijgen, retourneert deze dan false? Of een foutmelding geven?

Antwoord 1, autoriteit 100%

Controleren op ongedefinieerdheid is geen nauwkeurige manier om te testen of een sleutel bestaat. Wat als de sleutel bestaat, maar de waarde is eigenlijk undefined?

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

U moet in plaats daarvan de operator ingebruiken:

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

Als u wilt controleren of een sleutel niet bestaat, vergeet dan niet om haakjes te gebruiken:

!("key" in obj) // true if "key" doesn't exist in object
!"key" in obj   // Do not do this! It is equivalent to "false in obj"

Of, als je specifiek wilt testen op eigenschappen van de objectinstantie (en niet op geërfde eigenschappen), gebruik dan hasOwnProperty:

obj.hasOwnProperty("key") // true

Voor prestatievergelijking tussen de methoden in, hasOwnPropertyen de sleutel is undefined, zie deze benchmark

Antwoord 2, autoriteit 7%

Snel antwoord

Hoe controleer ik of een bepaalde sleutel bestaat in een JavaScript-object of -array?
Als een sleutel niet bestaat en ik probeer er toegang toe te krijgen, zal deze dan false retourneren? Of een foutmelding geven?

Als u rechtstreeks toegang krijgt tot een ontbrekende eigenschap met behulp van (associatieve) arraystijl of objectstijl, wordt een undefinedconstante geretourneerd.

De langzame en betrouwbare in-operator en hasOwnProperty-methode

Zoals mensen hier al hebben vermeld, zou je een object kunnen hebben met een eigenschap die is gekoppeld aan een “ongedefinieerde” constante.

var bizzareObj = {valid_key:  undefined};

In dat geval moet u de operator hasOwnPropertyof ingebruiken om te weten of de sleutel er echt is. Maar, maar tegen welke prijs?

dus ik zeg je…

inoperator en hasOwnPropertyzijn “methoden” die het Property Descriptor-mechanisme in Javascript gebruiken (vergelijkbaar met Java-reflectie in de Java-taal).

http://www.ecma-international.org/ecma -262/5.1/#sec-8.10

Het type Property Descriptor wordt gebruikt om de manipulatie en reïficatie van benoemde eigenschapattributen uit te leggen. Waarden van het type Eigenschapsdescriptor zijn records die zijn samengesteld uit benoemde velden waarbij de naam van elk veld een attribuutnaam is en de waarde een overeenkomstige attribuutwaarde is zoals gespecificeerd in 8.6.1. Bovendien kan elk veld aanwezig of afwezig zijn.

Aan de andere kant zal het aanroepen van een objectmethode of sleutel het Javascript [[Get]]-mechanisme gebruiken. Dat is een stuk sneller!

Benchmark

http://jsperf.com/checking- if-a-key-exists-in-a-javascript-array

.

De operator ingebruiken

var result = "Impression" in array;

Het resultaat was

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

HasOwnProperty gebruiken

var result = array.hasOwnProperty("Impression")

Het resultaat was

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

Directe toegang tot elementen (haakjesstijl)

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

Het resultaat was

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

Directe toegang tot elementen (objectstijl)

var result = array.Impression  === undefined;

Het resultaat was

168,303,172 ±0.20%     fastest

EDIT: Wat is de reden om aan een eigenschap de waarde undefinedtoe te kennen?

Die vraag verbaast me. In Javascript zijn er ten minste twee verwijzingen naar afwezige objecten om dit soort problemen te voorkomen: nullen undefined.

nullis de primitieve waarde die de opzettelijke afwezigheid van een objectwaarde vertegenwoordigt, of, kort gezegd, het bevestigdegebrek aan waarde. Aan de andere kant is undefinedeen onbekende waarde (niet gedefinieerd). Als er een eigenschap is die later zal worden gebruikt met een juistewaarde, overweeg dan om de null-referentie te gebruiken in plaats van undefinedomdat op het eerste moment de eigenschap bevestigdgeen waarde te hebben.

Vergelijk:

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[].

Advies

Vermijd objecten met undefinedwaarden. Controleer waar mogelijk direct en gebruik nullom eigenschapswaarden te initialiseren. Gebruik anders de langzame operator inof de methode hasOwnProperty().

EDIT: 12/04/2018 – NIET MEER RELEVANT

Zoals mensen hebben opgemerkt, hebben moderne versies van de Javascript-engines (met uitzondering van Firefox) de benadering voor toegangseigenschappen veranderd. De huidige implementatie is langzamer dan de vorige voor dit specifieke geval, maar het verschil tussen toegangssleutel en object is te verwaarlozen.

Antwoord 3, autoriteit 3%

Het geeft undefinedterug.

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

"key" in obj

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

yourArray = {age: "10"}
_.has(yourArray, "age")

_.has(yourArray, "invalidKey")

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

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

yourObjName.hasOwnProperty(key) : true ? false;

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

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

"key" in object

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

const invoice = {customer: {address: {city: "foo"}}}
console.log( invoice?.customer?.address?.city )
console.log( invoice?.customer?.address?.street )
console.log( invoice?.xyz?.address?.city )

if(_.has(this.options, 'login')){
  //key 'login' exists in this.options 
}
_.has = function(obj, key) {
  return hasOwnProperty.call(obj, key);
};

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

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

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

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

fruit = ['apple', 'grapes', 'banana']
fruit.indexOf('apple') > -1

fruit = ['apple', 'grapes', 'banana']
fruit.indexOf('apple1') > -1

const adventurer = {
  name: 'Alice',
  cat: {
    name: 'Dinah'
  }
}
console.log(adventurer.dog?.name) // undefined
console.log(adventurer.cat?.name) // Dinah

const obj = {foo: 'one', bar: 'two'};
const result = obj.foo ?? "Not found";

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

const hasKey = 'FinancialRiskIntent' in data.meta.prediction.intents;
if(hasKey) {
  console.log('The key exists.');
}
else {
  console.log('The key does not exist.');
}

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

const allowed = {
    '/login' : '',
    '/register': '',
    '/resetpsw': ''
};
console.log('/login' in allowed); //returns true