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.

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

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.

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

how about

try {

   alert(test.level1.level2.level3)

} catch(e) {

 ...whatever



}

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

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

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

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

  var noop = () => {} // We us a noop function so we can call methods also

  return new Proxy(noop, {

    get(noop, key) {

      // return end result if key is _result

      return key === '_result' 

        ? target 

        : resolve( // resolve with target value or undefined

            target === undefined ? undefined : target[key]

          )

    },



    // if we want to test a function then we can do so alos thanks to using noop

    // instead of using target in our proxy

    apply(noop, that, args) {

      return resolve(typeof target === 'function' ? target.apply(that, args) : undefined)

    },

  })

}



// some modified examples from the accepted answer

var test = {level1: {level2:() => ({level3:'level3'})}}

var test1 = {key1: {key2: ['item0']}}



// You need to get _result in the end to get the final result



console.log(resolve(test).level1.level2().level3._result)

console.log(resolve(test).level1.level2().level3.level4.level5._result)

console.log(resolve(test1).key1.key2[0]._result)

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

  return new Proxy(() => {}, {

    get(noop, key) {

      return key === 'then' ? target.then.bind(target) : resolve(

        Promise.resolve(target).then(target => {

          if (typeof target[key] === 'function') return target[key].bind(target)

          return target[key]

        })

      )

    },



    apply(noop, that, args) {

      return resolve(target.then(result => {

        return result.apply(that, args)

      }))

    },

  })

}



// this feels very much synchronous but are still non blocking :)

resolve(window) // this will chain a noop function until you call then()

  .fetch('https://httpbin.org/get')

  .json()

  .headers['User-Agent']

  .then(console.log, console.warn) // you get a warning if it doesn't exist

  

// You could use this method also for the first test object

// also, but it would have to call .then() in the end







// Another example

resolve(window)

  .fetch('https://httpbin.org/get?items=4&items=2')

  .json()

  .args

  .items

  // nice that you can map an array item without even having it ready

  .map(n => ~~n * 4) 

  .then(console.log, console.warn) // you get a warning if it doesn't exist

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.

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

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

}

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;

    }

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

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.

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

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

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

    var obj;



    keyPath = keyPath.split('.')

    var cKey = keyPath.shift();



    function get(pObj, pKey) {

        var bracketStart, bracketEnd, o;



        bracketStart = pKey.indexOf("[");

        if (bracketStart > -1) { //check for nested arrays

            bracketEnd = pKey.indexOf("]");

            var arrIndex = pKey.substr(bracketStart + 1, bracketEnd - bracketStart - 1);

            pKey = pKey.substr(0, bracketStart);

			var n = pObj[pKey];

            o = n? n[arrIndex] : undefined;



        } else {

            o = pObj[pKey];

        }

        return o;

    }



    obj = get(testObj, cKey);

    while (obj && keyPath.length) {

        obj = get(obj, keyPath.shift());

    }

    return typeof(obj) !== 'undefined';

}



var obj = {

    "l1":"level1",

    "arr1":[

        {"k":0},

        {"k":1},

        {"k":2}

    ],

    "sub": {

       	"a":"letter A",

        "b":"letter B"

    }

};

console.log("l1: " + deeptest("l1",obj));

console.log("arr1[0]: " + deeptest("arr1[0]",obj));

console.log("arr1[1].k: " + deeptest("arr1[1].k",obj));

console.log("arr1[1].j: " + deeptest("arr1[1].j",obj));

console.log("arr1[3]: " + deeptest("arr1[3]",obj));

console.log("arr2: " + deeptest("arr2",obj));

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

// @params o<object>

// @params path<string> expects 'obj.prop1.prop2.prop3'

// returns: obj[path] value or 'false' if prop doesn't exist



const objPropIfExists = o => path => {

  const levels = path.split('.');

  const res = (levels.length > 0) 

    ? levels.reduce((a, c) => a[c] || 0, o)

    : o[path];

  return (!!res) ? res : false

}



const obj = {

  name: 'Name',

  sys: { country: 'AU' },

  main: { temp: '34', temp_min: '13' },

  visibility: '35%'

}



const exists = objPropIfExists(obj)('main.temp')

const doesntExist = objPropIfExists(obj)('main.temp.foo.bar.baz')



console.log(exists, doesntExist)

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

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



let _ = test;



if ((_=_.level1) && (_=_.level2) && (_=_.level3)) {



  let level3 = _;

  //do stuff with level3



}

//you could also use 'stacked' if statements. This helps if your object goes very deep. 

//(formatted without nesting or curly braces except the last one)



let _ = test;



if (_=_.level1)

if (_=_.level2)

if (_=_.level3) {



   let level3 = _;

   //do stuff with level3

}





//or you can indent:

if (_=_.level1)

  if (_=_.level2)

    if (_=_.level3) {



      let level3 = _;

      //do stuff with level3

}

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

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;

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

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

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

  // Get property array from key string

  var properties = key.split(".");



  // Iterate through properties, returning undefined if object is null or property doesn't exist

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

    if (!obj || !obj.hasOwnProperty(properties[i])) {

      return;

    }

    obj = obj[properties[i]];

  }



  // Nested property found, so return the value

  return obj;

}





Usage:



getNestedProperty(test, "level1.level2.level3") // "level3"

getNestedProperty(test, "level1.level2.foo") // undefined

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

var testCases = [

  ["data.Messages[0].Code", true],

  ["data.Messages[1].Code", true],

  ["data.Messages[0]['Code']", true],

  ['data.Messages[0]["Code"]', true],

  ["data[Messages][0]['Code']", false],

  ["data['Messages'][0]['Code']", true]

];

var path = "data.Messages[0].Code";

var obj = {

  data: {

    Messages: [{

      Code: "0"

    }, {

      Code: "1"

    }]

  }

}



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 logOutput = ;

  var exists = path.every(key => {

    var currentItem = lastRef[path[steps]];

    if (currentItem) {

      logOutput.push(currentItem);

      lastRef = currentItem;

      steps++;

      return true;

    } else {

      return false;

    }

  });

  console.log(exists, logOutput);

  return exists;

}



testCases.forEach(testCase => {

  if (checkPathForTruthy(obj, testCase[0]) === testCase[1]) {

    console.log("Passed: " + testCase[0]);

  } else {

    console.log("Failed: " + testCase[0] + " expected " + testCase[1]);

  }

});

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

var has = function (obj, key) {

    return key.split(".").every(function (x) {

        if (typeof obj != "object" || obj === null || !x in obj)

            return false;

        if (obj.constructor === Array) 

            obj = obj[0];

        obj = obj[x];

        return true;

    });

}

Check linked answer for usages :)