Javascript 如何递归地使这个循环所有子循环？

我有以下资料：

for (var i = 0; i < children.length; i++){
   if(hasClass(children[i], "lbExclude")){
       children[i].parentNode.removeChild(children[i]);
   }
};

但我不清楚，如果我做出这样的选择，我该如何称呼现在的孩子？我将不再需要我澄清孩子的索引位置。有什么建议吗

谢谢

更新：

根据答案建议，我现在使用以下内容。这是正确/最有效的方法吗

函数移除测试（子级）{
if（hasClass（子级，“lbExclude”））{
child.parentNode.removeChild（child）；
}
}
函数所有子体（节点）{
对于（var i=0；i

函数所有子体（节点）{
对于（var i=0；i

---

循环所有子元素，对于每个元素，调用相同的函数并使其循环到该元素的子元素。

通常，可以在所有节点上递归调用函数。这真的取决于你想对孩子们做什么。如果您只是想收集所有子体，那么

element.getElementsByTagName

可能是一个更好的选择

var all = node.getElementsByTagName('*');

for (var i = -1, l = all.length; ++i < l;) {
    removeTest(all[i]);
}

var all=node.getElementsByTagName（'*'）；
对于（变量i=-1，l=all.length；++i

不需要对所有子级调用“AllDescents”方法，因为该方法本身已经完成了这项工作。因此，删除最后一个代码块，我认为这是一个合适的解决方案（á，而不是thé=]）

函数移除测试（子项）{
if（hasClass（子级，“lbExclude”））{
child.parentNode.removeChild（child）；
}
}
函数所有子体（节点）{
对于（var i=0；i

如果您使用js库，它非常简单：

$('.lbExclude').remove();

否则，如果要获取节点下的所有元素，可以通过本机方式收集它们：

var nodes = node.getElementsByTagName('*');
for (var i = 0; i < nodes.length; i++) {
  var n = nodes[i];
  if (hasClass(n, 'lbExclude')) {
    node.parentNode.removeChild(node);
  }
}

var nodes=node.getElementsByTagName（'*'）；
对于（var i=0；i

如果您有jquery，并且希望获得所有可以使用的子元素：

 var all_children= $(parent_element).find('*');

---

请注意，

all_children

是一个HTML集合，而不是数组。在循环时，它们的行为类似，但集合中并没有很多有用的

数组
 您可以使用BFS查找所有元素

function(element) {
    // [].slice.call() - HTMLCollection to Array
    var children = [].slice.call(element.children), found = 0;
    while (children.length > found) {
        children = children.concat([].slice.call(children[found].children));
        found++;
    }
    return children;
};

此函数返回元素的所有子元素。
在现代浏览器或babel中，最清晰的方法就是这样做。假设您有一个HTML节点
$node
，您希望递归其子节点

Array.prototype.forEach.call($node.querySelectorAll("*"), function(node) {
  doSomethingWith(node);
});

任何DOM节点上的
querySelectorAll（'*'）
都会在
NodeList
中为您提供元素的所有子节点
NodeList
是一个类似于数组的对象，因此您可以使用
array.prototype.forEach.call
来迭代此列表，在回调中逐个处理每个子项。
如果在循环中创建项，则应通过id=”“data name或其他内容留下索引。然后，您可以直接为它们编制索引，这对于大多数函数（如（！-F））来说会更快。对于1024位x100项，效果非常好，具体取决于您的操作

if ( document.getElementById( cid ) ) {
 return;
} else {
  what you actually want
}

在大多数情况下，一旦项目已经加载，这将更快。仅在“重新加载”或“安全域传输/登录/cors”时拖动页面，然后执行两次操作。
要将所有子体作为数组获取，请使用以下命令：

function getAllDescendants(node) {
    var all = [];
    getDescendants(node);

    function getDescendants(node) {
        for (var i = 0; i < node.childNodes.length; i++) {
            var child = node.childNodes[i];
            getDescendants(child);
            all.push(child);
        }
    }
    return all;
}

函数getAllSubstands（节点）{
var all=[]；
获取子体（节点）；
函数getDescents（节点）{
对于（var i=0；i
您知道这里嵌套了多少个数组吗？只需输入名称
m
：
m.parentNode.removeChild（m）
。但是可能会有问题，因为删除一个节点，然后将其
下一个绑定
（在
for
子句中）将无法按预期工作。@coshman，嵌套子节点的数量将是可变的。@dirk我没有想到这一点。你有一个解决这个问题的建议方法吗？对不起，你能更明确地说明如何在我的例子中应用这个函数吗？我认为更现代的版本应该是
函数allsubstands（node）{node.childNodes.forEach（child=>{allsubstands（child）；doSomethingToNode（child）；}
这将只获取元素，而不是所有节点。但是它们是通过hasClass方法测试的，所以我相信它们打算将其作为元素。哎呀，没有看到@J-P的答案。
Array.prototype.forEach.call($node.querySelectorAll("*"), function(node) {
  doSomethingWith(node);
});

if ( document.getElementById( cid ) ) {
 return;
} else {
  what you actually want
}

function getAllDescendants(node) {
    var all = [];
    getDescendants(node);

    function getDescendants(node) {
        for (var i = 0; i < node.childNodes.length; i++) {
            var child = node.childNodes[i];
            getDescendants(child);
            all.push(child);
        }
    }
    return all;
}

TreeNode node = tv.SelectedNode;
while (node.Parent != null)
{
    node = node.Parent;
}                    
CallRecursive(node);


private void CallRecursive(TreeNode treeNode)`
{            
    foreach (TreeNode tn in treeNode.Nodes)
    {
        //Write whatever code here this function recursively loops through all nodes                 
        CallRecursive(tn);
    }
}