Szybka Odpowiedź

Jak sprawdzić, czy dany klucz istnieje w obiekcie lub tablicy JavaScript? Jeśli klucz nie istnieje i spróbuję uzyskać do niego dostęp, czy zwróci false? Albo rzucić błąd?

Bezpośredni dostęp do brakującej właściwości za pomocą (asocjacyjnego) stylu tablicy lub stylu obiektu zwróci niezdefiniowaną stałą .

Powolny i niezawodny w operator i hasOwnProperty metoda

Jak już ludzie wspominali tutaj możesz mieć obiekt z właściwością powiązaną ze stałą "undefined".

 var bizzareObj = {valid_key:  undefined};

W takim przypadku będziesz musiał użyć hasOwnProperty lub w operatorze , aby wiedzieć, czy klucz naprawdę tam jest. Ale za jaką cenę?

Więc, mówię ci...

w operator i hasOwnProperty są "metodami", które używają mechanizmu deskryptora właściwości w Javascript (podobnie jak odbicie Javy w Javie język).

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

Typ deskryptora właściwości jest używany do wyjaśnienia manipulacji i reifikacji nazwanych atrybutów właściwości. Wartości typu deskryptor właściwości są rekordami składającymi się z nazwanych pól, gdzie nazwa każdego pola jest nazwą atrybutu, a jego wartość jest odpowiadającą wartością atrybutu, jak określono w 8.6.1. Ponadto każde pole może być obecne lub nieobecne.

Na drugiej hand, wywołanie metody obiektu lub klucza użyje mechanizmu Javascript [[Get]]. O wiele szybciej!

Benchmark

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

.

var result = "Impression" in array;

Wynik był

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

var result = array.hasOwnProperty("Impression")

Wynik był

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

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

Wynik był

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

var result = array.Impression  === undefined;

Wynik był

168,303,172 ±0.20%     fastest

EDIT: jaki jest powód przypisania właściwości undefined wartości?

null jest prymitywną wartością, która reprezentuje celowy brak jakiejkolwiek wartości obiektu, lub krótko mówiąc, potwierdzony brak wartości. Z drugiej strony, undefined jest nieznaną wartością (nie zdefiniowaną). Jeśli istnieje właściwość, która zostanie użyta później z właściwą wartością, rozważ użycie referencji null zamiast undefined, ponieważ w początkowym momencie właściwość została potwierdzona jako brak wartości.

Porównaj:

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

Porady

Unikaj obiektów o wartościach undefined. Sprawdź bezpośrednio, jeśli to możliwe i użyj null, aby zainicjować wartości właściwości. W przeciwnym razie użyj operatora slow in lub metody hasOwnProperty().

EDYCJA: 12/04/2018-NIE DOTYCZY ANYMORE

Jak ludzie komentowali, współczesne wersje silników Javascript (z wyjątkiem Firefoksa) zmieniły podejście do właściwości dostępu. Obecna implementacja jest wolniejsza niż poprzednia w tym konkretnym przypadku, ale różnica między kluczem dostępu a obiektem jest zaniedbywalna.

Zwróci undefined.

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

undefined jest specjalną wartością stałą. Można więc powiedzieć, np.

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

To prawdopodobnie najlepszy sposób na sprawdzenie brakujących kluczy. Jednak, jak wskazano w komentarzu poniżej, teoretycznie możliwe jest, że chcesz mieć rzeczywistą wartość undefined. Nigdy nie musiałem tego robić i nie mogę wymyślić powodu, dla którego bym chciał, ale dla kompletności możesz użyć operatora in

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

Zaakceptowana odpowiedźodnosi się do obiektu. Uważaj na używanie in operator na tablicy, aby znaleźć dane zamiast kluczy:

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

Aby przetestować istniejące elementy w tablicy: najlepszy sposób, aby znaleźć, czy element znajduje się w tablicy JavaScript?

"key" in obj

Prawdopodobnie testuje tylko wartości atrybutów obiektów, które bardzo różnią się od kluczy tablicy

Trzy sposoby sprawdzenia, czy właściwość jest obecna w obiekcie javascript:

1. !!obj.theProperty
   Zamieni wartość na bool. zwraca true dla wszystkich poza false wartość
2. 'theProperty' in obj
   Zwróci true, Jeśli właściwość istnieje, bez względu na jej wartość (nawet pustą)
