如果我有对象的引用：
var test = {};
可能（但不是立即）具有嵌套对象，例如：
{level1: {level2: {level3: "level3"}}};
检查深度嵌套对象中是否存在属性的最佳方法是什么？
警报（测试级别1）；生成未定义，但警告（test.level1.level2.level3）；失败。
我目前正在做这样的事情：
if(test.level1 && test.level1.level2 && test.level1.level2.level3) {
alert(test.level1.level2.level3);
}
但我想知道是否有更好的方法。
当前回答
我已经对这个问题提出的一些建议进行了性能测试（感谢cdMinix添加了lodash），结果如下。
免责声明#1将字符串转换为引用是不必要的元编程，可能最好避免。首先不要忘记你的推荐人。阅读类似问题的答案。免责声明#2我们在这里谈论的是每毫秒数百万次的操作。在大多数用例中，这些都不太可能产生很大的差异。了解每种方法的局限性，选择最有意义的方法。对我来说，我会采取一些类似于出于方便而减少的措施。
物体包裹（Oliver Steele）–34%–最快
var r1 = (((test || {}).level1 || {}).level2 || {}).level3;
var r2 = (((test || {}).level1 || {}).level2 || {}).foo;
原始解决方案（有疑问的建议）–45%
var r1 = test.level1 && test.level1.level2 && test.level1.level2.level3;
var r2 = test.level1 && test.level1.level2 && test.level1.level2.foo;
checkNested–50%
function checkNested(obj) {
for (var i = 1; i < arguments.length; i++) {
if (!obj.hasOwnProperty(arguments[i])) {
return false;
}
obj = obj[arguments[i]];
}
return true;
}
get_if_exist–52%
function get_if_exist(str) {
try { return eval(str) }
catch(e) { return undefined }
}
有效链–54%
function validChain( object, ...keys ) {
return keys.reduce( ( a, b ) => ( a || { } )[ b ], object ) !== undefined;
}
objHasKeys–63%
function objHasKeys(obj, keys) {
var next = keys.shift();
return obj[next] && (! keys.length || objHasKeys(obj[next], keys));
}
nestedPropertyExists–69%
function nestedPropertyExists(obj, props) {
var prop = props.shift();
return prop === undefined ? true : obj.hasOwnProperty(prop) ? nestedPropertyExists(obj[prop], props) : false;
}
_.获得–72%
深度测试–86%
function deeptest(target, s){
s= s.split('.')
var obj= target[s.shift()];
while(obj && s.length) obj= obj[s.shift()];
return obj;
}
悲伤的小丑–100%–最慢
var o = function(obj) { return obj || {} };
var r1 = o(o(o(o(test).level1).level2).level3);
var r2 = o(o(o(o(test).level1).level2).foo);
其他回答
/**
* @method getValue
* @description simplifies checking for existance and getting a deeply nested value within a ceratin context
* @argument {string} s string representation of the full path to the requested property
* @argument {object} context optional - the context to check defaults to window
* @returns the value if valid and set, returns undefined if invalid / not available etc.
*/
var getValue = function( s, context ){
var fn = function(){
try{
return eval(s);
}catch(e){
return undefined;
}
}
return fn.call(context||window,s);
}
和用法：
if( getValue('a[0].b[0].b[0].d') == 2 ) // true
您可以使用“.”分隔对象和路径
函数checkPathExist（obj，路径）{var pathArray=路径.split（“.”）for（pathArray的var i）{if（反射get（obj，i））{obj=obj[i]；}其他{return false；}}返回true；}var测试=｛level1：｛level2：｛level3：‘level3‘｝｝｝｝；console.log（'level.level.level3=>'，checkPathExist（测试，'level.level 2.level3'））；//真的console.log（'level.level.foo=>'，checkPathExist（测试，'level.level 2.foo'））；//假的
我知道这个问题很古老，但我想通过将其添加到所有对象来提供一个扩展。我知道人们倾向于不赞成使用Object原型来实现扩展的对象功能，但我发现没有什么比这更容易的了。此外，现在还允许使用Object.defineProperty方法。
Object.defineProperty( Object.prototype, "has", { value: function( needle ) {
var obj = this;
var needles = needle.split( "." );
for( var i = 0; i<needles.length; i++ ) {
if( !obj.hasOwnProperty(needles[i])) {
return false;
}
obj = obj[needles[i]];
}
return true;
}});
现在，为了测试任何对象中的任何属性，只需执行以下操作：
if( obj.has("some.deep.nested.object.somewhere") )
这里有一个jsfiddle来测试它，特别是它包含一些jQuery，如果您直接修改Object.prototype，因为属性变为可枚举，则会中断。这对于第三方图书馆来说应该很好。
我已经对这个问题提出的一些建议进行了性能测试（感谢cdMinix添加了lodash），结果如下。
免责声明#1将字符串转换为引用是不必要的元编程，可能最好避免。首先不要忘记你的推荐人。阅读类似问题的答案。免责声明#2我们在这里谈论的是每毫秒数百万次的操作。在大多数用例中，这些都不太可能产生很大的差异。了解每种方法的局限性，选择最有意义的方法。对我来说，我会采取一些类似于出于方便而减少的措施。
物体包裹（Oliver Steele）–34%–最快
var r1 = (((test || {}).level1 || {}).level2 || {}).level3;
var r2 = (((test || {}).level1 || {}).level2 || {}).foo;
原始解决方案（有疑问的建议）–45%
var r1 = test.level1 && test.level1.level2 && test.level1.level2.level3;
var r2 = test.level1 && test.level1.level2 && test.level1.level2.foo;
checkNested–50%
function checkNested(obj) {
for (var i = 1; i < arguments.length; i++) {
if (!obj.hasOwnProperty(arguments[i])) {
return false;
}
obj = obj[arguments[i]];
}
return true;
}
get_if_exist–52%
function get_if_exist(str) {
try { return eval(str) }
catch(e) { return undefined }
}
有效链–54%
function validChain( object, ...keys ) {
return keys.reduce( ( a, b ) => ( a || { } )[ b ], object ) !== undefined;
}
objHasKeys–63%
function objHasKeys(obj, keys) {
var next = keys.shift();
return obj[next] && (! keys.length || objHasKeys(obj[next], keys));
}
nestedPropertyExists–69%
function nestedPropertyExists(obj, props) {
var prop = props.shift();
return prop === undefined ? true : obj.hasOwnProperty(prop) ? nestedPropertyExists(obj[prop], props) : false;
}
_.获得–72%
深度测试–86%
function deeptest(target, s){
s= s.split('.')
var obj= target[s.shift()];
while(obj && s.length) obj= obj[s.shift()];
return obj;
}
悲伤的小丑–100%–最慢
var o = function(obj) { return obj || {} };
var r1 = o(o(o(o(test).level1).level2).level3);
var r2 = o(o(o(o(test).level1).level2).foo);
下面是我的看法-这些解决方案中的大多数都忽略了嵌套数组的情况，如：
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））；
