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

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

这是小提琴

CMS给出的答案也适用于空检查的以下修改

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

这是我使用的一个小助手函数，对我来说，它非常简单明了。希望这对一些人有帮助：）。

static issetFromIndices(param, indices, throwException = false) {
    var temp = param;

    try {
        if (!param) {
            throw "Parameter is null.";
        }

        if(!Array.isArray(indices)) {
            throw "Indices parameter must be an array.";
        }

        for (var i = 0; i < indices.length; i++) {
            var index = indices[i];
            if (typeof temp[index] === "undefined") {
                throw "'" + index + "' index is undefined.";
            }


            temp = temp[index];
        }
    } catch (e) {
        if (throwException) {
            throw new Error(e);
        } else {
            return false;
        }
    }

    return temp;
}

var person = {
    hobbies: {
        guitar: {
            type: "electric"
        }
    }
};

var indices = ["hobbies", "guitar", "type"];
var throwException = true;

try {
    var hobbyGuitarType = issetFromIndices(person, indices, throwException);
    console.log("Yay, found index: " + hobbyGuitarType);
} catch(e) {
    console.log(e);
}

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

怎么样

try {
   alert(test.level1.level2.level3)
} catch(e) {
 ...whatever

}

根据之前的评论，这里是另一个无法定义主对象的版本：

// Supposing that our property is at first.second.third.property:
var property = (((typeof first !== 'undefined' ? first : {}).second || {}).third || {}).property;