blocks|key|444793|text|这是基本的递归问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|444794|window.parser+=+function(searchParam,+data)+{
++if(data.title+!=+searchParam)+{
++++returnData+=+window.parser(searchParam,+children)
++}+else+{
+++++returnData+=+data;
++}

++return+returnData;
}|code-block|syntax|javascript|444795|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This is basic recursion problem.

<pre><code>window.parser = function(searchParam, data) {
 if(data.title != searchParam) {
 returnData = window.parser(searchParam, children)
 } else {
 returnData = data;
 }

 return returnData;
}
</code></pre>

blocks|key|659238|text|你必须使用递归。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|659239|var+currChild+=+data[0];
function+searchTree(currChild,+searchString){
+++++if(currChild.title+==+searchString){
++++++++++return+currChild;
+++++}else+if+(currChild.children+!=+null){
++++++++++for(i=0;+i+<+currChild.children.length;+i+%2B%2B){
+++++++++++++++if+(currChild.children[i].title+==searchString){
++++++++++++++++++++return+currChild.children[i];
+++++++++++++++}else{
++++++++++++++++++++searchTree(currChild.children[i],+searchString);
+++++++++++++++}
++++++++++}
++++++++++return+null;
+++++}
+++++return+null;
}|code-block|syntax|javascript|659240|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You have to use recursion.

<pre><code>var currChild = data[0];
function searchTree(currChild, searchString){
 if(currChild.title == searchString){
 return currChild;
 }else if (currChild.children != null){
 for(i=0; i &lt; currChild.children.length; i ++){
 if (currChild.children[i].title ==searchString){
 return currChild.children[i];
 }else{
 searchTree(currChild.children[i], searchString);
 }
 }
 return null;
 }
 return null;
}
</code></pre>

blocks|key|444899|text|基于@Ravindra的答案，但使用真正的递归。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|444900|function+searchTree(element,+matchingTitle){
+++++if(element.title+==+matchingTitle){
++++++++++return+element;
+++++}else+if+(element.children+!=+null){
++++++++++var+i;
++++++++++var+result+=+null;
++++++++++for(i=0;+result+==+null+&&+i+<+element.children.length;+i%2B%2B){
+++++++++++++++result+=+searchTree(element.children[i],+matchingTitle);
++++++++++}
++++++++++return+result;
+++++}
+++++return+null;
}|code-block|syntax|javascript|444901|然后你可以把它叫做：|444902|var+element+=+data[0];
var+result+=+searchTree(element,+'randomNode_1');|444903|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Basing this answer off of @Ravindra's answer, but with true recursion.

<pre><code>function searchTree(element, matchingTitle){
 if(element.title == matchingTitle){
 return element;
 }else if (element.children != null){
 var i;
 var result = null;
 for(i=0; result == null &amp;&amp; i &lt; element.children.length; i++){
 result = searchTree(element.children[i], matchingTitle);
 }
 return result;
 }
 return null;
}
</code></pre>

Then you could call it:

<pre><code>var element = data[0];
var result = searchTree(element, 'randomNode_1');
</code></pre>

blocks|key|659342|text|这是一个迭代的解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|659343|var+stack+=+[],+node,+ii;
stack.push(root);

while+(stack.length+>+0)+{
++++node+=+stack.pop();
++++if+(node.title+==+'randomNode_1')+{
++++++++//+Found+it!
++++++++return+node;
++++}+else+if+(node.children+&&+node.children.length)+{
++++++++for+(ii+=+0;+ii+<+node.children.length;+ii+%2B=+1)+{
++++++++++++stack.push(node.children[ii]);
++++++++}
++++}
}

//+Didn't+find+it.+Return+null.
return+null;|code-block|syntax|javascript|659344|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here's an iterative solution:

<pre><code>var stack = [], node, ii;
stack.push(root);

while (stack.length &gt; 0) {
 node = stack.pop();
 if (node.title == 'randomNode_1') {
 // Found it!
 return node;
 } else if (node.children &amp;&amp; node.children.length) {
 for (ii = 0; ii &lt; node.children.length; ii += 1) {
 stack.push(node.children[ii]);
 }
 }
}

