Jak sprawdzić, czy określony klucz istnieje w obiekcie lub tablicy JavaScript?

Jeśli klucz nie istnieje i spróbuję uzyskać do niego dostęp, czy zwróci wartość false? Lub rzucić błąd?

Sprawdzanie niezdefiniowanej nie jest dokładnym sposobem sprawdzenia, czy klucz istnieje. Co jeśli klucz istnieje, ale wartość jest rzeczywiście undefined?

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

Zamiast tego powinieneś użyć inoperatora:

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

Jeśli chcesz sprawdzić, czy klucz nie istnieje, pamiętaj o użyciu nawiasu:

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

Lub jeśli chcesz szczególnie przetestować właściwości instancji obiektu (a nie właściwości dziedziczone), użyj hasOwnProperty:

obj.hasOwnProperty("key") // true

Dla porównania wydajności między metodami, które są in, hasOwnPropertya kluczem jest undefined, zobacz ten wzorzec

szybka odpowiedź

Jak sprawdzić, czy określony klucz istnieje w obiekcie lub tablicy JavaScript? Jeśli klucz nie istnieje i spróbuję uzyskać do niego dostęp, czy zwróci wartość false? Lub 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łą.

Powolne i niezawodne w operatora i hasOwnProperty Sposób

Jak już wspomniano tutaj, możesz mieć obiekt o właściwości powiązanej z „niezdefiniowaną” stałą.

 var bizzareObj = {valid_key:  undefined};

W takim przypadku trzeba będzie używać hasOwnProperty lub w operatora wiedzieć, czy klucz jest naprawdę istnieje. Ale, ale za jaką cenę?

więc mówię ci ...

w operator i hasOwnProperty są „metodami”, które wykorzystują mechanizm deskryptora właściwości w Javascript (podobny do odbicie Java w języku Java).

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

Typ deskryptora właściwości służy do wyjaśnienia manipulacji i weryfikacji nazwanych atrybutów właściwości. Wartości typu Deskryptor właściwości to rekordy złożone z nazwanych pól, w których nazwa każdego pola jest nazwą atrybutu, a jego wartość jest odpowiednią wartością atrybutu określoną w 8.6.1. Ponadto dowolne pole może być obecne lub nieobecne.

Z drugiej strony wywołanie metody obiektu lub klucza spowoduje użycie mechanizmu Javascript [[Get]]. To jest o wiele szybsze!

reper

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

EDYCJA: Jaki jest powód przypisania do właściwości undefinedwartości?

To pytanie mnie zastanawia. W Javascripcie istnieją co najmniej dwa odwołania do nieobecnych obiektów, aby uniknąć takich problemów: nulli undefined.

nulljest pierwotną wartością, która reprezentuje celowy brak jakiejkolwiek wartości obiektu, lub w skrócie potwierdzony brak wartości. Z drugiej strony, undefinedwartość nieznana (nie zdefiniowana). Jeśli istnieje właściwość, która zostanie użyta później z odpowiednią wartością, rozważ użycie nullodwołania zamiast, undefinedponieważ w początkowej chwili potwierdzono, że właściwość nie ma wartości.

Porównać:

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

Doradzać

Unikaj obiektów z undefinedwartościami. Sprawdź bezpośrednio, gdy tylko jest to możliwe, i użyj, nullaby zainicjować wartości właściwości. W przeciwnym razie użyj powolnego inoperatora lub hasOwnProperty()metody.

EDYCJA: 12.04.2018 - NIE JEST ODPOWIEDNIE

Jak ludzie skomentowali, nowoczesne wersje silników JavaScript (z wyjątkiem Firefoxa) zmieniły podejście do właściwości dostępu. Bieżąca implementacja jest wolniejsza niż poprzednia w tym konkretnym przypadku, ale różnice między kluczem dostępu a obiektem są pomijalne.

Wróci undefined.

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

undefinedjest specjalną stałą wartością. Możesz więc powiedzieć np

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

