Checking if a key exists in a JavaScript object?

Question

How do I check if a particular key exists in a JavaScript object or array?

If a key doesn't exist, and I try to access it, will it return false? Or throw an error?

• Andrew Larsson: Everything (almost everything) in JavaScript is an Object or can be cast as one. This is where pseudo associative arrays are born just like @PatrickM pointed out.
• EscapeNetscape: this benchmark jsben.ch/#/WqlIl gives you an overview over the most common ways how to achieve this check.
• RGLSV: a quick workaround, usually I go for property.key = property.key || 'some default value', just in case I want that key to exist with some value to it
• Tom Stambaugh: Just a warning to those coming to this in 2022 -- MalwareBytes throws warnings at the "benchmark" link posted by @EscapeNetscape above. It might have been ok in 2016 when posted -- I suggest avoiding it now.

Answer 1

Checking for undefined-ness is not an accurate way of testing whether a key exists. What if the key exists but the value is actually undefined?

var obj = { key: undefined };
console.log(obj["key"] !== undefined); // false, but the key exists!

You should instead use the in operator:

var obj = { key: undefined };
console.log("key" in obj); // true, regardless of the actual value

If you want to check if a key doesn't exist, remember to use parenthesis:

var obj = { not_key: undefined };
console.log(!("key" in obj)); // true if "key" doesn't exist in object
console.log(!"key" in obj); // Do not do this! It is equivalent to "false in obj"

Or, if you want to particularly test for properties of the object instance (and not inherited properties), use hasOwnProperty:

var obj = { key: undefined };
console.log(obj.hasOwnProperty("key")); // true

For performance comparison between the methods that are in, hasOwnProperty and key is undefined, see this benchmark:

Benchmark results

• Ateş Göral: I'm convinced that there are use cases for having properties intentionally set to undefined.
• SamGoody: Valid use case: Gecko 1.9.1 [Firefox 3.5] has no window.onhashchange property. Gecko 1.9.2 [Firefox 3.6] has this property set to undefined (until the hash changes). To feature detect the hash history or the browser version, one must use window.hasOwnProperty("onhashchange")
• Simon_Weaver: Random fact: properties set to undefined won't get serialized by JSON.stringify(...), whereas null does. So anything set to undefined that is round tripped to JSON will simply disappear. You can also use delete obj.propName to remove a property from an object.
• Laurel: The benchmark has completely different results for me. Shouldn't it be updated? (Also please describe your images better than "Benchmark results", this is useless for a person who needs the alt text because they can't see the image.)
• VLAZ: @Laurel "Shouldn't it be updated?" no. because all benchmarks are wrong. Even if we are assume they are correct now they might not be tomorrow after one or more environment gets updated. And even the assumption that they are correct is a huge one to begin with as a microbenchmark divorced of context does not actually show useful information. Real data in a real application might have different performance characteristics. Note how this benchmark does not specify in which environment it was ran thus incomplete. So what should be done with the benchmark is to be removed and never used.

Answer 2

Quick Answer

How do I check if a particular key exists in a JavaScript object or array? If a key doesn't exist and I try to access it, will it return false? Or throw an error?

Accessing directly a missing property using (associative) array style or object style will return an undefined constant.

The slow and reliable in operator and hasOwnProperty method

As people have already mentioned here, you could have an object with a property associated with an "undefined" constant.

 var bizzareObj = {valid_key: undefined};

In that case, you will have to use hasOwnProperty or in operator to know if the key is really there. But, but at what price?

so, I tell you...

in operator and hasOwnProperty are "methods" that use the Property Descriptor mechanism in Javascript (similar to Java reflection in the Java language).

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

The Property Descriptor type is used to explain the manipulation and reification of named property attributes. Values of the Property Descriptor type are records composed of named fields where each field’s name is an attribute name and its value is a corresponding attribute value as specified in 8.6.1. In addition, any field may be present or absent.

On the other hand, calling an object method or key will use Javascript [[Get]] mechanism. That is a far way faster!

Benchmark

https://jsben.ch/HaHQt

Comparing key access in JS.

Using in operator

var result = "Impression" in array;

