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

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

这个问题由来已久。今天，您可以使用可选链接（？.）

let value = test?.level1?.level2?.level3;

资料来源：

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Optional_chaining

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

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

另一个ES5解决方案：

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

我创建了一个小函数来安全地获取嵌套对象财产。

function getValue(object, path, fallback, fallbackOnFalsy) {
    if (!object || !path) {
        return fallback;
    }

    // Reduces object properties to the deepest property in the path argument.
    return path.split('.').reduce((object, property) => {
       if (object && typeof object !== 'string' && object.hasOwnProperty(property)) {
            // The property is found but it may be falsy.
            // If fallback is active for falsy values, the fallback is returned, otherwise the property value.
            return !object[property] && fallbackOnFalsy ? fallback : object[property];
        } else {
            // Returns the fallback if current chain link does not exist or it does not contain the property.
            return fallback;
        }
    }, object);
}

或者更简单但稍微不可读的版本：

function getValue(o, path, fb, fbFalsy) {
   if(!o || !path) return fb;
   return path.split('.').reduce((o, p) => o && typeof o !== 'string' && o.hasOwnProperty(p) ? !o[p] && fbFalsy ? fb : o[p] : fb, o);
}

或者更短，但没有错误标志：

function getValue(o, path, fb) {
   if(!o || !path) return fb;
   return path.split('.').reduce((o, p) => o && typeof o !== 'string' && o.hasOwnProperty(p) ? o[p] : fb, o);
}

我测试了：

const obj = {
    c: {
        a: 2,
        b: {
            c: [1, 2, 3, {a: 15, b: 10}, 15]
        },
        c: undefined,
        d: null
    },
    d: ''
}

下面是一些测试：

// null
console.log(getValue(obj, 'c.d', 'fallback'));

// array
console.log(getValue(obj, 'c.b.c', 'fallback'));

// array index 2
console.log(getValue(obj, 'c.b.c.2', 'fallback'));

// no index => fallback
console.log(getValue(obj, 'c.b.c.10', 'fallback'));

要查看所有包含文档和测试的代码，您可以查看我的github要点：https://gist.github.com/vsambor/3df9ad75ff3de489bbcb7b8c60beebf4#file-javascriptgetnestedvalues js

我没有看到任何人使用代理的例子

所以我想出了自己的办法。它的优点是你不必对字符串进行插值。实际上，您可以返回一个可链接的对象函数并用它做一些神奇的事情

函数解析（目标）{var noop=（）=>｛｝//我们使用了一个noop函数，因此我们也可以调用方法返回新代理（noop{获取（noop，key）{//如果键为_result，则返回最终结果返回键==“_result”? 目标：resolve（//使用目标值或未定义的值进行解析目标==未定义？未定义：目标[key])},//如果我们想测试一个函数，那么由于使用noop，我们可以这么做//而不是在代理中使用target应用（noop，that，args）{返回解析（typeof target==“function”？target.apply（that，args）：未定义）},})}//接受答案中的一些修改示例var测试=｛level1：｛level2：（）=>（｛level3:'level3'｝）｝｝var test1=｛key1：｛key2：['item0‘]｝｝//您需要在最后获得_result以获得最终结果console.log（解析（测试）.level1.level2（）.level3._result）console.log（解析（测试）.level1.level2（）.level3.level4.level5._result）console.log（解析（test1）.key1.key2[0].result）console.log（resolve（test1）[0].key.result）//不存在

以上代码适用于同步内容。但是，如何测试像ajax调用这样的异步功能呢？你是怎么测试的？

fetch('https://httpbin.org/get')
.then(function(response) {
  return response.json()
})
.then(function(json) {
  console.log(json.headers['User-Agent'])
})

确保可以使用async/await来消除一些回调。但如果你能做得更神奇呢？看起来像这样的东西：

fetch('https://httpbin.org/get').json().headers['User-Agent']

你可能会想知道所有的承诺和链条在哪里。。。这可能会阻碍你所知道的一切。。。但使用相同的代理技术，您实际上可以测试深度嵌套的复杂路径是否存在，而无需编写单个函数

函数解析（目标）｛返回新代理（（）=>{}{获取（noop，key）{return key==“then”？target.then.bind（target）：解析(承诺.解决（目标）.然后（目标=>{if（typeof target[key]==“function”）返回target[key].bind（target）返回目标[键]}))},应用（noop，that，args）{返回解析（target.then（result=>{返回result.apply（即，args）}))},})}//这感觉非常同步，但仍然是非阻塞的：）resolve（window）//这将链接一个noop函数，直到您调用then（）.fetch（'https://httpbin.org/get').json（）.headers[“用户代理”].then（console.log，console.warn）//如果它不存在，则会收到警告//也可以对第一个测试对象使用此方法//也可以，但最后必须调用.then（）//另一个例子解析（窗口）.fetch（'https://httpbin.org/get?items=4&items=2').json（）.args参数.个项目//很好，您可以在没有准备好的情况下映射数组项.map（n=>~n*4）.then（console.log，console.warn）//如果它不存在，则会收到警告