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

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

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

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

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

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

另一种解决方法是，例如，使用以下对象：

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

然后，我所做的是向这个对象添加以下函数：

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

然后您可以测试：

x.getKey('a.b');

如果未定义，则函数返回“”（空字符串），否则返回现有值。

还请考虑检查链接的另一个更复杂的解决方案：JS对象具有属性深度检查

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

注：还有一个递归版本。

在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；}})}返回闭合（输入）；}

另一个ES5解决方案：

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

我以以下方式使用函数。

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