// Didn't find it. Return null.
return null;
</code></pre>

blocks|key|445008|text|下面是我的工作内容：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|445009|function+searchTree(data,+value)+{
if(data.title+==+value)+{
++++return+data;
}
if(data.children+&&+data.children.length+>+0)+{
++++for(var+i=0;+i+<+data.children.length;+i%2B%2B)+{
++++++++var+node+=+traverseChildren(data.children[i],+value);
++++++++if(node+!=+null)+{
++++++++++++return+node;
++++++++}
++++}
}
return+null;|code-block|syntax|javascript|445010|}|445011|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

The following is working at my end:

<pre><code>function searchTree(data, value) {
if(data.title == value) {
 return data;
}
if(data.children &amp;&amp; data.children.length &gt; 0) {
 for(var i=0; i &lt; data.children.length; i++) {
 var node = traverseChildren(data.children[i], value);
 if(node != null) {
 return node;
 }
 }
}
return null;
</code></pre>

}

blocks|key|659423|text|我的答案是从FishBasketGordo的迭代式答案中获得的灵感。它有点复杂，但也更灵活，您可以有多个根节点。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|659424|/**searchs+through+all+arrays+of+the+tree+if+the+for+a+value+from+a+property
+*+@param+aTree+:+the+tree+array
+*+@param+fCompair+:+This+function+will+receive+each+node.+It's+upon+you+to+define+which+
+++++++++++++++++++++condition+is+necessary+for+the+match.+It+must+return+true+if+the+condition+is+matched.+Example:
++++++++++++++++++++++++function(oNode){+if(oNode["Name"]+===+"AA")+return+true;+}
+*+@param+bGreedy?+:+us+true+to+do+not+stop+after+the+first+match,+default+is+false
+*+@return+an+array+with+references+to+the+nodes+for+which+fCompair+was+true;+In+case+no+node+was+found+an+empty+array
+*+++++++++will+be+returned
*/
var+_searchTree+=+function(aTree,+fCompair,+bGreedy){
++++var+aInnerTree+=+[];+//+will+contain+the+inner+children
++++var+oNode;+//+always+the+current+node
++++var+aReturnNodes+=+[];+//+the+nodes+array+which+will+returned

++++//+1.+loop+through+all+root+nodes+so+we+don't+touch+the+tree+structure
++++for(keysTree+in+aTree)+{
++++++++aInnerTree.push(aTree[keysTree]);
++++}
++++while(aInnerTree.length+>+0)+{
++++++++oNode+=+aInnerTree.pop();
++++++++//+check+current+node
++++++++if(+fCompair(oNode)+){
++++++++++++aReturnNodes.push(oNode);
++++++++++++if(!bGreedy){
++++++++++++++++return+aReturnNodes;
++++++++++++}
++++++++}+else+{+//+if+(node.children+&&+node.children.length)+{
++++++++++++//+find+other+objects,+1.+check+all+properties+of+the+node+if+they+are+arrays
++++++++++++for(keysNode+in+oNode){
++++++++++++++++//+true+if+the+property+is+an+array
++++++++++++++++if(oNode[keysNode]+instanceof+Array){
++++++++++++++++++++//+2.+push+all+array+object+to+aInnerTree+to+search+in+those+later
++++++++++++++++++++for+(var+i+=+0;+i+<+oNode[keysNode].length;+i%2B%2B)+{
++++++++++++++++++++++++aInnerTree.push(oNode[keysNode][i]);
++++++++++++++++++++}
++++++++++++++++}
++++++++++++}
++++++++}
++++}
++++return+aReturnNodes;+//+someone+was+greedy
}|code-block|syntax|javascript|659425|最后，您可以像这样使用该函数：|659426|var+foundNodes+=+_searchTree(data,+function(oNode){+if(oNode["title"]+===+"randomNode_3")+return+true;+},+false);
console.log("Node+with+title+found:+");
console.log(foundNodes[0]);|659427|如果您想查找具有此标题的所有节点，您可以简单地切换bGreedy参数：|659428|var+foundNodes+=+_searchTree(data,+function(oNode){+if(oNode["title"]+===+"randomNode_3")+return+true;+},+true);
console.log("NodeS+with+title+found:+");
console.log(foundNodes);|659429|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

