我编写了一个名为l33teral的库来帮助测试嵌套财产。您可以这样使用：

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

我也很喜欢这里的ES5/6解决方案。

在typeScript中，您可以执行以下操作：

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

我已经对这个问题提出的一些建议进行了性能测试（感谢cdMinix添加了lodash），结果如下。

免责声明#1将字符串转换为引用是不必要的元编程，可能最好避免。首先不要忘记你的推荐人。阅读类似问题的答案。免责声明#2我们在这里谈论的是每毫秒数百万次的操作。在大多数用例中，这些都不太可能产生很大的差异。了解每种方法的局限性，选择最有意义的方法。对我来说，我会采取一些类似于出于方便而减少的措施。

物体包裹（Oliver Steele）–34%–最快

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

原始解决方案（有疑问的建议）–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 }
}

有效链–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;
}

_.获得–72%

深度测试–86%

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

悲伤的小丑–100%–最慢

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

这适用于所有对象和阵列：）

ex:

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

这是我对Brian答案的改进版

我使用_has作为属性名称，因为它可能与现有的has属性（例如：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;
}});

这是小提琴

下面是我的看法-这些解决方案中的大多数都忽略了嵌套数组的情况，如：

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

我可能想检查obj.l2[0].k

使用下面的函数，您可以执行深度测试（'l2[0].k'，obj）

如果对象存在，函数将返回true，否则返回false

函数deeptest（keyPath，testObj）{变量obj；keyPath=keyPath.split（'.'）var cKey=keyPath.shift（）；函数get（pObj，pKey）{var bracketStart，bracketEnd，o；bracketStart=pKey.indexOf（“[”）；if（bracketStart>-1）｛//检查嵌套数组bracketEnd=pKey.indexOf（“]”）；var arrIndex=pKey.substr（bracketStart+1，bracketEnd-bracketStart-1）；pKey=pKey.substr（0，括号开始）；var n=pObj[pKey]；o=n？n[arrIndex]：未定义；}其他{o=pObj[pKey]；}返回o；}obj=获取（testObj，cKey）；while（obj&&keyPath.length）{obj=get（obj，keyPath.shift（））；}返回typeof（obj）！=='未定义'；}变量obj={“l1”：“级别1”，“arr1”：[｛“k”：0｝，{“k”:1}，｛“k”：2｝],“子”：{“a”：“字母a”，“b”：“字母b”}};console.log（“l1：”+深度测试（“l1”，obj））；console.log（“arr1[0]：”+深度测试（“arr1[0]”，obj））；console.log（“arr1[1].k:”+深度测试（“arr1].k”，obj））；console.log（“arr1[1].j:”+深度测试（“arr1].j”，obj））；console.log（“arr1[3]：”+深度测试（“arr1[3]”，obj））；console.log（“arr2:”+深度测试（“arr2”，obj））；

这是我从奥利弗·斯蒂尔那里学到的一个模式：

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

事实上，整篇文章讨论了如何在javascript中实现这一点。他决定使用上面的语法（一旦你习惯了，它就不那么难读了）作为成语。