Jest 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ć żadnego powodu, dla którego kiedykolwiek bym tego chciał, ale ze względu na kompletność możesz użyć inoperatora

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

Odpowiedź Zaakceptowany odnosi się do obiektu . Strzeż się za pomocą inoperatora na tablicy znaleźć dane zamiast klawiszy:

("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 na sprawdzenie, czy element znajduje się w tablicy JavaScript?

"key" in obj

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

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

1. !! obj.theProperty
   Konwertuje wartość na bool. zwraca PRAWDA dla wszystkich oprócz wartości „fałsz”
2. „theProperty” w obj Zwróci wartość
   true, jeśli właściwość istnieje, bez względu na jej wartość (nawet pusta)
3. obj.hasOwnProperty ('theProperty')
   Nie sprawdza łańcucha prototypów. (ponieważ wszystkie obiekty mają metodę „toString”, 1 i 2 zwrócą na niej wartość true, a 3 może zwrócić na niej wartość false).

Odniesienie:

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

Jeśli używasz biblioteki underscore.js, operacje na obiektach / tablicach stają się proste.

W twoim przypadku można zastosować metodę _. 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!");
}

Wyjaśnienie:

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

Z tego powodu dużo lepszą praktyką jest najpierw użycie inoperatora, a następnie porównanie wartości znajdującej się w kluczu, gdy już wiesz, że on istnieje.

Oto funkcja pomocnika, którą uważam za całkiem przydatną

To keyExists(key, search)może być używany do łatwo odszukać klucz wewnątrz obiektów lub tablic!

Po prostu przekaż mu klucz, który chcesz znaleźć, i wyszukaj obiekt 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 w różnych przeglądarkach.

vanila js

yourObjName.hasOwnProperty(key) : true ? false;

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

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

Rozwiązanie ES6

za pomocą Array#somei Object.keys. Zwróci wartość true, jeśli dany klucz istnieje w obiekcie, lub false, jeśli nie istnieje.

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

Sposób underscore.js -

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

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

Najłatwiejszym sposobem sprawdzenia jest

"key" in object

na przykład:

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

Zwracana wartość jako prawda oznacza, że ​​klucz istnieje w obiekcie.

Dla tych, którzy wzięli lodashudział w projekcie:
Istnieje metoda lodash _.get , która próbuje uzyskać „głębokie” klucze:

Pobiera wartość na ścieżkę obiektu. Jeśli rozstrzygnięta wartość nie jest zdefiniowana, wartość defaultValue jest zwracana w jej 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 głęboki , jest zdefiniowany i nie wyrzuci błędu, który mógłby zaszkodzić przepływowi twojego programu, jeśli ten klucz nie zostanie zdefiniowany.

Chociaż nie musi to sprawdzać, czy klucz istnieje, sprawdza prawdziwość wartości. Które undefinedi nullnależą do.

Boolean(obj.foo)

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

Jeśli chcesz sprawdzić dowolny klucz na dowolnej głębokości obiektu i uwzględnić wartości falsey, rozważ ten wiersz funkcji funkcji:

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 także ten pakiet NPM: https://www.npmjs.com/package/has-deep-value

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 „tablicowym” indeksy możemy traktować jak pewien rodzaj kluczy. Co zaskakujące, inoperator (który jest dobrym wyborem dla obiektu) działa również z tablicami. Zwrócona wartość nieistniejącego klucza toundefined

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

yourArray.indexOf (yourArrayKeyName)> -1

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

fruit.indexOf('apple') > -1

prawdziwe

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

fruit.indexOf('apple1') > -1

fałszywe

Te przykłady mogą wykazać różnice między różnymi sposobami. Mam nadzieję, że pomoże Ci wybrać odpowiedni dla swoich 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"]

Nowe niesamowite rozwiązanie z JavaScript Destrukturyzacją :

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 JavaScript Destrukturyzacja