另一种方式：

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

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

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

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

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

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

如果您在ES6环境中编码（或使用6to5），则可以利用箭头函数语法：

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

关于性能，使用try没有性能惩罚。。如果设置了属性，则捕获块。如果属性未设置，则会影响性能。

考虑简单地使用_.has：

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

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

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

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

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

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

这是小提琴

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

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