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

Jeśli klucz nie istnieje i próbuję uzyskać dostęp do niego, czy zwróci fałszywe? Lub rzuć błąd?

3543
Adam Ernst 8 lipiec 2009, 17:21

19 odpowiedzi

Najlepsza odpowiedź

Sprawdzanie nieokreślonego-nessa nie jest dokładnym sposobem testowania, czy klucz istnieje. Co jeśli klucz istnieje, ale wartość jest faktycznie undefined?

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

Należy użyć operatora in:

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

Jeśli chcesz sprawdzić, czy klucz nie istnieje, pamiętaj, aby użyć nawiasów:

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

Lub, jeśli chcesz w szczególności testować właściwości instancji obiektów (a nie odziedziczonych właściwości), użyj hasOwnProperty:

obj.hasOwnProperty("key") // true

W przypadku porównania wydajności między metodami in, hasOwnProperty i klucz jest undefined, zobacz to benchmark

4500
Ates Goral 10 październik 2019, 18:56

Akceptowana odpowiedź odnosi się do Obiekt. Uważaj za pomocą {X0}} Operator na array, 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 na znalezienie Jeśli element znajduje się w tablicy JavaScript?

33
Community 23 maj 2017, 11:55
"key" in obj

Jest prawdopodobne testowanie tylko wartości atrybutów obiektów, które są bardzo różne od klawiszy tablicznych

31
Amal Murali 29 październik 2013, 12:10

Jeśli używasz underscore.js biblioteka Następnie obiekt / operacje tablicy 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

15
vatsal 29 maj 2014, 19:48

Odpowiedź:

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

Wyjaśnienie:

Operator in sprawdzi, czy klucz istnieje w obiekcie. Jeśli sprawdziłeś, czy wartość została undefined: if (myObj["key"] === 'undefined'), mógłbyś wpłynąć na problemy, ponieważ klucz mógł istnieć w obiekcie za pomocą wartości undefined.

Z tego powodu jest to znacznie lepsza praktyka, aby najpierw użyć operatora in, a następnie porównaj wartość, która znajduje się w kluczu, gdy już wiesz, istnieje.

15
Chris McKee 29 czerwiec 2016, 12:46

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

To keyExists(key, search) może być używany do łatwego wyszukiwania klucza w ramach obiektów lub tablic!

Wystarczy podać klucz, który chcesz znaleźć i wyszukać 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

Było dość niezawodne i działa dobrze przeglądarka.

11
hashed_name 18 maj 2019, 10:32

Vanilla Js.

yourObjName.hasOwnProperty(key) : true ? false;

Jeśli chcesz sprawdzić, czy obiekt ma co najmniej jedną nieruchomość w ES2015

Object.keys(yourObjName).length : true ? false
9
Hajji Tarik 25 styczeń 2017, 15:39

Rozwiązanie ES6.

Korzystanie z {x0}} i Object.keys . Powróci true , jeśli podany klawisz 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 jednolity.

console.log(Object.keys({foo: 'one', bar: 'two'}).some(v => v == 'foo'));
9
kind user 26 marzec 2017, 15:45

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

underscore.js sposób -

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

_.has = function(obj, key) {
  return hasOwnProperty.call(obj, key);
};
6
Mohan Dere 2 grudzień 2016, 15:43

Najprostszym sposobem sprawdzenia jest

"key" in object

Na przykład:

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

Zwróć wartość jako true oznacza, że klucz istnieje w obiekcie.

6
shekhardtu 5 listopad 2018, 15:30

Dla tych, którzy mają lodash w swoim projekcie:
Jest lodash _.get Metoda, która próbuje zdobyć "głębokie" klucze:

Pobiera wartość na ścieżce obiektu. Jeśli rozdzielona wartość jest niezdefiniowana, domyślnaValue jest zwracany na swoim miejscu.

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, jednak głęboko , jest zdefiniowany, a nie będzie rzuć błąd, który może zaszkodzić przepływowi programu, jeśli ten klucz nie jest zdefiniowany.

4
vsync 29 marzec 2017, 14:47

Jeśli chcesz sprawdzić dowolny klawisz na dowolnej głębokości na obiekcie i koncie w przypadku wartościowych wartości 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 także ten pakiet NPM: https://www.npmjs.com/package/has- głębokość

4
Alex 17 październik 2018, 12:58

Chociaż niekoniecznie sprawdza, czy klucz istnieje, sprawdza prawdę o wartości. W którym undefined i null.

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') Aby sprawdzić, czy klucz istnieje lub nie zapewnia mi inteligencji.

4
realappie 11 grudzień 2019, 08:57
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';
3
sarea 26 sierpień 2019, 14:12

W świecie "Array" możemy spojrzeć na indeksy jako jakieś klucze. Co jest zaskakujące operator in (który jest dobry wybór dla obiektu) również działa z tablicami. Zwracana wartość 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]);
3
Kamil Kiełczewski 30 styczeń 2020, 09:27

Yourarray.indexof (YourarraykeyName) & GT; -1

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

fruit.indexOf('apple') > -1

true


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

fruit.indexOf('apple1') > -1

false

2
Anupam Maurya 19 luty 2019, 10:59

Przykład te mogą wykazać różnice między różnymi sposobami. Mam nadzieję, że pomoże Ci wybrać właściwy 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"]
0
Alexander 21 luty 2018, 14:23

Nowe niesamowite rozwiązanie z zniszczenie 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

Czy sprawdź Inne użycie niszczenia javascript

-1
NAVIN 31 sierpień 2018, 18:05

Powróci undefined.

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

undefined jest specjalną stałą wartością. Więc możesz 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 sprawdzenia brakujących kluczy. Jednakże, jak wskazano w komentarzu poniżej, jest to teoretycznie możliwe, że chcesz mieć rzeczywistą wartość być undefined. Nigdy nie musiałem tego zrobić i nie mogę myśleć o powodzie, dlaczego kiedykolwiek chciałbym, ale tylko ze względu na kompletność, możesz użyć operatora in

// this works even if you have {"goodbye": undefined}
if( "goodbye" in aa ) {
    // do something
}
156
hashed_name 18 maj 2019, 07:49