My answer is inspired from FishBasketGordo's iterativ answer. It's a little bit more complex but also much more flexible and you can have more than just one root node.

<pre><code>/**searchs through all arrays of the tree if the for a value from a property
 * @param aTree : the tree array
 * @param fCompair : This function will receive each node. It's upon you to define which 
 condition is necessary for the match. It must return true if the condition is matched. Example:
 function(oNode){ if(oNode["Name"] === "AA") return true; }
 * @param bGreedy? : us true to do not stop after the first match, default is false
 * @return an array with references to the nodes for which fCompair was true; In case no node was found an empty array
 * will be returned
*/
var _searchTree = function(aTree, fCompair, bGreedy){
 var aInnerTree = []; // will contain the inner children
 var oNode; // always the current node
 var aReturnNodes = []; // the nodes array which will returned

 // 1. loop through all root nodes so we don't touch the tree structure
 for(keysTree in aTree) {
 aInnerTree.push(aTree[keysTree]);
 }
 while(aInnerTree.length &gt; 0) {
 oNode = aInnerTree.pop();
 // check current node
 if( fCompair(oNode) ){
 aReturnNodes.push(oNode);
 if(!bGreedy){
 return aReturnNodes;
 }
 } else { // if (node.children &amp;&amp; node.children.length) {
 // find other objects, 1. check all properties of the node if they are arrays
 for(keysNode in oNode){
 // true if the property is an array
 if(oNode[keysNode] instanceof Array){
 // 2. push all array object to aInnerTree to search in those later
 for (var i = 0; i &lt; oNode[keysNode].length; i++) {
 aInnerTree.push(oNode[keysNode][i]);
 }
 }
 }
 }
 }
 return aReturnNodes; // someone was greedy
}
</code></pre>

Finally you can use the function like this:

<pre><code>var foundNodes = _searchTree(data, function(oNode){ if(oNode["title"] === "randomNode_3") return true; }, false);
console.log("Node with title found: ");
console.log(foundNodes[0]);
</code></pre>

And if you want to find all nodes with this title you can simply switch the bGreedy parameter:

<pre><code>var foundNodes = _searchTree(data, function(oNode){ if(oNode["title"] === "randomNode_3") return true; }, true);
console.log("NodeS with title found: ");
console.log(foundNodes);
</code></pre>

blocks|key|445104|text|这个函数是通用的，可以递归搜索。如果输入树是对象(单根)或对象数组(多个根对象)，这并不重要。您可以配置属性名称，以在树对象中保存子数组。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|445105|//+Searches+items+tree+for+object+with+specified+prop+with+value
//+
//+@param+{object}+tree+nodes+tree+with+children+items+in+nodesProp[]+table,+with+one+(object)+or+many+(array+of+objects)+roots
//+@param+{string}+propNodes+name+of+prop+that+holds+child+nodes+array
//+@param+{string}+prop+name+of+searched+node's+prop
//+@param+{mixed}+value+value+of+searched+node's++prop
//+@returns+{object/null}+returns+first+object+that+match+supplied+arguments+(prop:+value)+or+null+if+no+matching+object+was+found

