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

根据@Stephane LaFlèche的回答，我提出了另一个剧本版本。

JSFiddle演示

var obj = {"a":{"b":{"c":"Hello World"}},"resTest":"potato","success":"This path exists"};
checkForPathInObject = function(object,path,value) {
        var pathParts   = path.split("."),
            result      = false;
        // Check if required parameters are set; if not, return false
        if(!object || typeof object == 'undefined' || !path || typeof path != 'string')
            return false;
        /* Loop through object keys to find a way to the path or check for value
         * If the property does not exist, set result to false
         * If the property is an object, update @object
         * Otherwise, update result */
        for(var i=0;i<pathParts.length;i++){
            var currentPathPart = pathParts[i];
            if(!object.hasOwnProperty( currentPathPart )) {
                result = false;
            } else if (object[ currentPathPart ] && path == pathParts[i]) {
                result = pathParts[i];
                break;
            } else if(typeof object[ currentPathPart ] == 'object') {
                object = object[ currentPathPart ];
            } else {
                result = object[ currentPathPart ];
            }
        }
        /* */
        if(typeof value != 'undefined' && value == result)
            return true;
        return result;
};
// Uncomment the lines below to test the script
// alert( checkForPathInObject(obj,'a.b.c') ); // Results "Hello World"
// alert( checkForPathInObject(obj,'a.success') ); // Returns false
// alert( checkForPathInObject(obj,'resTest', 'potato') ); // Returns true

今天刚刚编写了这个函数，它对嵌套对象中的属性进行了深入搜索，如果找到了，则返回该属性的值。

/**
 * Performs a deep search looking for the existence of a property in a 
 * nested object. Supports namespaced search: Passing a string with
 * a parent sub-object where the property key may exist speeds up
 * search, for instance: Say you have a nested object and you know for 
 * certain the property/literal you're looking for is within a certain
 * sub-object, you can speed the search up by passing "level2Obj.targetProp"
 * @param {object} obj Object to search
 * @param {object} key Key to search for
 * @return {*} Returns the value (if any) located at the key
 */
var getPropByKey = function( obj, key ) {
    var ret = false, ns = key.split("."),
        args = arguments,
        alen = args.length;

    // Search starting with provided namespace
    if ( ns.length > 1 ) {
        obj = (libName).getPropByKey( obj, ns[0] );
        key = ns[1];
    }

    // Look for a property in the object
    if ( key in obj ) {
        return obj[key];
    } else {
        for ( var o in obj ) {
            if ( (libName).isPlainObject( obj[o] ) ) {
                ret = (libName).getPropByKey( obj[o], key );
                if ( ret === 0 || ret === undefined || ret ) {
                    return ret;
                }
            }
        }
    }

    return false;
}

对该答案进行轻微编辑，以允许在路径中嵌套数组

var has=函数（obj，key）{return key.split（“.”）.every（函数（x）{if（类型obj！=“对象”| | obj===空| |！x在obj中）return false；if（obj.constructor==数组）obj=obj[0]；obj=obj[x]；返回true；});}

检查链接答案的用法：）

我认为下面的脚本提供了更可读的表示。

声明函数：

var o = function(obj) { return obj || {};};

然后这样使用：

if (o(o(o(o(test).level1).level2).level3)
{

}

我称之为“悲伤小丑技巧”，因为它使用了符号o(

编辑：

这是TypeScript的版本

它在编译时提供类型检查（如果使用像Visual Studio这样的工具，还提供智能感知）

export function o<T>(someObject: T, defaultValue: T = {} as T) : T {
    if (typeof someObject === 'undefined' || someObject === null)
        return defaultValue;
    else
        return someObject;
}

用法相同：

o(o(o(o(test).level1).level2).level3

但这次intelligense奏效了！

此外，您可以设置默认值：

o(o(o(o(o(test).level1).level2).level3, "none")

使现代化

看起来lodash已经为您的所有嵌套属性获取需求添加了_.get。

_.get(countries, 'greece.sparta.playwright')

https://lodash.com/docs#get

上一个答案

lodash用户可能喜欢lodash.contrib，它有几种方法可以缓解这个问题。

获取路径

签名：_.getPath（obj:Object，ks:String|Array）

基于所描述的路径获取嵌套对象中任何深度处的值给出的钥匙。键可以以数组或点分隔字符串的形式给出。如果无法到达路径，则返回undefined。

var countries = {
        greece: {
            athens: {
                playwright:  "Sophocles"
            }
        }
    }
};

_.getPath(countries, "greece.athens.playwright");
// => "Sophocles"

_.getPath(countries, "greece.sparta.playwright");
// => undefined

_.getPath(countries, ["greece", "athens", "playwright"]);
// => "Sophocles"

_.getPath(countries, ["greece", "sparta", "playwright"]);
// => undefined