您还可以将tc39可选链接建议与babel 7-tc39建议可选链接一起使用

代码如下所示：

  const test = test?.level1?.level2?.level3;
  if (test) alert(test);

另一种方式：

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

我也遇到了同样的问题，我想看看是否能找到自己的解决方案。这接受要检查的路径作为字符串。

function checkPathForTruthy(obj, path) {
  if (/\[[a-zA-Z_]/.test(path)) {
    console.log("Cannot resolve variables in property accessors");
    return false;
  }

  path = path.replace(/\[/g, ".");
  path = path.replace(/]|'|"/g, "");
  path = path.split(".");

  var steps = 0;
  var lastRef = obj;
  var exists = path.every(key => {
    var currentItem = lastRef[path[steps]];
    if (currentItem) {
      lastRef = currentItem;
      steps++;
      return true;
    } else {
      return false;
    }
  });

  return exists;
}

下面是一些日志记录和测试用例的片段：

console.clear（）；var测试案例=[[“data.Messages[0].Code”，true]，[“data.Messages[1].Code”，true]，[“data.Messages[0]['Code']”，true]，['data.Messages[0][“Code”]'，true]，[“data[Messages][0]['Code']”，错误]，[“data['Messages'][0]['Code']”，真]];var path=“data.Messages[0].Code”；变量obj={数据：{消息：[{代码：“0”}, {代码：“1”}]}}函数checkPathForTruthy（obj，路径）{if（/\[[a-zA-Z_]/.test（路径））{console.log（“无法解析属性访问器中的变量”）；return false；}path=路径替换（/\[/g，“.”）；path=路径替换（/]|'|“/g，”“）；path=路径拆分（“.”）；var步数=0；var lastRef=obj；var logOutput=[]；var exists=path.every（key=>{var currentItem=lastRef[path[steps]]；if（currentItem）{logOutput.push（currentItem）；lastRef=当前项；步骤++；返回true；}其他{return false；}});console.log（存在，logOutput）；返回存在；}testCase.forEach（testCase=>{如果（checkPathForTruthy（obj，testCase[0]）==testCase[1]）{console.log（“通过：”+testCase[0]）；}其他{console.log（“失败：”+testCase[0]+“预期”+testCase[1]）；}});

另一个选项（接近这个答案）：

function resolve(root, path){
    try {
        return (new Function(
            'root', 'return root.' + path + ';'
        ))(root);
    } catch (e) {}
}

var tree = { level1: [{ key: 'value' }] };
resolve(tree, 'level1[0].key'); // "value"
resolve(tree, 'level1[1].key'); // undefined

更多信息：https://stackoverflow.com/a/18381564/1636522

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

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

这是小提琴

这个功能怎么样？它不需要单独列出每个嵌套属性，而是保持“dot”语法（尽管是字符串），使其更具可读性。如果未找到属性，则返回undefined或指定的默认值，如果找到，则返回属性的值。

val(obj, element, default_value)
    // Recursively checks whether a property of an object exists. Supports multiple-level nested properties separated with '.' characters.
    // obj = the object to test
    // element = (string or array) the name of the element to test for.  To test for a multi-level nested property, separate properties with '.' characters or pass as array)
    // default_value = optional default value to return if the item is not found. Returns undefined if no default_value is specified.
    // Returns the element if it exists, or undefined or optional default_value if not found.
    // Examples: val(obj1, 'prop1.subprop1.subsubprop2');
    // val(obj2, 'p.r.o.p', 'default_value');
    {

        // If no element is being requested, return obj. (ends recursion - exists)
        if (!element || element.length == 0) { return obj; }

        // if the element isn't an object, then it can't have properties. (ends recursion - does not exist)
        if (typeof obj != 'object') { return default_value; }

        // Convert element to array.
        if (typeof element == 'string') { element = element.split('.') };   // Split on dot (.)

        // Recurse into the list of nested properties:
        let first = element.shift();
        return val(obj[first], element, default_value);

    }