function+searchTree(tree,+nodesProp,+prop,+value)+{
++var+i,+f+=+null;+//+iterator,+found+node
++if+(Array.isArray(tree))+{+//+if+entry+object+is+array+objects,+check+each+object
++++for+(i+=+0;+i+<+tree.length;+i%2B%2B)+{
++++++f+=+searchTree(tree[i],+nodesProp,+prop,+value);
++++++if+(f)+{+//+if+found+matching+object,+return+it.
++++++++return+f;
++++++}
++++}
++}+else+if+(typeof+tree+===+'object')+{+//+standard+tree+node+(one+root)
++++if+(tree[prop]+!==+undefined+&&+tree[prop]+===+value)+{
++++++return+tree;+//+found+matching+node
++++}
++}
++if+(tree[nodesProp]+!==+undefined+&&+tree[nodesProp].length+>+0)+{+//+if+this+is+not+maching+node,+search+nodes,+children+(if+prop+exist+and+it+is+not+empty)
++++return+searchTree(tree[nodesProp],+nodesProp,+prop,+value);
++}+else+{
++++return+null;+//+node+does+not+match+and+it+neither+have+children
++}
}|code-block|syntax|javascript|445106|我在本地测试了它，它工作得很好，但不知何故它不能在jsfiddle或jsbin上运行...(这些站点上的递归问题??)|445107|运行代码：|445108|++++var+data+=+[{
++++++title:+'topNode',
++++++children:+[{
++++++++title:+'node1',
++++++++children:+[{
++++++++++title:+'randomNode_1'
++++++++},+{
++++++++++title:+'node2',
++++++++++children:+[{
++++++++++++title:+'randomNode_2',
++++++++++++children:+[{
++++++++++++++title:+'node2',
++++++++++++++children:+[{
++++++++++++++++title:+'randomNode_3',
++++++++++++++}]
++++++++++++}]
++++++++++}]
++++++++}]
++++++}]
++++}];

++++var+r+=+searchTree(data,+'children',+'title',+'randomNode_1');
++++//var+r+=+searchTree(data,+'children',+'title',+'node2');++//+check+it+too
++++console.log(r);|445109|它可以在http://www.pythontutor.com/live.html#mode=edit中工作(粘贴代码)|offset|length|445110|entityMap|0|LINK|mutability|MUTABLE|url|http://www.pythontutor.com/live.html#mode=edit^0|0|0|0|0|0|4|1A|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|10|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|11|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|12|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|13|8|@]|9|@$O|14|P|15|1|16]]|A|$]]|$1|Q|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|X]]]]

This function is universal and does search recursively.
It does not matter, if input tree is object(single root), or array of objects (many root objects). You can configure prop name that holds children array in tree objects.

<pre><code>// Searches items tree for object with specified prop with value
// 
// @param {object} tree nodes tree with children items in nodesProp[] table, with one (object) or many (array of objects) roots
// @param {string} propNodes name of prop that holds child nodes array
// @param {string} prop name of searched node's prop
// @param {mixed} value value of searched node's prop
// @returns {object/null} returns first object that match supplied arguments (prop: value) or null if no matching object was found

function searchTree(tree, nodesProp, prop, value) {
 var i, f = null; // iterator, found node
 if (Array.isArray(tree)) { // if entry object is array objects, check each object
 for (i = 0; i &lt; tree.length; i++) {
 f = searchTree(tree[i], nodesProp, prop, value);
 if (f) { // if found matching object, return it.
 return f;
 }
 }
 } else if (typeof tree === 'object') { // standard tree node (one root)
 if (tree[prop] !== undefined &amp;&amp; tree[prop] === value) {
 return tree; // found matching node
 }
 }
 if (tree[nodesProp] !== undefined &amp;&amp; tree[nodesProp].length &gt; 0) { // if this is not maching node, search nodes, children (if prop exist and it is not empty)
 return searchTree(tree[nodesProp], nodesProp, prop, value);
 } else {
 return null; // node does not match and it neither have children
 }
}
</code></pre>

I tested it localy and it works ok, but it somehow won't run on jsfiddle or jsbin...(recurency issues on those sites ??)

run code :

<pre><code> var data = [{
 title: 'topNode',
 children: [{
 title: 'node1',
 children: [{
 title: 'randomNode_1'
 }, {
 title: 'node2',
 children: [{
 title: 'randomNode_2',
 children: [{
 title: 'node2',
 children: [{
 title: 'randomNode_3',
 }]
 }]
 }]
 }]
 }]
 }];

 var r = searchTree(data, 'children', 'title', 'randomNode_1');
 //var r = searchTree(data, 'children', 'title', 'node2'); // check it too
 console.log(r);
</code></pre>

It works in <a href="http://www.pythontutor.com/live.html#mode=edit" rel="nofollow noreferrer">http://www.pythontutor.com/live.html#mode=edit</a> (paste the code)

