मैं इस लूप को सभी बच्चों को बार-बार कैसे बना सकता हूं?

Question

मेरे पास निम्न है:

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

मैं इसे सभी बच्चों के बच्चों के माध्यम से लूप करना चाहता हूं (न केवल शीर्ष स्तर)। मुझे यह लाइन मिली, जो ऐसा लगता है:

for(var m = n.firstChild; m != null; m = m.nextSibling) { 

लेकिन मैं अस्पष्ट हूं कि अगर मैं उस स्विच को चालू करता हूं तो मैं वर्तमान बच्चे को कैसे संदर्भित करता हूं? अब मुझे बच्चे की सूचकांक स्थिति को स्पष्ट करने के लिए नहीं होगा। कोई सुझाव?

धन्यवाद!

अद्यतन:

मैं अब उत्तर सुझावों के अनुसार निम्नलिखित का उपयोग कर रहा हूं। क्या ऐसा करने का यह सही/सबसे प्रभावी तरीका है?

function removeTest(child) { 
    if (hasClass(child, "lbExclude")) { 
    child.parentNode.removeChild(child); 
    } 
} 

function allDescendants(node) { 
    for (var i = 0; i < node.childNodes.length; i++) { 
    var child = node.childNodes[i]; 
    allDescendants(child); 
    removeTest(child); 
    } 
} 

var children = temp.childNodes; 
for (var i = 0; i < children.length; i++) { 
    allDescendants(children[i]); 
}; 

Answer 1

आम तौर पर आपके पास एक ऐसा कार्य होता है जिसे सभी नोड्स पर रिकर्सिवली कहा जा सकता है। यह वास्तव में इस बात पर निर्भर करता है कि आप बच्चों के साथ क्या करना चाहते हैं। यदि आप बस सभी वंशजों को इकट्ठा करना चाहते हैं, तो element.getElementsByTagName एक बेहतर विकल्प हो सकता है।

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

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

Answer 2

function allDescendants (node) { 
    for (var i = 0; i < node.childNodes.length; i++) { 
     var child = node.childNodes[i]; 
     allDescendants(child); 
     doSomethingToNode(child); 
    } 
} 

सभी बच्चों से अधिक

आप पाश, और प्रत्येक तत्व के लिए, आप एक ही समारोह फोन है और यह उस तत्व का बच्चों पर पाश की है।

Answer 3

सभी बच्चों पर 'allDescendants' विधि फोन करने के लिए कोई ज़रूरत नहीं है, क्योंकि विधि ही पहले से ही है कि नहीं करता है। तो पिछले codeblock को हटा दें और मुझे लगता है कि एक उचित समाधान है (एक, The नहीं =])

  function removeTest(child){  
       if(hasClass(child, "lbExclude")){ 
        child.parentNode.removeChild(child); 
       } 
      } 

      function allDescendants (node) { 
       for (var i = 0; i < node.childNodes.length; i++) { 
        var child = node.childNodes[i]; 
        allDescendants(child); 
        removeTest(child); 
       } 
      }   

      var children = allDescendants(temp); 

Answer 4

आप एक js पुस्तकालय का उपयोग करते हैं यह इस रूप में सरल है: यदि आप अन्यथा

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

एक नोड के अंतर्गत सभी तत्वों को हासिल करना चाहते हैं तो आप उन सभी मूल रूप से एकत्र कर सकते हैं: आप jQuery है और आप सभी वंशज तत्वों प्राप्त करना चाहते हैं

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

Answer 5

आप का उपयोग कर सकते हैं:

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

बस ध्यान रखें कि all_children एक HTML संग्रह है और एक सरणी नहीं है। जब आप बस लूपिंग करते हैं, तो वे समान व्यवहार करते हैं, लेकिन संग्रह में उपयोगी Array.prototype विधियों का बहुत अधिक उपयोग नहीं होता है, जिन्हें आप अन्यथा आनंद ले सकते हैं।

Answer 6

आप सभी तत्वों को खोजने के लिए बीएफएस का उपयोग कर सकते हैं।

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; 
}; 

यह फ़ंक्शन तत्व के सभी बच्चों के बच्चों को वापस देता है।