测试深层对象结构中属性的存在 [英] test the existence of property in a deep object structure

问题描述

在javascript中，可以说我想访问对象深处的属性，例如:

In javascript, lets say I want to access a property deep in an object, for example:

entry.mediaGroup [0] .contents [0] .url

entry.mediaGroup[0].contents[0].url

在该结构的任何位置，属性可能都是未定义的(因此可能未设置mediaGroup).

At any point along that structure, a property may be undefined (so mediaGroup may not be set).

有一种简单的说法:

if( entry.mediaGroup[0].contents[0].url ){
   console.log( entry.mediaGroup[0].contents[0].url )
}

没有产生错误?如果沿途的任何点未定义，则这种方式将产生未定义的错误.

without generating an error? This way will generate an undefined error if any point along the way is undefined.

我的解决方案

if(entry) && (entry.mediaGroup) && (entry.MediaGroup[0]) ...snip...){
   console.log(entry.mediaGroup[0].contents[0].url)
}

这很长.我猜肯定有一些更优雅的东西了.

which is pretty lengthy. I am guessing there must be something more elegant.

推荐答案

/*decend through an object tree to a specified node, and return it.
  If node is unreachable, return undefined. This should also work with arrays in the tree.                                                                                               
  Examples:                                                                                                                                                                            
    var test1 = {a:{b:{c:{d:1}}}};                                                                                                                                            
    console.log(objectDesend(test1, 'a', 'b', 'c', 'd'));                                                                                                                
    var test2 = {a:{b:{c:1}}};     //will fail to reach d                                                                                                                                         
    console.log(objectDesend(test2, 'a', 'b', 'c', 'd'));
*/
var objectDescend = function(){
    var obj = arguments[0];
    var keys = arguments;
    var cur = obj;                                                                                                                                                        
    for(var i=1; i<keys.length; i++){                                                                                                                                     
        var key = keys[i];                                                                                                                                                
        var cur = cur[key];                                                                                                                                               
        if(typeof(cur)=='undefined')                                                                                                                                      
            return cur;                                                                                                                                                   
    }                                                                                                                                                                     
    return cur;                                                                                                                                                           
}                                                                                                                                                                         

var test1 = {a:{b:{c:{d:1}}}};                                                                                                                                            
console.log(objectDescend(test1, 'a', 'b', 'c', 'd'));                                                                                                                
var test2 = {a:{b:{c:1}}};                                                                                                                                              
console.log(objectDescend(test2, 'a', 'b', 'c', 'd'));

因此，这将返回您要查找的值，或者由于该值不存在而未定义.它不会返回false，因为它实际上可能是您要查找的值(d:false).

So this will return either the value you are looking for, or undefined since that value doesn't exist. It won't return false, as that may actually be the value you are looking for (d:false).

在我的代码库中，我添加了Object.prototype.descend，因此可以执行test1.descend('a'，'b'，'c'，'d').这仅在ECMAScript 5(IE> = 9)中有效，因为您需要创建它，以便函数不会出现在枚举中.有关更多信息:添加一个Object primitive的方法，但没有将其作为属性出现

In my code base, I add Object.prototype.descend, so I can do test1.descend('a', 'b', 'c', 'd'). This will only work in ECMAScript 5 (IE>=9) since you need to make it so your function doesn't appear in enumerations. For more info: Add a method to Object primative, but not have it come up as a property

这是我的代码:

Object.defineProperty(Object.prototype, 'descend', {
    value: function(){
        var keys = arguments;
        var cur = this;
        for(var i=0; i<keys.length; i++){
            var key = keys[i];
            var cur = cur[key];
            if(typeof(cur)=='undefined')
                return cur;
        }
        return cur;
    }
});



var test1 = {a:{b:{c:{d:false}}}};
//this will return false, which is the value of d                                                                                   
console.log(test1.descend('a', 'b', 'c', 'd'));                                                                                                                       
var test2 = {a:{b:{c:1}}};
//undefined since we can't reach d.                                                                                                
console.log(test2.descend(test2, 'a', 'b', 'c', 'd'));

这篇关于测试深层对象结构中属性的存在的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！