The result was

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

Using hasOwnProperty

var result = array.hasOwnProperty("Impression")

The result was

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

Accessing elements directly (brackets style)

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

The result was

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

Accessing elements directly (object style)

var result = array.Impression === undefined;

The result was

168,303,172 ±0.20% fastest

EDIT: What is the reason to assign to a property the undefined value?

That question puzzles me. In Javascript, there are at least two references for absent objects to avoid problems like this: null and undefined.

null is the primitive value that represents the intentional absence of any object value, or in short terms, the confirmed lack of value. On the other hand, undefined is an unknown value (not defined). If there is a property that will be used later with a proper value consider use null reference instead of undefined because in the initial moment the property is confirmed to lack value.

Compare:

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

Advice

Avoid objects with undefined values. Check directly whenever possible and use null to initialize property values. Otherwise, use the slow in operator or hasOwnProperty() method.

EDIT: 12/04/2018 - NOT RELEVANT ANYMORE

As people have commented, modern versions of the Javascript engines (with firefox exception) have changed the approach for access properties. The current implementation is slower than the previous one for this particular case but the difference between access key and object is neglectable.

Answer 3

It will return undefined.

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

undefined is a special constant value. So you can say, e.g.

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

This is probably the best way to check for missing keys. However, as is pointed out in a comment below, it's theoretically possible that you'd want to have the actual value be undefined. I've never needed to do this and can't think of a reason offhand why I'd ever want to, but just for the sake of completeness, you can use the in operator

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

• Nosredna: Yes. It returns undefined whether it is created as an object or an array.
• Ateş Göral: What if the key exists but the value is actually undefined?
• Matthew Crumley: You should use === instead of == when comparing to undefined, otherwise null will compare equal to undefined.
• Sergei: @AtesGoral the question is about the key not the value

Answer 4

1. Checking for properties of the object including inherited properties

This could be determined using the in operator which returns true if the specified property is in the specified object or it's prototype chain, false otherwise

const person = { name: 'dan' };
console.log('name' in person); // true
console.log('age' in person); // false

2. Checking for properties of the object instance (not including inherited properties)

*2021 - Using the new method ***Object.hasOwn() as a replacement for Object.hasOwnProperty()

Object.hasOwn() is intended as a replacement for Object.hasOwnProperty() and is a new method available to use (yet still not fully supported by all browsers like safari yet but soon will be)

Object.hasOwn() is a static method which returns true if the specified object has the specified property as its own property. If the property is inherited, or does not exist, the method returns false.

const person = { name: 'dan' };
console.log(Object.hasOwn(person, 'name'));// true
console.log(Object.hasOwn(person, 'age'));// false
const person2 = Object.create({gender: 'male'});
console.log(Object.hasOwn(person2, 'gender'));// false

What is the motivation to use it over Object.prototype.hasOwnProperty? - It is recommended to use this method over the Object.hasOwnProperty() because it also works for objects created by using Object.create(null) and for objects that have overridden the inherited hasOwnProperty() method. Although it's possible to solve these kind of problems by calling Object.prototype.hasOwnProperty() on an external object, Object.hasOwn() overcome these problems, hence is preferred (see examples below)

let person = {
 hasOwnProperty: function() {
 return false;
 },
 age: 35
};
if (Object.hasOwn(person, 'age')) {
 console.log(person.age); // true - the remplementation of hasOwnProperty() did not affect the Object
}

let person = Object.create(null);
person.age = 35;
if (Object.hasOwn(person, 'age')) {
 console.log(person.age); // true - works regardless of how the object was created
}

More about Object.hasOwn can be found here : https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwn

Browser compatibility for Object.hasOwn - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwn#browser_compatibility

Answer 5

"key" in obj

Is likely testing only object attribute values that are very different from array keys

Answer 6

The accepted answer refers to Object. Beware using the in operator on Array to find data instead of keys:

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

To test existing elements in an Array: Best way to find if an item is in a JavaScript array?

Answer 7

Three ways to check if a property is present in a javascript object:

1. !!obj.theProperty
   Will convert value to bool. returns true for all but the false value
