[javascript] Test for existence of nested JavaScript object key

If I have a reference to an object:

var test = {};

that will potentially (but not immediately) have nested objects, something like:

{level1: {level2: {level3: "level3"}}};

What is the best way to check for the existence of property in deeply nested objects?

alert(test.level1); yields undefined, but alert(test.level1.level2.level3); fails.

I’m currently doing something like this:

if(test.level1 && test.level1.level2 && test.level1.level2.level3) {
    alert(test.level1.level2.level3);
}

but I was wondering if there’s a better way.

I am using a function in the following fashion.

var a = {};
a.b = {};
a.b.c = {};
a.b.c.d = "abcdabcd";

function isDefined(objectChainString) {
    try {
        var properties = objectChainString.split('.');
        var currentLevel = properties[0];
        if (currentLevel in window) {
            var consolidatedLevel = window[currentLevel];
            for (var i in properties) {
                if (i == 0) {
                    continue;
                } else {
                    consolidatedLevel = consolidatedLevel[properties[i]];
                }
            }
            if (typeof consolidatedLevel != 'undefined') {
                return true;
            } else {
                return false;
            }
        } else {
            return false;
        }
    } catch (e) {
        return false;
    }
}

// defined
console.log(checkUndefined("a.b.x.d"));
//undefined
console.log(checkUndefined("a.b.c.x"));
console.log(checkUndefined("a.b.x.d"));
console.log(checkUndefined("x.b.c.d"));

I think the following script gives more readable representation.

declare a function:

var o = function(obj) { return obj || {};};

then use it like this:

