Javascript 迭代和搜索具有多个级别的对象文字中的值

以下是我想做的：

我有一个具有多个级别的树（javascript对象文字结构）

我有这个对象的一个特定键的值

我想在结构中搜索这个精确的键值对，并返回另一个键的值作为输出

为清楚起见，以下是我的对象文字：

{
"nodeId": 1081,
"appId": 150,
"displayText": "Welcome here",
"Nodes": [
    {
        "nodeId": 2000,
        "appId": 150,
        "displayText": "Buy",
        "parentNodeId": 1081,
        "Nodes": [
            {
                "nodeId": 2003,
                "appId": 150,
                "displayText": "tCars",
                "parentNodeId": 2000,
                "Nodes": [
                    {
                        "nodeId": 2006,
                        "appId": 150,
                        "displayText": "Diesel",
                        "parentNodeId": 2003,
                        "Nodes": [
                            {
                                "nodeId": 2008,
                                "appId": 150,
                                "displayText": "Price", //This is what I want as return value.
                                "parentNodeId": 2006,
                                "Nodes": [],
                                "nodeCode": "RN_1_1_2_1_3_2_4_1",
                                "parentCode": "RN_1_1_2_1_3_2",
                                "jumpToNode": "RN_1_1" //here is the value that I have with me.
                            }
                        ],
                        "nodeCode": "RN_1_1_2_1_3_2",
                        "parentCode": "RN_1_1_2_1"
                    }
                ],
                "concatWithHeader": false,
                "nodeCode": "RN_1_1_2_1",
                "parentCode": "RN_1_1"
            }
        ],
        "nodeCode": "RN_1_1",
        "parentCode": "RN"
    }
  ],
  "nodeCode": "RN",
  "parentCode": "ROOT_NODE"
}

2。我随身携带的值是“RN_1_1”，与

jumpToNode

3。我想在此对象文本中搜索并获取键的值

displayText

为此，我搜索并尝试了一些方法，但无法获得迭代内部

节点
对象的逻辑

到目前为止我写的方法是：

function getObjects(tree){
var searchkey="RN_1_1";
var displayText = "displayText";
var nodeCode = "nodeCode";
var returnText;

if (tree.hasOwnProperty(nodeCode)) {
   var obj = tree[nodeCode];

   if(obj == searchkey){
    returnText = tree[displayText]; //gives me the return text
    break;
   }
   else{
    //here I should iterate over the inner `Nodes` and get the required value.
   }
}
}

请帮忙

谢谢。
我想你可以做类似这样的事情，递归地工作：

function findProperty(obj, prop, val, propToFetch) {
    var answer;
    if (obj.hasOwnProperty(prop) && obj[prop] === val) {
        return obj[propToFetch];
    }
    for (var i = 0, len = obj.Nodes.length; i < len; i++) {
        answer = findProperty(obj.Nodes[i], prop, val, propToFetch);
        if (answer !== null) {return answer;}
    }
    return null;
}

var result = findProperty(data, "jumpToNode", "RN_1_1", "displayText");

功能查找属性（obj、prop、val、propToFetch）{
var回答；
if（对象hasOwnProperty（prop）&&obj[prop]==val）{
返回对象[propToFetch]；
}
对于（变量i=0，len=obj.Nodes.length；i

此处的工作演示：
根据您的JSON对象，您可以使用以下方式：

var searchKey="RN_1_1",
displayText = "displayText",
nodeCode = "nodeCode",
returnText,

treeSearch = function (obj, searchKey) {
              if (obj[nodeCode] === searchKey) {
                returnText = obj[displayText];
              } else {
                if (obj['Nodes'][0]) {
                  treeSearch(obj['Nodes'][0], searchKey);
                } else {
                  returnText = null
                }

              }
            };

treeSearch(JSONdata, 'RN_1_1_2_1_3_2');

我已经使用nodeId展平了数组，以便更容易在其中搜索

展平阵列后，可以根据需要对其进行过滤（我建议使用）

这是现场直播。结果显示在控制台中

  function flattenNodes (obj, newArr) {
    if (obj && obj.Nodes) {
        var nodes = obj.Nodes;
        delete(obj.Nodes);
        newArr[obj.nodeId] = obj;
        return flattenNodes(nodes.pop(), newArr);
    } else {
        return newArr;
    }
  };
  var flattenArr = flattenNodes(arr, new Array());

  function findInJumpToNode(find) {
      for(key in flattenArr) {
        if (flattenArr[key] && flattenArr[key]['jumpToNode']) {
          if (flattenArr[key]['jumpToNode'] == find) {
            return flattenArr[key];
          }
        }
      }
  }

  var found = findInJumpToNode('RN_1_1');
  console.log(found);

您可以使用递归来处理您的案例。
在jsFiddle上查看这个

var nodes= [getNodes()];  
alert(getObjects(nodes));
function getObjects(tree){    

var searchkey="RN_1_1_2_1_3_2_4_1";
var displayText = "displayText";
var nodeCode = "nodeCode";
var returnText;

if(tree.length > 0)
{    
    if(tree[0]["nodeCode"] === searchkey)
    {        
        return tree[0][displayText];        
    }
    if(typeof tree[0]["Nodes"] === "undefined")
    {
        return;
    }
    return getObjects(tree[0]["Nodes"]);
}



}

如果节点数组中有多个项，这看起来不起作用。OP的javascript可能没有显示这种情况，但是如果数组中没有为多个对象设置的话，它就没有理由成为一个数组。