我认为这是一个轻微的改进（变成了一行）：

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

这之所以有效，是因为&&运算符返回其计算的最终操作数（并且短路）。

我在寻找属性存在时返回的值，所以我通过上面的CMS修改了答案。下面是我想到的：

函数getNestedProperty（obj，key）{//从键字符串获取属性数组var财产=key.split（“.”）；//遍历财产，如果对象为空或属性不存在，则返回未定义的对于（var i=0；i<属性.length；i++）{if（！obj||！obj.hasOwnProperty（财产[i]））{回来}obj=obj[财产[i]]；}//找到嵌套属性，因此返回值返回obj；}用法：getNestedProperty（测试，“level.level2.level3”）//“level3”getNestedProperty（测试，“level.level2.foo”）//未定义

如果您恰好使用AngularJs，则可以使用$parse服务检查是否存在深度对象属性，如下所示：

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

为了避免这样的陈述：

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

不要忘记将$parse服务注入控制器

有关详细信息：https://glebbahmutov.com/blog/angularjs-parse-hacks/

今天刚刚编写了这个函数，它对嵌套对象中的属性进行了深入搜索，如果找到了，则返回该属性的值。

/**
 * 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;
}

在html模板中使用一行程序并没有真正好的答案，所以我使用ES6代理做了一个。您只需将一个对象或值传递给“遍历”函数，并使用返回值或回退值的函数调用来完成所需的嵌套调用。使用：

const testObject=｛深度：｛嵌套：｛对象：｛closure:（）=>｛return“closure”｝，数量：9，布尔值：真，数组：[1，2，｛foo:｛bar:true｝｝]} }}}遍历（testObject）.dep（）//｛嵌套：｛…｝｝遍历（testObject）.non.existint（）//未定义的遍历（testObject）.dep.enested.obj.closure（）//关闭遍历（testObject）.dep.enested.obj.array[5]（'fallback'）//后退，后退遍历（testObject）.dep.enested.obj.array[2]（）//｛foo:｛…｝｝遍历（testObject）.dep.enested.obj.array[2].foo.bar（）//真的遍历（testObject）.dept.netnested.obj.array[2].foo.bar[4]（'fallback'）//后退，后退遍历（testObject）.完全.错误[3].调用（）.WILL_THROW（）//未捕获的TypeError:无法读取未定义的属性“WILL_TROW”

函数本身：

常量遍历=（输入）=>{//唯一空对象const unset=新对象（）；//我们需要包装器来确保我们可以访问同一个唯一的空对象常量闭包=（输入）=>{//将每个输入包装到此const handler=new Function（）；handler.input=输入；//返回包装器代理返回新代理（handler{//保持横向移动获取：（target，name）=>{//如果未定义，则作为初始输入提供if（！target.input）{返回关闭（未设置）；}//否则if（target.input[name]！==未定义）{//输入具有该属性返回闭包（target.input[name]）；}其他{返回关闭（未设置）；}},//带回退的结果apply:（目标，上下文，参数）=>{return handler.input==未设置？args[0]：handler.input；}})}返回闭合（输入）；}

您可以尝试可选链接（但要注意浏览器兼容性）。

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

let level3 = test?.level1?.level2?.level3;
console.log(level3); // level3

level3 = test?.level0?.level1?.level2?.level3;
console.log(level3); // undefined

有一个babel插件（@babel/plugin建议可选链接）用于光学通道。所以，如果需要，请升级您的babel。