blocks|key|659522|text|灵活的递归解决方案，适用于任何树|type|unstyled|depth|inlineStyleRanges|entityRanges|data|659523|//+predicate:+(item)+=>+boolean
//+getChildren:+(item)+=>+treeNode[]
searchTree(predicate,+getChildren,+treeNode)+{
++++++++function+search(treeNode)+{
++++++++++++if+(!treeNode)+{
++++++++++++++++return+undefined;
++++++++++++}

++++++++++++for+(let+treeItem+of+treeNode)+{
++++++++++++++++if+(predicate(treeItem))+{
++++++++++++++++++++return+treeItem;
++++++++++++++++}

++++++++++++++++const+foundItem+=+search(getChildren(treeItem));

++++++++++++++++if+(foundItem)+{
++++++++++++++++++++return+foundItem;
++++++++++++++++}
++++++++++++}
++++++++}

++++++++return+search(treeNode);
++++}|code-block|syntax|javascript|659524|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

A flexible recursive solution that will work for any tree

<pre><code>// predicate: (item) =&gt; boolean
// getChildren: (item) =&gt; treeNode[]
searchTree(predicate, getChildren, treeNode) {
 function search(treeNode) {
 if (!treeNode) {
 return undefined;
 }

 for (let treeItem of treeNode) {
 if (predicate(treeItem)) {
 return treeItem;
 }

 const foundItem = search(getChildren(treeItem));

 if (foundItem) {
 return foundItem;
 }
 }
 }

 return search(treeNode);
 }
</code></pre>

blocks|key|445157|text|在树中查找元素的所有父项|type|unstyled|depth|inlineStyleRanges|entityRanges|data|445158|let+objects+=+[{
++++++id:+'A',
++++++name:+'ObjA',
++++++children:+[
++++++++{
++++++++++id:+'A1',
++++++++++name:+'ObjA1'
++++++++},
++++++++{
++++++++++id:+'A2',
++++++++++name:+'objA2',
++++++++++children:+[
++++++++++++{
++++++++++++++id:+'A2-1',
++++++++++++++name:+'objA2-1'
++++++++++++},
++++++++++++{
++++++++++++++id:+'A2-2',
++++++++++++++name:+'objA2-2'
++++++++++++}
++++++++++]
++++++++}
++++++]
++++},
++++{
++++++id:+'B',
++++++name:+'ObjB',
++++++children:+[
++++++++{
++++++++++id:+'B1',
++++++++++name:+'ObjB1'
++++++++}
++++++]
++++}
++++];

let+docs+=+[
++{

++++object:+{
++++++id:+'A',
++++++name:+'docA'
++++},
++++typedoc:+{
++++++id:+'TD1',
++++++name:+'Typde+Doc1'
++++}
++},
++{

++++object:+{
++++++id:+'A',
++++++name:+'docA'
++++},
++++typedoc:+{
++++++id:+'TD2',
++++++name:+'Typde+Doc2'
++++}
++},
++{

++++object:+{
++++++id:+'A1',
++++++name:+'docA1'
++++},
++++typedoc:+{
++++++id:+'TDx1',
++++++name:+'Typde+Doc+x1'
++++}
++},
++{

++++object:+{
++++++id:+'A1',
++++++name:+'docA1'
++++},
++++typedoc:+{
++++++id:+'TDx2',
++++++name:+'Typde+Doc+x1'
++++}
++},
++{

++++object:+{
++++++id:+'A2',
++++++name:+'docA2'
++++},
++++typedoc:+{
++++++id:+'TDx2',
++++++name:+'Type+de+Doc+x2'
++++}
++},
++{

++++object:+{
++++++id:+'A2-1',
++++++name:+'docA2-1'
++++},
++++typedoc:+{
++++++id:+'TDx2-1',
++++++name:+'Type+de+Docx2-1'
++++},
++},
++{

++++object:+{
++++++id:+'A2-2',
++++++name:+'docA2-2'
++++},
++++typedoc:+{
++++++id:+'TDx2-2',
++++++name:+'Type+de+Docx2-2'
++++},
++},
++{

++++object:+{
++++++id:+'B',
++++++name:+'docB'
++++},
++++typedoc:+{
++++++id:+'TD1',
++++++name:+'Typde+Doc1'
++++}
++},
++{

++++object:+{
++++++id:+'B1',
++++++name:+'docB1'
++++},
++++typedoc:+{
++++++id:+'TDx1',
++++++name:+'Typde+Doc+x1'
++++}

++}
];