2. 'theProperty' in obj
   Will return true if the property exists, no matter its value (even empty)
3. obj.hasOwnProperty('theProperty')
   Does not check the prototype chain. (since all objects have the toString method, 1 and 2 will return true on it, while 3 can return false on it.)

Reference:

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

• ARJUN: !!obj.theProperty fails when value is undefined. Ex: var a = {a : undefined, b : null}; !!a.a **will return false**
• traktor: from review: !!obj.theProperty is not a solution to check if an object has a property named theProperty. It fails for any falsey property value, undefined, null, numeric 0 or NaN, and the empty string ""

Answer 8

If you are using underscore.js library then object/array operations become simple.

In your case _.has method can be used. Example:

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

returns true

But,

_.has(yourArray, "invalidKey")

returns false

Answer 9

Answer:

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

Explanation:

The in operator will check if the key exists in the object. If you checked if the value was undefined: if (myObj["key"] === 'undefined'), you could run into problems because a key could possibly exist in your object with the undefined value.

For that reason, it is much better practice to first use the in operator and then compare the value that is inside the key once you already know it exists.

Answer 10

To find if a key exists in an object, use

Object.keys(obj).includes(key)

The ES7 includes method checks if an Array includes an item or not, & is a simpler alternative to indexOf.

• spetsnaz: not a good choice if you have integer keys such as myArray[456] = 'John'; because for some reason Object.keys() returns keys as string items, not integer ones so includes() won't play nice.

Answer 11

Here's a helper function I find quite useful

This keyExists(key, search) can be used to easily lookup a key within objects or arrays!

Just pass it the key you want to find, and search obj (the object or array) you want to find it in.

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

It's been pretty reliable and works well cross-browser.

• Nick F: This seems a bit confused: firstly, when searching an Array this method is checking for a value, not a key. Secondly, why iterate through an array like this when you can use the built-in Array.indexOf method? (if you're looking for a value, that is)

Answer 12

Optional chaining operator:

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

See supported browsers list

---

For those which have lodash included in their project:
There is a lodash _.get method which tries to get "deep" keys:

Gets the value at path of object. If the resolved value is undefined, the defaultValue is returned in its place.

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>

---

This will effectively check if that key, however deep, is defined and will not throw an error which might harm the flow of your program if that key is not defined.

Answer 13

vanila js

yourObjName.hasOwnProperty(key) : true ? false;

If you want to check if the object has at least one property in es2015

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

Answer 14

ES6 solution

using Array#some and Object.keys . It will return true if given key exists in the object or false if it doesn't.

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

One-line example.

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

• Sid: It will fail for non-numerable properties of the object.
• kind user: @Sid Give me some example.
• Sid: Here you go. let joshua = { name: 'Joshua', address: 'London' }; Object.defineProperty(joshua, 'isMarried', { value: true, enumerable: false}); console.log('isMarried' in Object.keys(joshua))
• Sid: I'm applying your solution on my object. Shouldn't it be giving true for first output ? console.log(Object.keys(joshua).some(v => v == 'isMarried')); console.log(joshua.isMarried)
• Sid: I'm sorry but did you check the output of second console statement ? Object.defineProperty is equivalent to setting the property using dot notation.

Answer 15

Optional Chaining (?.) operator can also be used for this

Source: MDN/Operators/Optional_chaining

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

Answer 16

The easiest way to check is

"key" in object

for example:

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

Return value as true implies that key exists in the object.

Answer 17

If you want to check for any key at any depth on an object and account for falsey values consider this line for a utility function:

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

Results

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

Also see this NPM package: https://www.npmjs.com/package/has-deep-value

Answer 18

An alternate approach using "Reflect"

As per MDN

Reflect is a built-in object that provides methods for interceptable JavaScript operations.

The static Reflect.has() method works like the in operator as a function.

var obj = {
 a: undefined,
 b: 1,
 c: "hello world"
}
console.log(Reflect.has(obj, 'a'))
console.log(Reflect.has(obj, 'b'))
console.log(Reflect.has(obj, 'c'))
console.log(Reflect.has(obj, 'd'))

Should I use it ?

It depends.

Reflect.has() is slower than the other methods mentioned on the accepted answer (as per my benchmark test). But, if you are using it only a few times in your code, I don't see much issues with this approach.

Answer 19

We can use - hasOwnProperty.call(obj, key);

The underscore.js way -

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

Answer 20

While this doesn't necessarily check if a key exists, it does check for the truthiness of a value. Which undefined and null fall under.

Boolean(obj.foo)

This solution works best for me because I use typescript, and using strings like so 'foo' in obj or obj.hasOwnProperty('foo') to check whether a key exists or not does not provide me with intellisense.

Answer 21

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

Answer 22

Worth noting that since the introduction of ES11 you can use the nullish coalescing operator, which simplifies things a lot:

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

The code above will return "Not found" for any "falsy" values in foo. Otherwise it will return obj.foo.

See Combining with the nullish coalescing operator

Answer 23

Try in

In 'array' world we can look on indexes as some kind of keys. What is surprising the in operator (which is good choice for object) also works with arrays. The returned value for non-existed key is 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]);

