简单使用https://www.npmjs.com/package/js-aid用于检查嵌套对象的包。

function getValue(base, strValue) {

    if(base == null) return;
    
    let currentKey = base;
    
    const keys = strValue.split(".");
    
    let parts;
    
    for(let i=1; i < keys.length; i++) {
        parts = keys[i].split("[");
        if(parts == null || parts[0] == null) return;
        let idx;
        if(parts.length > 1) { // if array
            idx = parseInt(parts[1].split("]")[0]);
            currentKey = currentKey[parts[0]][idx];
        } else {
            currentKey = currentKey[parts[0]];
        }
        if(currentKey == null) return;
    }
    return currentKey;
}

如果结果在嵌套或值本身的任何地方失败，则调用函数返回undefined

const a = {
  b: {
    c: [
      {
        d: 25
      }
    ]
  }
}
console.log(getValue(a, 'a.b.c[1].d'))
// output
25

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

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

函数解析（目标）{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）//如果它不存在，则会收到警告

如果您恰好使用AngularJs，则可以使用$parse服务检查是否存在深度对象属性，如下所示：

if( $parse('model.data.items')(vm) ) {
    vm.model.data.items.push('whatever');
}

为了避免这样的陈述：

if(vm.model && vm.model.data && vm.model.data.items) {
    ....
}

不要忘记将$parse服务注入控制器

有关详细信息：https://glebbahmutov.com/blog/angularjs-parse-hacks/

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

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

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

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