function+buildAllParents(doc,+objects)+{
++++for+(let+o+=+0;+o+<+objects.length;+o%2B%2B)+{
++++++let+allParents+=+[];
++++++let+getAllParents+=+(o,+eleFinded)+=>+{
++++++++if+(o.id+===+doc.object.id)+{
++++++++++doc.allParents+=+allParents;
++++++++++eleFinded+=+true;
++++++++++return+{+doc,+eleFinded+};
++++++++}
++++++++if+(o.children)+{
++++++++++allParents.push(o.id);
++++++++++for+(let+c+=+0;+c+<+o.children.length;+c%2B%2B)+{
++++++++++++let+{+eleFinded,+doc+}+=+getAllParents(o.children[c],+eleFinded);
++++++++++++if+(eleFinded)+{
++++++++++++++return+{+eleFinded,+doc+};
++++++++++++}+else+{
++++++++++++++continue;
++++++++++++}
++++++++++}

++++++++}
++++++++return+{+eleFinded+};
++++++};
++++++if+(objects[o].id+===+doc.object.id)+{
++++++++doc.allParents+=+[objects[o].id];
++++++++return+doc;
++++++}+else+if+(objects[o].children)+{
++++++++allParents.push(objects[o].id);
++++++++for+(let+c+=+0;+c+<+objects[o].children.length;+c%2B%2B)+{
++++++++++let+eleFinded+=+null;`enter+code+here`
++++++++++let+res+=+getAllParents(objects[o].children[c],+eleFinded);
++++++++++if+(res.eleFinded)+{
++++++++++++return+res.doc;
++++++++++}+else+{
++++++++++++continue;
++++++++++}
++++++++}
++++++}

++++}
++}

docs+=+docs.map(d+=>+buildAllParents(d,+objects`enter+code+here`))|code-block|syntax|javascript|445159|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

find all parents of the element in the tree 

<pre><code>let objects = [{
 id: 'A',
 name: 'ObjA',
 children: [
 {
 id: 'A1',
 name: 'ObjA1'
 },
 {
 id: 'A2',
 name: 'objA2',
 children: [
 {
 id: 'A2-1',
 name: 'objA2-1'
 },
 {
 id: 'A2-2',
 name: 'objA2-2'
 }
 ]
 }
 ]
 },
 {
 id: 'B',
 name: 'ObjB',
 children: [
 {
 id: 'B1',
 name: 'ObjB1'
 }
 ]
 }
 ];

let docs = [
 {

 object: {
 id: 'A',
 name: 'docA'
 },
 typedoc: {
 id: 'TD1',
 name: 'Typde Doc1'
 }
 },
 {

 object: {
 id: 'A',
 name: 'docA'
 },
 typedoc: {
 id: 'TD2',
 name: 'Typde Doc2'
 }
 },
 {

 object: {
 id: 'A1',
 name: 'docA1'
 },
 typedoc: {
 id: 'TDx1',
 name: 'Typde Doc x1'
 }
 },
 {

 object: {
 id: 'A1',
 name: 'docA1'
 },
 typedoc: {
 id: 'TDx2',
 name: 'Typde Doc x1'
 }
 },
 {

 object: {
 id: 'A2',
 name: 'docA2'
 },
 typedoc: {
 id: 'TDx2',
 name: 'Type de Doc x2'
 }
 },
 {

 object: {
 id: 'A2-1',
 name: 'docA2-1'
 },
 typedoc: {
 id: 'TDx2-1',
 name: 'Type de Docx2-1'
 },
 },
 {

 object: {
 id: 'A2-2',
 name: 'docA2-2'
 },
 typedoc: {
 id: 'TDx2-2',
 name: 'Type de Docx2-2'
 },
 },
 {

 object: {
 id: 'B',
 name: 'docB'
 },
 typedoc: {
 id: 'TD1',
 name: 'Typde Doc1'
 }
 },
 {

 object: {
 id: 'B1',
 name: 'docB1'
 },
 typedoc: {
 id: 'TDx1',
 name: 'Typde Doc x1'
 }

 }
];



