在深層物體中按名稱查找屬性

Question

我有一個巨大的集合，我正在尋找一個屬性集合內的關鍵某處。獲取包含該鍵/索引的所有對象的引用列表或完整路徑的可靠方法是什麼？我使用jQuery和lodash，如果它有幫助，你可以忘記無限指針遞歸，這是一個純粹的JSON響應。

fn({ 'a': 1, 'b': 2, 'c': {'d':{'e':7}}}, "d"); 
// [o.c] 

fn({ 'a': 1, 'b': 2, 'c': {'d':{'e':7}}}, "e"); 
// [o.c.d] 

fn({ 'aa': 1, 'bb': 2, 'cc': {'d':{'x':9}}, dd:{'d':{'y':9}}}, 'd'); 
// [o.cc,o.cc.dd] 

FWIW lodash具有_.find函數，會發現有兩個窩深嵌套的對象，但似乎在那之後失敗。 （例如http://codepen.io/anon/pen/bnqyh）

Answer 1

這應做到：

function fn(obj, key) { 
    if (_.has(obj, key)) // or just (key in obj) 
     return [obj]; 
    // elegant: 
    return _.flatten(_.map(obj, function(v) { 
     return typeof v == "object" ? fn(v, key) : []; 
    }), true); 

    // or efficient: 
    var res = []; 
    _.forEach(obj, function(v) { 
     if (typeof v == "object" && (v = fn(v, key)).length) 
      res.push.apply(res, v); 
    }); 
    return res; 
} 

Answer 2

類似這樣的東西可以工作，將其轉換爲對象並遞歸。

function find(jsonStr, searchkey) { 
    var jsObj = JSON.parse(jsonStr); 
    var set = []; 
    function fn(obj, key, path) { 
     for (var prop in obj) { 
      if (prop === key) { 
       set.push(path + "." + prop); 
      } 
      if (obj[prop]) { 
       fn(obj[prop], key, path + "." + prop); 
      } 
     } 
     return set; 
    } 
    fn(jsObj, searchkey, "o"); 
} 

小提琴：jsfiddle

Answer 3

一個純JavaScript的解決辦法如下所示：

function findNested(obj, key, memo) { 
    var i, 
     proto = Object.prototype, 
     ts = proto.toString, 
     hasOwn = proto.hasOwnProperty.bind(obj); 

    if ('[object Array]' !== ts.call(memo)) memo = []; 

    for (i in obj) { 
    if (hasOwn(i)) { 
     if (i === key) { 
     memo.push(obj[i]); 
     } else if ('[object Array]' === ts.call(obj[i]) || '[object Object]' === ts.call(obj[i])) { 
     findNested(obj[i], key, memo); 
     } 
    } 
    } 

    return memo; 
} 

這裏是你如何使用這個功能：

findNested({'aa': 1, 'bb': 2, 'cc': {'d':{'x':9}}, dd:{'d':{'y':9}}}, 'd'); 

和結果將是：

[{x: 9}, {y: 9}] 

Answer 4

這將深搜索對象（乾草）的值（針）的數組，然後返回的結果數組...

search = function(hay, needle, accumulator) { 
    var accumulator = accumulator || []; 
    if (typeof hay == 'object') { 
    for (var i in hay) { 
     search(hay[i], needle, accumulator) == true ? accumulator.push(hay) : 1; 
    } 
    } 
    return new RegExp(needle).test(hay) || accumulator; 
} 

Answer 5

Array.prototype.findpath = function(item,path) { 
    return this.find(function(f){return item==eval('f.'+path)}); 
} 

Answer 6

我是這樣做的：

function _find(obj, field, results) 
{ 
    var tokens = field.split('.'); 

    // if this is an array, recursively call for each row in the array 
    if(obj instanceof Array) 
    { 
     obj.forEach(function(row) 
     { 
      _find(row, field, results); 
     }); 
    } 
    else 
    { 
     // if obj contains the field 
     if(obj[ tokens[ 0 ] ] !== undefined) 
     { 
      // if we're at the end of the dot path 
      if(tokens.length === 1) 
      { 
       results.push(obj[ tokens[ 0 ] ]); 
      } 
      else 
      { 
       // keep going down the dot path 
       _find(obj[ tokens[ 0 ] ], field.substr(field.indexOf('.') + 1), results); 
      } 
     } 
    } 
} 

以測試它：

var obj = { 
    document: { 
     payload: { 
      items:[ 
       {field1: 123}, 
       {field1: 456} 
       ] 
     } 
    } 
}; 
var results = []; 

_find(obj.document,'payload.items.field1', results); 
console.log(results); 

輸出

[ 123, 456 ]