Answer 24

yourArray.indexOf(yourArrayKeyName) > -1

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

true

---

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

false

---

for strict object keys checking:

const object1 = {};
object1.stackoverflow = 51; 
console.log(object1.hasOwnProperty('stackoverflow')); 
output: true 

• ken: Those are values, not keys.
• Anupam Maurya: okay, for object checking you can use Object.keys({}).length where it returns length of that array object. for example Object.keys({}).length output -> 0
• Anupam Maurya: use this.. @ken const object1 = {}; object1.stackoverflow = 51; console.log(object1.hasOwnProperty('stackoverflow')); // output: true
• ken: I know how to do it, I was just leaving a comment as to why I downvoted your answer, and so that anyone still learning would realize why your answer is wrong. You should remove your answer because it is answering a different question than the one that was asked.
• Anupam Maurya: cool @ken got your point i have update here, you can check now! thankyou :)

Answer 25

JS Double Exclamation !! sign may help in this case.

const cars = {
 petrol:{
 price: 5000
 },
 gas:{
 price:8000
 }
 }

Suppose we have the object above and If you try to log car with petrol price.

=> console.log(cars.petrol.price);
=> 5000

You'll definitely get 5000 out of it. But what if you try to get an electric car which does not exist then you'll get undefine

=> console.log(cars.electric);
=> undefine

But using !! which is its short way to cast a variable to be a Boolean (true or false) value.

=> console.log(!!cars.electric);
=> false

Answer 26

In my case, I wanted to check an NLP metadata returned by LUIS which is an object. I wanted to check if a key which is a string "FinancialRiskIntent" exists as a key inside that metadata object.

1. I tried to target the nested object I needed to check -> data.meta.prediction.intents (for my own purposes only, yours could be any object)
2. I used below code to check if the key exists:

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

This is checking for a specific key which I was initially looking for.

Hope this bit helps someone.

Answer 27

These example can demonstrate the differences between defferent ways. Hope it will help you to pick the right one for your needs:

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

Answer 28

const rawObject = {};
rawObject.propertyKey = 'somethingValue';
console.log(rawObject.hasOwnProperty('somethingValue'));
// expected output: true

checking particular key present in given object, hasOwnProperty will works here.

Answer 29

If you have ESLint configured in your project follows ESLint rule no-prototype-builtins. The reason why has been described in the following link:

// bad
console.log(object.hasOwnProperty(key));
// good
console.log(Object.prototype.hasOwnProperty.call(object, key));
// best
const has = Object.prototype.hasOwnProperty; // cache the lookup once, in module scope.
console.log(has.call(object, key));
/* or */
import has from 'has'; // https://www.npmjs.com/package/has
console.log(has(object, key));

Answer 30

const person = {
 id: 1,
 name: 'askavy',
 age: 23
}
**Method 1**
console.log(person.hasOwnProperty('name'))
**Method 2**
console.log('name' in person) 
**Method 3**
const checkKey = (obj , keyNmae) => {
 return Object.keys(obj).some((key) => {
 return key === keyNmae
 })
}
console.log(checkKey(person , 'name'))