function buildAllParents(doc, objects) {
 for (let o = 0; o &lt; objects.length; o++) {
 let allParents = [];
 let getAllParents = (o, eleFinded) =&gt; {
 if (o.id === doc.object.id) {
 doc.allParents = allParents;
 eleFinded = true;
 return { doc, eleFinded };
 }
 if (o.children) {
 allParents.push(o.id);
 for (let c = 0; c &lt; o.children.length; c++) {
 let { eleFinded, doc } = getAllParents(o.children[c], eleFinded);
 if (eleFinded) {
 return { eleFinded, doc };
 } else {
 continue;
 }
 }

 }
 return { eleFinded };
 };
 if (objects[o].id === doc.object.id) {
 doc.allParents = [objects[o].id];
 return doc;
 } else if (objects[o].children) {
 allParents.push(objects[o].id);
 for (let c = 0; c &lt; objects[o].children.length; c++) {
 let eleFinded = null;`enter code here`
 let res = getAllParents(objects[o].children[c], eleFinded);
 if (res.eleFinded) {
 return res.doc;
 } else {
 continue;
 }
 }
 }

 }
 }

docs = docs.map(d =&gt; buildAllParents(d, objects`enter code here`))
</code></pre>

blocks|key|445243|text|这里有一个更复杂的选项-它通过提供(节点、nodeChildrenKey、键/值对和可选的附加键/值对)来查找树状节点中的第一项。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|445244|const+findInTree+=+(node,+childrenKey,+key,+value,++additionalKey?,+additionalValue?)+=>+{
++let+found+=+null;
++if+(additionalKey+&&+additionalValue)+{
++++found+=+node[childrenKey].find(x+=>+x[key]+===+value+&&+x[additionalKey]+===+additionalValue);
++}+else+{
++++found+=+node[childrenKey].find(x+=>+x[key]+===+value);
++}
++if+(typeof(found)+===+'undefined')+{
++++for+(const+item+of+node[childrenKey])+{
++++++if+(typeof(found)+===+'undefined'+&&+item[childrenKey]+&&+item[childrenKey].length+>+0)+{
++++++++found+=+findInTree(item,+childrenKey,+key,+value,+additionalKey,+additionalValue);
++++++}
++++}
++}
++return+found;
};

export+{+findInTree+};|code-block|syntax|javascript|445245|希望这能帮助到别人。|445246|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

here is a more complex option - it finds the first item in a tree-like node with providing (node, nodeChildrenKey, key/value pairs &amp; optional additional key/value pairs)

<pre><code>const findInTree = (node, childrenKey, key, value, additionalKey?, additionalValue?) =&gt; {
 let found = null;
 if (additionalKey &amp;&amp; additionalValue) {
 found = node[childrenKey].find(x =&gt; x[key] === value &amp;&amp; x[additionalKey] === additionalValue);
 } else {
 found = node[childrenKey].find(x =&gt; x[key] === value);
 }
 if (typeof(found) === 'undefined') {
 for (const item of node[childrenKey]) {
 if (typeof(found) === 'undefined' &amp;&amp; item[childrenKey] &amp;&amp; item[childrenKey].length &gt; 0) {
 found = findInTree(item, childrenKey, key, value, additionalKey, additionalValue);
 }
 }
 }
 return found;
};

export { findInTree };
</code></pre>

Hope it helps someone.