3. obj.hasOwnProperty('theProperty')
   Nie sprawdza łańcucha prototypów. (ponieważ wszystkie obiekty mają metodę toString, 1 i 2 zwrócą wartość true, podczas gdy 3 mogą zwrócić wartość false to.)

Odniesienie:

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

Jeśli używasz podkreślenia.biblioteka JS wtedy operacje na obiektach/tablicach stają się proste.

W Twoim przypadku _.można zastosować metodę has. Przykład:

yourArray = {age: "10"}

_.has(yourArray, "age")

Zwraca true

Ale,

_.has(yourArray, "invalidKey")

Zwraca false

ODPOWIEDŹ:

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

Explanation:

Operator in sprawdzi, czy klucz istnieje w obiekcie. Jeśli sprawdziłeś, czy wartość była niezdefiniowana: if (myObj["key"] === 'undefined'), możesz napotkać problemy, ponieważ klucz może istnieć w Twoim obiekcie z wartością undefined.

Z tego powodu o wiele lepszą praktyką jest najpierw użycie operatora in, a następnie porównanie wartości znajdującej się wewnątrz klucza, gdy już wiesz, że istnieje.

Oto funkcja pomocnicza, którą uważam za bardzo przydatną

Ten keyExists(key, search) może być użyty do łatwego wyszukania klucza w obiektach lub tablicach!

Po prostu podaj klucz, który chcesz znaleźć, i wyszukaj obj (obiekt lub tablicę), w którym chcesz go znaleźć.

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

Jest dość niezawodny i działa dobrze między przeglądarkami.

Vanila js

yourObjName.hasOwnProperty(key) : true ? false;

Jeśli chcesz sprawdzić, czy obiekt ma przynajmniej jedną właściwość w es2015

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

Rozwiązanie ES6

Za pomocą Array#some oraz Object.keys. Zwróci true jeśli dany klucz istnieje w obiekcie lub false jeśli nie.

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

Przykład jednowierszowy.

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

Możemy użyć - hasOwnProperty.call(obj, key);

Podkreślenie.js way-

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

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

Najprostszym sposobem sprawdzenia jest

"key" in object

Na przykład:

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

Wartość zwracana jako true oznacza, że klucz istnieje w obiekcie.

Dla tych, którzy mają lodash włączone w ich projekcie:
istnieje lodash _.get metoda, która próbuje uzyskać "głębokie" klucze:

Pobiera wartość w path obiektu. Jeśli rozwiązana wartość jest niezdefiniowana, defaultValue jest zwracana w jego miejsce.

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>

To skutecznie sprawdzi, czy ten klucz, jakkolwiek deep , jest zdefiniowany i nie wyrzuci błędu, który może zaszkodzić przepływowi Twojego programu, jeśli ten klucz nie jest zdefiniowany.

Jeśli chcesz sprawdzić dowolny klucz na dowolnej głębokości obiektu i uwzględnić wartości false rozważ tę linię dla funkcji użytkowej:

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

Wyniki

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

Zobacz też ten pakiet NPM: https://www.npmjs.com/package/has-deep-value

Chociaż niekoniecznie sprawdza, czy klucz istnieje, sprawdza prawdziwość wartości. Które undefined i null podlegają

Boolean(obj.foo)

To rozwiązanie działa najlepiej dla mnie, ponieważ używam maszynopisu i używam ciągów takich jak 'foo' in obj lub obj.hasOwnProperty('foo') sprawdzenie, czy klucz istnieje, czy nie, nie dostarcza mi inteligencji.

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

W świecie 'array' możemy patrzeć na indeksy jak na jakiś rodzaj kluczy. Co zaskakujące operator in (który jest dobrym wyborem dla obiektu) działa również z tablicami. Zwracaną wartością dla nieistniejącego klucza jest undefined

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

Twoja kolej.indexOf(Twoja nazwa) > -1

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

fruit.indexOf('apple') > -1

true

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

fruit.indexOf('apple1') > -1

false

Ten przykład może wykazać różnice między defferent ways. Mam nadzieję, że pomoże Ci wybrać odpowiedni dla Twoich potrzeb: {]}

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

Szybkim i łatwym rozwiązaniem jest przekonwertowanie obiektu na json, wtedy będziesz mógł wykonać to proste zadanie:

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

Jeśli użyjesz tablicy, klucz obiektu zostanie przekonwertowany na liczby całkowite ex 0,1,2,3 itd. dlatego zawsze będzie fałszywy

Nowe niesamowite rozwiązanie z destrukcją JavaScript :

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

Sprawdź inne użycie destrukcji JavaScript