if (o(o(o(o(test).level1).level2).level3)
{

}

I call it "sad clown technique" because it is using sign o(

EDIT:

here is a version for TypeScript

it gives type checks at compile time (as well as the intellisense if you use a tool like Visual Studio)

export function o<T>(someObject: T, defaultValue: T = {} as T) : T {
    if (typeof someObject === 'undefined' || someObject === null)
        return defaultValue;
    else
        return someObject;
}

the usage is the same:

o(o(o(o(test).level1).level2).level3

but this time intellisense works!

plus, you can set a default value:

o(o(o(o(o(test).level1).level2).level3, "none")

I know this question is old, but I wanted to offer an extension by adding this to all objects. I know people tend to frown on using the Object prototype for extended object functionality, but I don't find anything easier than doing this. Plus, it's now allowed for with the Object.defineProperty method.

Object.defineProperty( Object.prototype, "has", { value: function( needle ) {
    var obj = this;
    var needles = needle.split( "." );
    for( var i = 0; i<needles.length; i++ ) {
        if( !obj.hasOwnProperty(needles[i])) {
            return false;
        }
        obj = obj[needles[i]];
    }
    return true;
}});

Now, in order to test for any property in any object you can simply do:

if( obj.has("some.deep.nested.object.somewhere") )

Here's a jsfiddle to test it out, and in particular it includes some jQuery that breaks if you modify the Object.prototype directly because of the property becoming enumerable. This should work fine with 3rd party libraries.

One simple way is this:

try {
    alert(test.level1.level2.level3);
} catch(e) {
    alert("undefined");    // this is optional to put any output here
}

The try/catch catches the cases for when any of the higher level objects such as test, test.level1, test.level1.level2 are not defined.

Another ES5 solution:

function hasProperties(object, properties) {
    return !properties.some(function(property){
        if (!object.hasOwnProperty(property)) {
            return true;
        }
        object = object[property];
        return false;
    });
}

Another way to work this out is for example, having the following object :

var x = {
    a: {
        b: 3
    }
};

then, what I did was add the following function to this object :

x.getKey = function(k){
        var r ;
        try {
            r = eval('typeof this.'+k+' !== "undefined"');
        }catch(e){
            r = false;
        }
        if(r !== false){
            return eval('this.'+k);
        }else{
            console.error('Missing key: \''+k+'\'');
            return '';
        }
    };

then you can test :

x.getKey('a.b');

If it's undefined the function returns "" (empty string) else it returns the existing value.

Please also consider this other more complex solution checking the link : JS object has property deep check

Object.prototype.hasOwnNestedProperty = function(propertyPath){
    if(!propertyPath)
        return false;

    var properties = propertyPath.split('.');
    var obj = this;

    for (var i = 0; i < properties.length; i++) {
        var prop = properties[i];

        if(!obj || !obj.hasOwnProperty(prop)){
            return false;
        } else {
            obj = obj[prop];
        }
    }

    return true;
};

// Usage: 
var obj = {
   innerObject:{
       deepObject:{
           value:'Here am I'
       }
   }
}

obj.hasOwnNestedProperty('innerObject.deepObject.value');

P.S.: There is also a recursive version.

create a global function and use in whole project

try this

function isExist(arg){_x000D_
   try{_x000D_
      return arg();_x000D_
   }catch(e){_x000D_
      return false;_x000D_
   }_x000D_
}_x000D_
_x000D_
let obj={a:5,b:{c:5}};_x000D_
_x000D_
console.log(isExist(()=>obj.b.c))_x000D_
console.log(isExist(()=>obj.b.foo))_x000D_
console.log(isExist(()=>obj.test.foo))

if condition

if(isExist(()=>obj.test.foo)){
   ....
}

I was looking for the value to be returned if the property exists, so I modified the answer by CMS above. Here's what I came up with:

function getNestedProperty(obj, key) {_x000D_
  // Get property array from key string_x000D_
  var properties = key.split(".");_x000D_
_x000D_
  // Iterate through properties, returning undefined if object is null or property doesn't exist_x000D_
  for (var i = 0; i < properties.length; i++) {_x000D_
    if (!obj || !obj.hasOwnProperty(properties[i])) {_x000D_
      return;_x000D_
    }_x000D_
    obj = obj[properties[i]];_x000D_
  }_x000D_
_x000D_
  // Nested property found, so return the value_x000D_
  return obj;_x000D_
}_x000D_
_x000D_
_x000D_
Usage:_x000D_
_x000D_
getNestedProperty(test, "level1.level2.level3") // "level3"_x000D_
getNestedProperty(test, "level1.level2.foo") // undefined

I automated the process

if(isset(object,["prop1","prop2"])){
// YES!

}

function isset(object, props){
    var dump;
    try {
        for(var x in props){
            if(x == 0) {
                dump = object[props[x]];
                return;
            }
            dump = dump[props[x]];
        }
    } catch(e) {
        return false;
    }

    return true;
}

There's a little pattern for this, but can get overwhelming at some times. I suggest you use it for two or three nested at a time.

if (!(foo.bar || {}).weep) return;
// Return if there isn't a 'foo.bar' or 'foo.bar.weep'.

As I maybe forgot to mention, you could also extend this further. Below example shows a check for nested foo.bar.weep.woop or it would return if none are available.

if (!((foo.bar || {}).weep || {}).woop) return;
// So, return if there isn't a 'foo.bar', 'foo.bar.weep', or 'foo.bar.weep.woop'.
// More than this would be overwhelming.

Yet another version:

function nestedPropertyExists(obj, props) {
    var prop = props.shift();
    return prop === undefined
        ? true
        : obj.hasOwnProperty(prop) ? nestedPropertyExists(obj[prop], props) : false;
}

nestedPropertyExists({a:{b:{c:1}}}, ['a','b','c']); // returns true
nestedPropertyExists({a:{b:{c:1}}}, ['a','b','c','d']); // returns false

Quite a lot of answers but still: why not simpler?

An es5 version of getting the value would be:

function value(obj, keys) {
    if (obj === undefined) return obj;
    if (keys.length === 1 && obj.hasOwnProperty(keys[0])) return obj[keys[0]];
    return value(obj[keys.shift()], keys);
}

if (value(test, ['level1', 'level2', 'level3'])) {
  // do something
}

you could also use it with value(config, ['applet', i, 'height']) || 42

Credits to CMS for his ES6 solution that gave me this idea.

Now we can also use reduce to loop through nested keys:

// @params o<object>_x000D_
// @params path<string> expects 'obj.prop1.prop2.prop3'_x000D_
// returns: obj[path] value or 'false' if prop doesn't exist_x000D_
_x000D_
const objPropIfExists = o => path => {_x000D_
  const levels = path.split('.');_x000D_
  const res = (levels.length > 0) _x000D_
    ? levels.reduce((a, c) => a[c] || 0, o)_x000D_
    : o[path];_x000D_
  return (!!res) ? res : false_x000D_
}_x000D_
_x000D_
const obj = {_x000D_
  name: 'Name',_x000D_
  sys: { country: 'AU' },_x000D_
  main: { temp: '34', temp_min: '13' },_x000D_
  visibility: '35%'_x000D_
}_x000D_
_x000D_
const exists = objPropIfExists(obj)('main.temp')_x000D_
const doesntExist = objPropIfExists(obj)('main.temp.foo.bar.baz')_x000D_
_x000D_
console.log(exists, doesntExist)

var a;

a = {
    b: {
        c: 'd'
    }
};

function isset (fn) {
    var value;
    try {
        value = fn();
    } catch (e) {
        value = undefined;
    } finally {
        return value !== undefined;
    }
};

// ES5
console.log(
    isset(function () { return a.b.c; }),
    isset(function () { return a.b.c.d.e.f; })
);

If you are coding in ES6 environment (or using 6to5) then you can take advantage of the arrow function syntax:

// ES6 using the arrow function
console.log(
    isset(() => a.b.c),
    isset(() => a.b.c.d.e.f)
);

Regarding the performance, there is no performance penalty for using try..catch block if the property is set. There is a performance impact if the property is unset.

Consider simply using _.has:

var object = { 'a': { 'b': { 'c': 3 } } };

_.has(object, 'a');
// ? true

_.has(object, 'a.b.c');
// ? true

_.has(object, ['a', 'b', 'c']);
// ? true

function isIn(string, object){
    var arr = string.split(".");
    var notFound = true;
    var length = arr.length;
    for (var i = 0; i < length; i++){
        var key = arr[i];
        if (!object.hasOwnProperty(key)){
            notFound = false;
            break;
        }
        if ((i + length) <= length){
            object = object[key];
        }
    }
    return notFound;
}
var musicCollection = {
    hasslehoff: {
        greatestHits : true
    }
};
console.log(isIn("hasslehoff.greatestHits", musicCollection));
console.log(isIn("hasslehoff.worseHits", musicCollection));

here my String based delimiter version.

I think this is a slight improvement (becomes a 1-liner):

   alert( test.level1 && test.level1.level2 && test.level1.level2.level3 )

This works because the && operator returns the final operand it evaluated (and it short-circuits).

Based on a previous comment, here is another version where the main object could not be defined either:

// Supposing that our property is at first.second.third.property:
var property = (((typeof first !== 'undefined' ? first : {}).second || {}).third || {}).property;

Here is a pattern I picked up from Oliver Steele:

var level3 = (((test || {}).level1 || {}).level2 || {}).level3;
alert( level3 );

In fact that whole article is a discussion of how you can do this in javascript. He settles on using the above syntax (which isn't that hard to read once you get used to it) as an idiom.

I wrote my own function that takes the desired path, and has a good and bad callback function.

function checkForPathInObject(object, path, callbackGood, callbackBad){
    var pathParts = path.split(".");
    var currentObjectPath = object;

    // Test every step to see if it exists in object
    for(var i=0; i<(pathParts.length); i++){
        var currentPathPart = pathParts[i];
        if(!currentObjectPath.hasOwnProperty(pathParts[i])){
            if(callbackBad){
                callbackBad();
            }
            return false;
        } else {
            currentObjectPath = currentObjectPath[pathParts[i]];
        }
    }

    // call full path in callback
    callbackGood();
}

Usage:

var testObject = {
    level1:{
        level2:{
            level3:{
            }
        }
    }
};


checkForPathInObject(testObject, "level1.level2.level3", function(){alert("good!")}, function(){alert("bad!")}); // good

checkForPathInObject(testObject, "level1.level2.level3.levelNotThere", function(){alert("good!")}, function(){alert("bad!")}); //bad

I have used this function for access properties of the deeply nested object and it working for me...

this is the function

/**
 * get property of object
 * @param obj object
 * @param path e.g user.name
 */
getProperty(obj, path, defaultValue = '-') {
  const value = path.split('.').reduce((o, p) => o && o[p], obj);

  return value ? value : defaultValue;
}

this is how I access the deeply nested object property

{{ getProperty(object, 'passengerDetails.data.driverInfo.currentVehicle.vehicleType') }}

Update

Looks like lodash has added _.get for all your nested property getting needs.

_.get(countries, 'greece.sparta.playwright')

https://lodash.com/docs#get

Previous answer

lodash users may enjoy lodash.contrib which has a couple methods that mitigate this problem.

getPath

Signature: _.getPath(obj:Object, ks:String|Array)

Gets the value at any depth in a nested object based on the path described by the keys given. Keys may be given as an array or as a dot-separated string. Returns undefined if the path cannot be reached.

var countries = {
        greece: {
            athens: {
                playwright:  "Sophocles"
            }
        }
    }
};

_.getPath(countries, "greece.athens.playwright");
// => "Sophocles"

_.getPath(countries, "greece.sparta.playwright");
// => undefined

_.getPath(countries, ["greece", "athens", "playwright"]);
// => "Sophocles"

_.getPath(countries, ["greece", "sparta", "playwright"]);
// => undefined

I have created a little function to get nested object properties safely.

function getValue(object, path, fallback, fallbackOnFalsy) {
    if (!object || !path) {
        return fallback;
    }

    // Reduces object properties to the deepest property in the path argument.
    return path.split('.').reduce((object, property) => {
       if (object && typeof object !== 'string' && object.hasOwnProperty(property)) {
            // The property is found but it may be falsy.
            // If fallback is active for falsy values, the fallback is returned, otherwise the property value.
            return !object[property] && fallbackOnFalsy ? fallback : object[property];
        } else {
            // Returns the fallback if current chain link does not exist or it does not contain the property.
            return fallback;
        }
    }, object);
}

Or a simpler but slightly unreadable version:

function getValue(o, path, fb, fbFalsy) {
   if(!o || !path) return fb;
   return path.split('.').reduce((o, p) => o && typeof o !== 'string' && o.hasOwnProperty(p) ? !o[p] && fbFalsy ? fb : o[p] : fb, o);
}

Or even shorter but without fallback on falsy flag:

function getValue(o, path, fb) {
   if(!o || !path) return fb;
   return path.split('.').reduce((o, p) => o && typeof o !== 'string' && o.hasOwnProperty(p) ? o[p] : fb, o);
}

I have test with:

const obj = {
    c: {
        a: 2,
        b: {
            c: [1, 2, 3, {a: 15, b: 10}, 15]
        },
        c: undefined,
        d: null
    },
    d: ''
}

And here are some tests:

// null
console.log(getValue(obj, 'c.d', 'fallback'));

// array
console.log(getValue(obj, 'c.b.c', 'fallback'));

// array index 2
console.log(getValue(obj, 'c.b.c.2', 'fallback'));

// no index => fallback
console.log(getValue(obj, 'c.b.c.10', 'fallback'));

To see all the code with documentation and the tests I've tried you can check my github gist: https://gist.github.com/vsambor/3df9ad75ff3de489bbcb7b8c60beebf4#file-javascriptgetnestedvalues-js

Based on this answer, I came up with this generic function using ES2015 which would solve the problem

function validChain( object, ...keys ) {
    return keys.reduce( ( a, b ) => ( a || { } )[ b ], object ) !== undefined;
}

var test = {
  first: {
    second: {
        third: "This is not the key your are looking for"
    }
  }
}

if ( validChain( test, "first", "second", "third" ) ) {
    console.log( test.first.second.third );
}

//Just in case is not supported or not included by your framework
//***************************************************
Array.prototype.some = function(fn, thisObj) {
  var scope = thisObj || window;
  for ( var i=0, j=this.length; i < j; ++i ) {
    if ( fn.call(scope, this[i], i, this) ) {
      return true;
    }
  }
  return false;
};
//****************************************************

function isSet (object, string) {
  if (!object) return false;
  var childs = string.split('.');
  if (childs.length > 0 ) {
    return !childs.some(function (item) {
      if (item in object) {
        object = object[item]; 
        return false;
      } else return true;
    });
  } else if (string in object) { 
    return true;
  } else return false;
}

var object = {
  data: {
    item: {
      sub_item: {
        bla: {
          here : {
            iam: true
          }
        }
      }
    }
  }
};

console.log(isSet(object,'data.item')); // true
console.log(isSet(object,'x')); // false
console.log(isSet(object,'data.sub_item')); // false
console.log(isSet(object,'data.item')); // true
console.log(isSet(object,'data.item.sub_item.bla.here.iam')); // true

you can path object and path seprated with "."

function checkPathExist(obj, path) {_x000D_
  var pathArray =path.split(".")_x000D_
  for (var i of pathArray) {_x000D_
    if (Reflect.get(obj, i)) {_x000D_
      obj = obj[i];_x000D_
  _x000D_
    }else{_x000D_
  return false;_x000D_
    }_x000D_
  }_x000D_
 return true;_x000D_
}_x000D_
_x000D_
var test = {level1:{level2:{level3:'level3'}} };_x000D_
_x000D_
console.log('level1.level2.level3 => ',checkPathExist(test, 'level1.level2.level3')); // true_x000D_
console.log( 'level1.level2.foo => ',checkPathExist(test, 'level1.level2.foo')); // false

In typeScript you can do something like this:

 if (object.prop1 && object.prop1.prop2 && object.prop1.prop2.prop3) {
    const items = object.prop1.prop2.prop3
    console.log(items);
 }

I thought I'd add another one that I came up with today. The reason I am proud of this solution is that it avoids nested brackets that are used in many solutions such as Object Wrap (by Oliver Steele):

(in this example I use an underscore as a placeholder variable, but any variable name will work)

//the 'test' object_x000D_
var test = {level1: {level2: {level3: 'level3'}}};_x000D_
_x000D_
let _ = test;_x000D_
_x000D_
if ((_=_.level1) && (_=_.level2) && (_=_.level3)) {_x000D_
_x000D_
  let level3 = _;_x000D_
  //do stuff with level3_x000D_
_x000D_
}

//you could also use 'stacked' if statements. This helps if your object goes very deep. _x000D_
//(formatted without nesting or curly braces except the last one)_x000D_
_x000D_
let _ = test;_x000D_
_x000D_
if (_=_.level1)_x000D_
if (_=_.level2)_x000D_
if (_=_.level3) {_x000D_
_x000D_
   let level3 = _;_x000D_
   //do stuff with level3_x000D_
}_x000D_
_x000D_
_x000D_
//or you can indent:_x000D_
if (_=_.level1)_x000D_
  if (_=_.level2)_x000D_
    if (_=_.level3) {_x000D_
_x000D_
      let level3 = _;_x000D_
      //do stuff with level3_x000D_
}

You can do this by using the recursive function. This will work even if you don't know all nested Object keys name.

function FetchKeys(obj) {
    let objKeys = [];
    let keyValues = Object.entries(obj);
    for (let i in keyValues) {
        objKeys.push(keyValues[i][0]);
        if (typeof keyValues[i][1] == "object") {
            var keys = FetchKeys(keyValues[i][1])
            objKeys = objKeys.concat(keys);
        }
    }
    return objKeys;
}

let test = { level1: { level2: { level3: "level3" } } };
let keyToCheck = "level2";
let keys = FetchKeys(test); //Will return an array of Keys

if (keys.indexOf(keyToCheck) != -1) {
    //Key Exists logic;
}
else {
    //Key Not Found logic;
}

You can also use tc39 optional chaining proposal together with babel 7 - tc39-proposal-optional-chaining

Code would look like this:

  const test = test?.level1?.level2?.level3;
  if (test) alert(test);

This works with all objects and arrays :)

ex:

if( obj._has( "something.['deep']['under'][1][0].item" ) ) {
    //do something
}

this is my improved version of Brian's answer

I used _has as the property name because it can conflict with existing has property (ex: maps)

Object.defineProperty( Object.prototype, "_has", { value: function( needle ) {
var obj = this;
var needles = needle.split( "." );
var needles_full=[];
var needles_square;
for( var i = 0; i<needles.length; i++ ) {
    needles_square = needles[i].split( "[" );
    if(needles_square.length>1){
        for( var j = 0; j<needles_square.length; j++ ) {
            if(needles_square[j].length){
                needles_full.push(needles_square[j]);
            }
        }
    }else{
        needles_full.push(needles[i]);
    }
}
for( var i = 0; i<needles_full.length; i++ ) {
    var res = needles_full[i].match(/^((\d+)|"(.+)"|'(.+)')\]$/);
    if (res != null) {
        for (var j = 0; j < res.length; j++) {
            if (res[j] != undefined) {
                needles_full[i] = res[j];
            }
        }
    }

    if( typeof obj[needles_full[i]]=='undefined') {
        return false;
    }
    obj = obj[needles_full[i]];
}
return true;
}});

Here's the fiddle

You can read an object property at any depth, if you handle the name like a string: 't.level1.level2.level3'.

window.t={level1:{level2:{level3: 'level3'}}};

function deeptest(s){
    s= s.split('.')
    var obj= window[s.shift()];
    while(obj && s.length) obj= obj[s.shift()];
    return obj;
}

alert(deeptest('t.level1.level2.level3') || 'Undefined');

It returns undefined if any of the segments is undefined.

My solution that I use since long time (using string unfortunaly, couldn't find better)

function get_if_exist(str){
    try{return eval(str)}
    catch(e){return undefined}
}

// way to use
if(get_if_exist('test.level1.level2.level3')) {
    alert(test.level1.level2.level3);
}

// or simply 
alert(get_if_exist('test.level1.level2.level3'));

edit: this work only if object "test" have global scope/range. else you have to do something like :

// i think it's the most beautiful code I have ever write :p
function get_if_exist(obj){
    return arguments.length==1 || (obj[arguments[1]] && get_if_exist.apply(this,[obj[arguments[1]]].concat([].slice.call(arguments,2))));
}

alert(get_if_exist(test,'level1','level2','level3'));

edit final version to allow 2 method of call :

function get_if_exist(obj){
    var a=arguments, b=a.callee; // replace a.callee by the function name you choose because callee is depreceate, in this case : get_if_exist
    // version 1 calling the version 2
    if(a[1] && ~a[1].indexOf('.')) 
        return b.apply(this,[obj].concat(a[1].split('.')));
    // version 2
    return a.length==1 ? a[0] : (obj[a[1]] && b.apply(this,[obj[a[1]]].concat([].slice.call(a,2))));
}

// method 1
get_if_exist(test,'level1.level2.level3');


// method 2
get_if_exist(test,'level1','level2','level3');

I didn't see any example of someone using Proxies

So I came up with my own. The great thing about it is that you don't have to interpolate strings. You can actually return a chain-able object function and do some magical things with it. You can even call functions and get array indexes to check for deep objects

function resolve(target) {_x000D_
  var noop = () => {} // We us a noop function so we can call methods also_x000D_
  return new Proxy(noop, {_x000D_
    get(noop, key) {_x000D_
      // return end result if key is _result_x000D_
      return key === '_result' _x000D_
        ? target _x000D_
        : resolve( // resolve with target value or undefined_x000D_
            target === undefined ? undefined : target[key]_x000D_
          )_x000D_
    },_x000D_
_x000D_
    // if we want to test a function then we can do so alos thanks to using noop_x000D_
    // instead of using target in our proxy_x000D_
    apply(noop, that, args) {_x000D_
      return resolve(typeof target === 'function' ? target.apply(that, args) : undefined)_x000D_
    },_x000D_
  })_x000D_
}_x000D_
_x000D_
// some modified examples from the accepted answer_x000D_
var test = {level1: {level2:() => ({level3:'level3'})}}_x000D_
var test1 = {key1: {key2: ['item0']}}_x000D_
_x000D_
// You need to get _result in the end to get the final result_x000D_
_x000D_
console.log(resolve(test).level1.level2().level3._result)_x000D_
console.log(resolve(test).level1.level2().level3.level4.level5._result)_x000D_
console.log(resolve(test1).key1.key2[0]._result)_x000D_
console.log(resolve(test1)[0].key._result) // don't exist

The above code works fine for synchronous stuff. But how would you test something that is asynchronous like this ajax call? How do you test that? what if the response isn't json when it returns a 500 http error?

window.fetch('https://httpbin.org/get')
.then(function(response) {
  return response.json()
})
.then(function(json) {
  console.log(json.headers['User-Agent'])
})

sure you could use async/await to get rid of some callbacks. But what if you could do it even more magically? something that looks like this:

fetch('https://httpbin.org/get').json().headers['User-Agent']

You probably wonder where all the promise & .then chains are... this could be blocking for all that you know... but using the same Proxy technique with promise you can actually test deeply nested complex path for it existence without ever writing a single function

function resolve(target) { _x000D_
  return new Proxy(() => {}, {_x000D_
    get(noop, key) {_x000D_
      return key === 'then' ? target.then.bind(target) : resolve(_x000D_
        Promise.resolve(target).then(target => {_x000D_
          if (typeof target[key] === 'function') return target[key].bind(target)_x000D_
          return target[key]_x000D_
        })_x000D_
      )_x000D_
    },_x000D_
_x000D_
    apply(noop, that, args) {_x000D_
      return resolve(target.then(result => {_x000D_
        return result.apply(that, args)_x000D_
      }))_x000D_
    },_x000D_
  })_x000D_
}_x000D_
_x000D_
// this feels very much synchronous but are still non blocking :)_x000D_
resolve(window) // this will chain a noop function until you call then()_x000D_
  .fetch('https://httpbin.org/get')_x000D_
  .json()_x000D_
  .headers['User-Agent']_x000D_
  .then(console.log, console.warn) // you get a warning if it doesn't exist_x000D_
  _x000D_
// You could use this method also for the first test object_x000D_
// also, but it would have to call .then() in the end_x000D_
_x000D_
_x000D_
_x000D_
// Another example_x000D_
resolve(window)_x000D_
  .fetch('https://httpbin.org/get?items=4&items=2')_x000D_
  .json()_x000D_
  .args_x000D_
  .items_x000D_
  // nice that you can map an array item without even having it ready_x000D_
  .map(n => ~~n * 4) _x000D_
  .then(console.log, console.warn) // you get a warning if it doesn't exist

function propsExists(arg) {
  try {
    const result = arg()
  
    if (typeof result !== 'undefined') {
      return true
    }

    return false
  } catch (e) {
    return false;
  }
}

This function will also test for 0, null. If they are present it will also return true.

Example:

function propsExists(arg) {
  try {
    const result = arg()
  
    if (typeof result !== 'undefined') {
      return true
    }

    return false
  } catch (e) {
    return false;
  }
}

let obj = {
  test: {
    a: null,
    b: 0,
    c: undefined,
    d: 4,
    e: 'Hey',
    f: () => {},
    g: 5.4,
    h: false,
    i: true,
    j: {},
    k: [],
    l: {
        a: 1,
    }
  }
};


console.log('obj.test.a', propsExists(() => obj.test.a))
console.log('obj.test.b', propsExists(() => obj.test.b))
console.log('obj.test.c', propsExists(() => obj.test.c))
console.log('obj.test.d', propsExists(() => obj.test.d))
console.log('obj.test.e', propsExists(() => obj.test.e))
console.log('obj.test.f', propsExists(() => obj.test.f))
console.log('obj.test.g', propsExists(() => obj.test.g))
console.log('obj.test.h', propsExists(() => obj.test.h))
console.log('obj.test.i', propsExists(() => obj.test.i))
console.log('obj.test.j', propsExists(() => obj.test.j))
console.log('obj.test.k', propsExists(() => obj.test.k))
console.log('obj.test.l', propsExists(() => obj.test.l))

getValue (o, key1, key2, key3, key4, key5) {
    try {
      return o[key1][key2][key3][key4][key5]
    } catch (e) {
      return null
    }
}

how about

try {
   alert(test.level1.level2.level3)
} catch(e) {
 ...whatever

}

Here's my take on it - most of these solutions ignore the case of a nested array as in:

    obj = {
        "l1":"something",
        "l2":[{k:0},{k:1}],
        "l3":{
            "subL":"hello"
        }
    }

I may want to check for obj.l2[0].k

With the function below, you can do deeptest('l2[0].k',obj)

The function will return true if the object exists, false otherwise

function deeptest(keyPath, testObj) {_x000D_
    var obj;_x000D_
_x000D_
    keyPath = keyPath.split('.')_x000D_
    var cKey = keyPath.shift();_x000D_
_x000D_
    function get(pObj, pKey) {_x000D_
        var bracketStart, bracketEnd, o;_x000D_
_x000D_
        bracketStart = pKey.indexOf("[");_x000D_
        if (bracketStart > -1) { //check for nested arrays_x000D_
            bracketEnd = pKey.indexOf("]");_x000D_
            var arrIndex = pKey.substr(bracketStart + 1, bracketEnd - bracketStart - 1);_x000D_
            pKey = pKey.substr(0, bracketStart);_x000D_
   var n = pObj[pKey];_x000D_
            o = n? n[arrIndex] : undefined;_x000D_
_x000D_
        } else {_x000D_
            o = pObj[pKey];_x000D_
        }_x000D_
        return o;_x000D_
    }_x000D_
_x000D_
    obj = get(testObj, cKey);_x000D_
    while (obj && keyPath.length) {_x000D_
        obj = get(obj, keyPath.shift());_x000D_
    }_x000D_
    return typeof(obj) !== 'undefined';_x000D_
}_x000D_
_x000D_
var obj = {_x000D_
    "l1":"level1",_x000D_
    "arr1":[_x000D_
        {"k":0},_x000D_
        {"k":1},_x000D_
        {"k":2}_x000D_
    ],_x000D_
    "sub": {_x000D_
        "a":"letter A",_x000D_
        "b":"letter B"_x000D_
    }_x000D_
};_x000D_
console.log("l1: " + deeptest("l1",obj));_x000D_
console.log("arr1[0]: " + deeptest("arr1[0]",obj));_x000D_
console.log("arr1[1].k: " + deeptest("arr1[1].k",obj));_x000D_
console.log("arr1[1].j: " + deeptest("arr1[1].j",obj));_x000D_
console.log("arr1[3]: " + deeptest("arr1[3]",obj));_x000D_
console.log("arr2: " + deeptest("arr2",obj));

Based on @Stephane LaFlèche's answer, I came up with my alternative version of the script.

Demo on JSFiddle

var obj = {"a":{"b":{"c":"Hello World"}},"resTest":"potato","success":"This path exists"};
checkForPathInObject = function(object,path,value) {
        var pathParts   = path.split("."),
            result      = false;
        // Check if required parameters are set; if not, return false
        if(!object || typeof object == 'undefined' || !path || typeof path != 'string')
            return false;
        /* Loop through object keys to find a way to the path or check for value
         * If the property does not exist, set result to false
         * If the property is an object, update @object
         * Otherwise, update result */
        for(var i=0;i<pathParts.length;i++){
            var currentPathPart = pathParts[i];
            if(!object.hasOwnProperty( currentPathPart )) {
                result = false;
            } else if (object[ currentPathPart ] && path == pathParts[i]) {
                result = pathParts[i];
                break;
            } else if(typeof object[ currentPathPart ] == 'object') {
                object = object[ currentPathPart ];
            } else {
                result = object[ currentPathPart ];
            }
        }
        /* */
        if(typeof value != 'undefined' && value == result)
            return true;
        return result;
};
// Uncomment the lines below to test the script
// alert( checkForPathInObject(obj,'a.b.c') ); // Results "Hello World"
// alert( checkForPathInObject(obj,'a.success') ); // Returns false
// alert( checkForPathInObject(obj,'resTest', 'potato') ); // Returns true

Another option (close to this answer) :

function resolve(root, path){
    try {
        return (new Function(
            'root', 'return root.' + path + ';'
        ))(root);
    } catch (e) {}
}

var tree = { level1: [{ key: 'value' }] };
resolve(tree, 'level1[0].key'); // "value"
resolve(tree, 'level1[1].key'); // undefined

More on this : https://stackoverflow.com/a/18381564/1636522

I was having the same issue and and wanted to see if I could come up with a my own solution. This accepts the path you want to check as a string.

function checkPathForTruthy(obj, path) {
  if (/\[[a-zA-Z_]/.test(path)) {
    console.log("Cannot resolve variables in property accessors");
    return false;
  }

  path = path.replace(/\[/g, ".");
  path = path.replace(/]|'|"/g, "");
  path = path.split(".");

  var steps = 0;
  var lastRef = obj;
  var exists = path.every(key => {
    var currentItem = lastRef[path[steps]];
    if (currentItem) {
      lastRef = currentItem;
      steps++;
      return true;
    } else {
      return false;
    }
  });

  return exists;
}

Here is a snippet with some logging and test cases:

console.clear();_x000D_
var testCases = [_x000D_
  ["data.Messages[0].Code", true],_x000D_
  ["data.Messages[1].Code", true],_x000D_
  ["data.Messages[0]['Code']", true],_x000D_
  ['data.Messages[0]["Code"]', true],_x000D_
  ["data[Messages][0]['Code']", false],_x000D_
  ["data['Messages'][0]['Code']", true]_x000D_
];_x000D_
var path = "data.Messages[0].Code";_x000D_
var obj = {_x000D_
  data: {_x000D_
    Messages: [{_x000D_
      Code: "0"_x000D_
    }, {_x000D_
      Code: "1"_x000D_
    }]_x000D_
  }_x000D_
}_x000D_
_x000D_
function checkPathForTruthy(obj, path) {_x000D_
  if (/\[[a-zA-Z_]/.test(path)) {_x000D_
    console.log("Cannot resolve variables in property accessors");_x000D_
    return false;_x000D_
  }_x000D_
_x000D_
  path = path.replace(/\[/g, ".");_x000D_
  path = path.replace(/]|'|"/g, "");_x000D_
  path = path.split(".");_x000D_
_x000D_
  var steps = 0;_x000D_
  var lastRef = obj;_x000D_
  var logOutput = [];_x000D_
  var exists = path.every(key => {_x000D_
    var currentItem = lastRef[path[steps]];_x000D_
    if (currentItem) {_x000D_
      logOutput.push(currentItem);_x000D_
      lastRef = currentItem;_x000D_
      steps++;_x000D_
      return true;_x000D_
    } else {_x000D_
      return false;_x000D_
    }_x000D_
  });_x000D_
  console.log(exists, logOutput);_x000D_
  return exists;_x000D_
}_x000D_
_x000D_
testCases.forEach(testCase => {_x000D_
  if (checkPathForTruthy(obj, testCase[0]) === testCase[1]) {_x000D_
    console.log("Passed: " + testCase[0]);_x000D_
  } else {_x000D_
    console.log("Failed: " + testCase[0] + " expected " + testCase[1]);_x000D_
  }_x000D_
});

Following options were elaborated starting from this answer. Same tree for both :

var o = { a: { b: { c: 1 } } };

Stop searching when undefined

var u = undefined;
o.a ? o.a.b ? o.a.b.c : u : u // 1
o.x ? o.x.y ? o.x.y.z : u : u // undefined
(o = o.a) ? (o = o.b) ? o.c : u : u // 1

Ensure each level one by one

var $ = function (empty) {
    return function (node) {
        return node || empty;
    };
}({});

$($(o.a).b).c // 1
$($(o.x).y).z // undefined

Well there are no really good answer for one-liners to use in html templates, so i made one using ES6 Proxies. You just pass an object or value to the "traverse" function and do as much nested calls as you want closing them with function call which will return value or fallback value. Using:

const testObject = { _x000D_
  deep: { _x000D_
    nested: { _x000D_
      obj: { _x000D_
        closure: () => { return "closure" },_x000D_
        number: 9,_x000D_
        boolean: true,_x000D_
        array: [1, 2, { foo: { bar: true } }]_x000D_
      } _x000D_
    }_x000D_
  }_x000D_
}_x000D_
_x000D_
traverse(testObject).deep() _x000D_
// {nested: {…}}_x000D_
_x000D_
traverse(testObject).non.existent() _x000D_
// undefined_x000D_
_x000D_
traverse(testObject).deep.nested.obj.closure()() _x000D_
// closure_x000D_
_x000D_
traverse(testObject).deep.nested.obj.array[5]('fallback')_x000D_
// fallback_x000D_
_x000D_
traverse(testObject).deep.nested.obj.array[2]()_x000D_
// {foo: {…}}_x000D_
_x000D_
traverse(testObject).deep.nested.obj.array[2].foo.bar()_x000D_
// true_x000D_
_x000D_
traverse(testObject).deep.nested.obj.array[2].foo.bar[4]('fallback')_x000D_
// fallback_x000D_
_x000D_
traverse(testObject).completely.wrong[3].call().WILL_THROW()_x000D_
// Uncaught TypeError: Cannot read property 'WILL_THROW' of undefined

Function itself:

const traverse = (input) => {_x000D_
    // unique empty object_x000D_
    const unset = new Object();_x000D_
    // we need wrapper to ensure we have access to the same unique empty object_x000D_
    const closure = (input) => {_x000D_
        // wrap each input into this_x000D_
        const handler = new Function();_x000D_
        handler.input = input;    _x000D_
        // return wrappers proxy _x000D_
        return new Proxy(handler, {_x000D_
            // keep traversing_x000D_
            get: (target, name) => {_x000D_
                // if undefined supplied as initial input_x000D_
                if (!target.input) {_x000D_
                    return closure(unset);_x000D_
                }_x000D_
                // otherwise_x000D_
                if (target.input[name] !== undefined) {_x000D_
                    // input has that property_x000D_
                    return closure(target.input[name]);_x000D_
                } else {_x000D_
                    return closure(unset);_x000D_
                }_x000D_
            },_x000D_
            // result with fallback_x000D_
            apply: (target, context, args) => {_x000D_
                return handler.input === unset ? _x000D_
                    args[0] : handler.input;_x000D_
            }_x000D_
        })_x000D_
    }_x000D_
    return closure(input);    _x000D_
}

I wrote a library called l33teral to help test for nested properties. You can use it like this:

var myObj = {/*...*/};
var hasNestedProperties = leet(myObj).probe('prop1.prop2.prop3');

I do like the ES5/6 solutions here, too.

CMS solution works great but usage/syntax can be more convenient. I suggest following

var checkNested = function(obj, structure) {

  var args = structure.split(".");

  for (var i = 0; i < args.length; i++) {
    if (!obj || !obj.hasOwnProperty(args[i])) {
      return false;
    }
    obj = obj[args[i]];
  }
  return true;
};

You can simply use object notation using dot instead of supplying multiple arguments

var test = {level1:{level2:{level3:'level3'}} };

checkNested(test, 'level1.level2.level3'); // true
checkNested(test, 'level1.level2.foo'); // false

Simply use https://www.npmjs.com/package/js-aid package for checking for the nested object.

If you happen to be using AngularJs you can use the $parse service to check if a deep object property exists, like this:

if( $parse('model.data.items')(vm) ) {
    vm.model.data.items.push('whatever');
}

to avoid statements like this:

if(vm.model && vm.model.data && vm.model.data.items) {
    ....
}

don't forget to inject the $parse service into your controller

for more info: https://glebbahmutov.com/blog/angularjs-parse-hacks/

I tried a recursive approach:

function objHasKeys(obj, keys) {
  var next = keys.shift();
  return obj[next] && (! keys.length || objHasKeys(obj[next], keys));
}

The ! keys.length || kicks out of the recursion so it doesn't run the function with no keys left to test. Tests:

obj = {
  path: {
    to: {
      the: {
        goodKey: "hello"
      }
    }
  }
}

console.log(objHasKeys(obj, ['path', 'to', 'the', 'goodKey'])); // true
console.log(objHasKeys(obj, ['path', 'to', 'the', 'badKey']));  // undefined

I am using it to print a friendly html view of a bunch of objects with unknown key/values, e.g.:

var biosName = objHasKeys(myObj, 'MachineInfo:BiosInfo:Name'.split(':'))
             ? myObj.MachineInfo.BiosInfo.Name
             : 'unknown';

And yet another one which is very compact:

function ifSet(object, path) {
  return path.split('.').reduce((obj, part) => obj && obj[part], object)
}

called:

let a = {b:{c:{d:{e:'found!'}}}}
ifSet(a, 'b.c.d.e') == 'found!'
ifSet(a, 'a.a.a.a.a.a') == undefined

It won't perform great since it's splitting a string (but increases readability of the call) and iterates over everything even if it's already obvious that nothing will be found (but increases readability of the function itself).

at least is faster than _.get http://jsben.ch/aAtmc

Slight edit to this answer to allow nested arrays in the path

var has = function (obj, key) {_x000D_
    return key.split(".").every(function (x) {_x000D_
        if (typeof obj != "object" || obj === null || !x in obj)_x000D_
            return false;_x000D_
        if (obj.constructor === Array) _x000D_
            obj = obj[0];_x000D_
        obj = obj[x];_x000D_
        return true;_x000D_
    });_x000D_
}

Check linked answer for usages :)

theres a function here on thecodeabode (safeRead) which will do this in a safe manner... i.e.

safeRead(test, 'level1', 'level2', 'level3');

if any property is null or undefined, an empty string is returned

The answer given by CMS works fine with the following modification for null checks as well

function checkNested(obj /*, level1, level2, ... levelN*/) 
      {
             var args = Array.prototype.slice.call(arguments),
             obj = args.shift();

            for (var i = 0; i < args.length; i++) 
            {
                if (obj == null || !obj.hasOwnProperty(args[i]) ) 
                {
                    return false;
                }
                obj = obj[args[i]];
            }
            return true;
    }

I have done performance tests (thank you cdMinix for adding lodash) on some of the suggestions proposed to this question with the results listed below.

Disclaimer #1 Turning strings into references is unnecessary meta-programming and probably best avoided. Don't lose track of your references to begin with. Read more from this answer to a similar question.

Disclaimer #2 We are talking about millions of operations per millisecond here. It is very unlikely any of these would make much difference in most use cases. Choose whichever makes the most sense knowing the limitations of each. For me I would go with something like reduce out of convenience.

Object Wrap (by Oliver Steele) – 34 % – fastest

var r1 = (((test || {}).level1 || {}).level2 || {}).level3;
var r2 = (((test || {}).level1 || {}).level2 || {}).foo;

Original solution (suggested in question) – 45%

var r1 = test.level1 && test.level1.level2 && test.level1.level2.level3;
var r2 = test.level1 && test.level1.level2 && test.level1.level2.foo;

checkNested – 50%

function checkNested(obj) {
  for (var i = 1; i < arguments.length; i++) {
    if (!obj.hasOwnProperty(arguments[i])) {
      return false;
    }
    obj = obj[arguments[i]];
  }
  return true;
}

get_if_exist – 52%

function get_if_exist(str) {
    try { return eval(str) }
    catch(e) { return undefined }
}

validChain – 54%

function validChain( object, ...keys ) {
    return keys.reduce( ( a, b ) => ( a || { } )[ b ], object ) !== undefined;
}

objHasKeys – 63%

function objHasKeys(obj, keys) {
  var next = keys.shift();
  return obj[next] && (! keys.length || objHasKeys(obj[next], keys));
}

nestedPropertyExists – 69%

function nestedPropertyExists(obj, props) {
    var prop = props.shift();
    return prop === undefined ? true : obj.hasOwnProperty(prop) ? nestedPropertyExists(obj[prop], props) : false;
}

_.get – 72%

deeptest – 86%

function deeptest(target, s){
    s= s.split('.')
    var obj= target[s.shift()];
    while(obj && s.length) obj= obj[s.shift()];
    return obj;
}

sad clowns – 100% – slowest

var o = function(obj) { return obj || {} };

var r1 = o(o(o(o(test).level1).level2).level3);
var r2 = o(o(o(o(test).level1).level2).foo);

/**
 * @method getValue
 * @description simplifies checking for existance and getting a deeply nested value within a ceratin context
 * @argument {string} s       string representation of the full path to the requested property 
 * @argument {object} context optional - the context to check defaults to window
 * @returns the value if valid and set, returns undefined if invalid / not available etc.
 */
var getValue = function( s, context ){
    var fn = function(){
        try{
            return eval(s);
        }catch(e){
            return undefined;
        }
    }
    return fn.call(context||window,s);
}

and usage :

if( getValue('a[0].b[0].b[0].d') == 2 ) // true

ES6 answer, thoroughly tested :)

const propExists = (obj, path) => {
    return !!path.split('.').reduce((obj, prop) => {
        return obj && obj[prop] ? obj[prop] : undefined;
    }, obj)
}

?see Codepen with full test coverage

Another way :

/**
 * This API will return particular object value from JSON Object hierarchy.
 *
 * @param jsonData : json type : JSON data from which we want to get particular object
 * @param objHierarchy : string type : Hierarchical representation of object we want to get,
 *                       For example, 'jsonData.Envelope.Body["return"].patient' OR 'jsonData.Envelope.return.patient'
 *                       Minimal Requirements : 'X.Y' required.
 * @returns evaluated value of objHierarchy from jsonData passed.
 */
function evalJSONData(jsonData, objHierarchy){
    
    if(!jsonData || !objHierarchy){
        return null;
    }
    
    if(objHierarchy.indexOf('["return"]') !== -1){
        objHierarchy = objHierarchy.replace('["return"]','.return');
    }
    
    let objArray = objHierarchy.split(".");
    if(objArray.length === 2){
        return jsonData[objArray[1]];
    }
    return evalJSONData(jsonData[objArray[1]], objHierarchy.substring(objHierarchy.indexOf(".")+1));
}

Just wrote this function today which does a deep search for a property in a nested object and returns the value at the property if found.

/**
 * Performs a deep search looking for the existence of a property in a 
 * nested object. Supports namespaced search: Passing a string with
 * a parent sub-object where the property key may exist speeds up
 * search, for instance: Say you have a nested object and you know for 
 * certain the property/literal you're looking for is within a certain
 * sub-object, you can speed the search up by passing "level2Obj.targetProp"
 * @param {object} obj Object to search
 * @param {object} key Key to search for
 * @return {*} Returns the value (if any) located at the key
 */
var getPropByKey = function( obj, key ) {
    var ret = false, ns = key.split("."),
        args = arguments,
        alen = args.length;

    // Search starting with provided namespace
    if ( ns.length > 1 ) {
        obj = (libName).getPropByKey( obj, ns[0] );
        key = ns[1];
    }

    // Look for a property in the object
    if ( key in obj ) {
        return obj[key];
    } else {
        for ( var o in obj ) {
            if ( (libName).isPlainObject( obj[o] ) ) {
                ret = (libName).getPropByKey( obj[o], key );
                if ( ret === 0 || ret === undefined || ret ) {
                    return ret;
                }
            }
        }
    }

    return false;
}

Here's a little helper function I use that, to me, is pretty simple and straightforward. Hopefully it's helpful to some :).

static issetFromIndices(param, indices, throwException = false) {
    var temp = param;

    try {
        if (!param) {
            throw "Parameter is null.";
        }

        if(!Array.isArray(indices)) {
            throw "Indices parameter must be an array.";
        }

        for (var i = 0; i < indices.length; i++) {
            var index = indices[i];
            if (typeof temp[index] === "undefined") {
                throw "'" + index + "' index is undefined.";
            }


            temp = temp[index];
        }
    } catch (e) {
        if (throwException) {
            throw new Error(e);
        } else {
            return false;
        }
    }

    return temp;
}

var person = {
    hobbies: {
        guitar: {
            type: "electric"
        }
    }
};

var indices = ["hobbies", "guitar", "type"];
var throwException = true;

try {
    var hobbyGuitarType = issetFromIndices(person, indices, throwException);
    console.log("Yay, found index: " + hobbyGuitarType);
} catch(e) {
    console.log(e);
}

The very best and simplest answer is:

var isDefinedPath = function (path) {

    var items = path.split ('.');

    if (!items || items.length < 1 || !(items[0] in window)) { return false; }

    var buffer = [items[0]];
    for (var i = 1, e = items.length; i < e; i ++) {
        buffer.push (items[i]);
        if (eval ('typeof(' + buffer.join ('.') + ') == "undefined"')) {
            return false;
        }
    }

    return true;

}

test: isDefinedPath ('level1.level2.level3');

first level cannot be array, others can

A shorter, ES5 version of @CMS's excellent answer:

// Check the obj has the keys in the order mentioned. Used for checking JSON results.  
var checkObjHasKeys = function(obj, keys) {
  var success = true;
  keys.forEach( function(key) {
    if ( ! obj.hasOwnProperty(key)) {
      success = false;
    }
    obj = obj[key];
  })
  return success;
}

With a similar test:

var test = { level1:{level2:{level3:'result'}}};
utils.checkObjHasKeys(test, ['level1', 'level2', 'level3']); // true
utils.checkObjHasKeys(test, ['level1', 'level2', 'foo']); // false