blocks|key|659685|text|这是一种迭代的广度优先搜索。它返回包含给定名称(nodeName)和给定值(nodeValue)的子节点的第一个节点。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|659686|getParentNode(nodeName,+nodeValue,+rootNode)+{
++++const+queue=+[+rootNode+]
++++while+(queue.length)+{
++++++++const+node+=+queue.shift()
++++++++if+(node[nodeName]+===+nodeValue)+{
++++++++++++return+node
++++++++}+else+if+(node+instanceof+Object)+{
++++++++++++const+children+=+Object.values(node)
++++++++++++if+(children.length)+{
++++++++++++++++queue.push(...children)
++++++++++++}
++++++++}
++++}
++++return+null
}|code-block|syntax|javascript|659687|它将像这样用来解决最初的问题：|659688|getParentNode('title',+'randomNode_1',+data[0])|659689|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

This is an iterative breadth first search. It returns the first node that contains a child of a given name (nodeName) and a given value (nodeValue).

<pre><code>getParentNode(nodeName, nodeValue, rootNode) {
 const queue= [ rootNode ]
 while (queue.length) {
 const node = queue.shift()
 if (node[nodeName] === nodeValue) {
 return node
 } else if (node instanceof Object) {
 const children = Object.values(node)
 if (children.length) {
 queue.push(...children)
 }
 }
 }
 return null
}
</code></pre>

It would be used like this to solve the original question:

<pre><code>getParentNode('title', 'randomNode_1', data[0])
</code></pre>

blocks|key|659700|text|ES6%2B：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|659701|const+deepSearch+=+(data,+value,+key+=+'title',+sub+=+'children',+tempObj+=+{})+=>+{
++++if+(value+&&+data)+{
++++++++data.find((node)+=>+{
++++++++++++if+(node[key]+==+value)+{
++++++++++++++++tempObj.found+=+node;
++++++++++++++++return+node;
++++++++++++}
++++++++++++return+deepSearch(node[sub],+value,+key,+sub,+tempObj);
++++++++});
++++++++if+(tempObj.found)+{
++++++++++++return+tempObj.found;
++++++++}
++++}
++++return+false;
};

const+result+=+deepSearch(data,+'randomNode_1',+'title',+'children');|code-block|syntax|javascript|659702|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

ES6+:

<pre><code>const deepSearch = (data, value, key = 'title', sub = 'children', tempObj = {}) =&gt; {
 if (value &amp;&amp; data) {
 data.find((node) =&gt; {
 if (node[key] == value) {
 tempObj.found = node;
 return node;
 }
 return deepSearch(node[sub], value, key, sub, tempObj);
 });
 if (tempObj.found) {
 return tempObj.found;
 }
 }
 return false;
};

const result = deepSearch(data, 'randomNode_1', 'title', 'children');
</code></pre>

blocks|key|659735|text|无BS版本：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|659736|const+find+=+(root,+title)+=>+
++root.title+===+title+?
++++root+:
++++root.children?.reduce((result,+n)+=>+result+%7C%7C+find(n,+title),+undefined)|code-block|syntax|javascript|659737|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

no BS version:
<pre><code>const find = (root, title) =&gt; 
 root.title === title ?
 root :
 root.children?.reduce((result, n) =&gt; result || find(n, title), undefined)
</code></pre>

I have and object literal that is essentially a tree that does not have a fixed number of levels. How can I go about searching the tree for a particualy node and then return that node when found in an effcient manner in javascript?

Essentially I have a tree like this and would like to find the node with the title 'randomNode_1'

<pre><code>var data = [
{
title: 'topNode',
 children: [
 {
 title: 'node1',
 children: [
 {
 title: 'randomNode_1'
 },
 { 
 title: 'node2',
 children: [
 {
 title: 'randomNode_2',
 children:[
 { 
 title: 'node2',
 children: [
 {
 title: 'randomNode_3',
 }]
 }
 ]
 }]
 }]
 }
 ]
 }];
</code></pre>

How to find a node in a tree with JavaScript

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我有一个对象字面量，它本质上是一个没有固定层数的树。如何在树中搜索特定的节点，然后在javascript中以有效的方式返回该节点？实际上，我有一个这样的树，希望找到标题为“randomNode_1”的节点。var data = [{title: 'topNode', children: [   {       titl...

问如何使用JavaScript在树中查找节点
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何使用JavaScript在树中查找节点EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何使用JavaScript在树中查找节点
EN