如果像字符串一样处理名称：“t.level1。level2。level3”，则可以在任何深度读取对象属性。

window.t={level1:{level2:{level3: 'level3'}}};

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

alert(deeptest('t.level1.level2.level3') || 'Undefined');

如果任何段未定义，则返回undefined。

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

    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））；

我编写了自己的函数，该函数采用所需的路径，并具有一个好的和坏的回调函数。

function checkForPathInObject(object, path, callbackGood, callbackBad){
    var pathParts = path.split(".");
    var currentObjectPath = object;

    // Test every step to see if it exists in object
    for(var i=0; i<(pathParts.length); i++){
        var currentPathPart = pathParts[i];
        if(!currentObjectPath.hasOwnProperty(pathParts[i])){
            if(callbackBad){
                callbackBad();
            }
            return false;
        } else {
            currentObjectPath = currentObjectPath[pathParts[i]];
        }
    }

    // call full path in callback
    callbackGood();
}

用法：

var testObject = {
    level1:{
        level2:{
            level3:{
            }
        }
    }
};


checkForPathInObject(testObject, "level1.level2.level3", function(){alert("good!")}, function(){alert("bad!")}); // good

checkForPathInObject(testObject, "level1.level2.level3.levelNotThere", function(){alert("good!")}, function(){alert("bad!")}); //bad

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

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

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

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

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

您可以使用递归函数来实现这一点。即使您不知道所有嵌套的对象键名称，也可以使用此方法。

function FetchKeys(obj) {
    let objKeys = [];
    let keyValues = Object.entries(obj);
    for (let i in keyValues) {
        objKeys.push(keyValues[i][0]);
        if (typeof keyValues[i][1] == "object") {
            var keys = FetchKeys(keyValues[i][1])
            objKeys = objKeys.concat(keys);
        }
    }
    return objKeys;
}

let test = { level1: { level2: { level3: "level3" } } };
let keyToCheck = "level2";
let keys = FetchKeys(test); //Will return an array of Keys

if (keys.indexOf(keyToCheck) != -1) {
    //Key Exists logic;
}
else {
    //Key Not Found logic;
}