Gibt es in direktem Javascript (dh ohne Erweiterungen wie jQuery usw.) eine Möglichkeit, den Index eines untergeordneten Knotens innerhalb seines übergeordneten Knotens zu bestimmen, ohne alle untergeordneten Knoten zu durchlaufen und zu vergleichen?

Z.B,

var child = document.getElementById('my_element');
var parent = child.parentNode;
var childNodes = parent.childNodes;
var count = childNodes.length;
var child_index;
for (var i = 0; i < count; ++i) {
  if (child === childNodes[i]) {
    child_index = i;
    break;
  }
}

Gibt es eine bessere Möglichkeit, den Index des Kindes zu bestimmen?

Sie können die previousSiblingEigenschaft verwenden, um die Geschwister zu durchlaufen, bis Sie zurückkehren nullund zählen, wie viele Geschwister Sie angetroffen haben:

var i = 0;
while( (child = child.previousSibling) != null ) 
  i++;
//at the end i will contain the index.

Bitte beachten Sie, dass es in Sprachen wie Java eine getPreviousSibling()Funktion gibt, in JS ist dies jedoch eine Eigenschaft geworden - previousSibling.

Ich habe es gern benutzt indexOf. Weil eingeschaltet indexOfist Array.prototypeund ein parent.childrenist NodeList, muss man es verwenden. call();Es ist irgendwie hässlich, aber es ist ein Einzeiler und verwendet Funktionen, mit denen jeder Javascript-Entwickler sowieso vertraut sein sollte.

var child = document.getElementById('my_element');
var parent = child.parentNode;
// The equivalent of parent.children.indexOf(child)
var index = Array.prototype.indexOf.call(parent.children, child);

ES6:

Array.from(element.parentNode.children).indexOf(element)

Erklärung:

• element.parentNode.children→ Gibt die Brüder von elementeinschließlich dieses Elements zurück.

• Array.from→ Wirkt den Konstruktor childrenauf ein ArrayObjekt

• indexOf→ Sie können sich bewerben, indexOfweil Sie jetzt ein ArrayObjekt haben.

ES - kürzer

[...element.parentNode.children].indexOf(element);

Der Spread-Operator ist eine Abkürzung dafür

Hinzufügen eines (aus Sicherheitsgründen vorangestellten) Elements.getParentIndex ():

Element.prototype.PREFIXgetParentIndex = function() {
  return Array.prototype.indexOf.call(this.parentNode.children, this);
}

Ich gehe davon aus, dass bei einem Element, bei dem alle untergeordneten Elemente nacheinander im Dokument angeordnet sind, der schnellste Weg darin bestehen sollte, eine binäre Suche durchzuführen und die Dokumentpositionen der Elemente zu vergleichen. Wie in der Schlussfolgerung eingeführt, wird die Hypothese jedoch zurückgewiesen. Je mehr Elemente Sie haben, desto größer ist das Leistungspotenzial. Wenn Sie beispielsweise 256 Elemente hätten, müssten Sie (optimalerweise) nur 16 davon überprüfen! Für 65536 nur 256! Die Leistung wächst auf 2! Weitere Zahlen / Statistiken anzeigen. Besuchen Sie Wikipedia

(function(constructor){
   'use strict';
    Object.defineProperty(constructor.prototype, 'parentIndex', {
      get: function() {
        var searchParent = this.parentElement;
        if (!searchParent) return -1;
        var searchArray = searchParent.children,
            thisOffset = this.offsetTop,
            stop = searchArray.length,
            p = 0,
            delta = 0;

        while (searchArray[p] !== this) {
            if (searchArray[p] > this)
                stop = p + 1, p -= delta;
            delta = (stop - p) >>> 1;
            p += delta;
        }

        return p;
      }
    });
})(window.Element || Node);

Die Art und Weise, wie Sie es verwenden, besteht darin, die Eigenschaft 'parentIndex' eines beliebigen Elements abzurufen. Schauen Sie sich zum Beispiel die folgende Demo an.

(function(constructor){
   'use strict';
    Object.defineProperty(constructor.prototype, 'parentIndex', {
      get: function() {
        var searchParent = this.parentNode;
        if (searchParent === null) return -1;
        var childElements = searchParent.children,
            lo = -1, mi, hi = childElements.length;
        while (1 + lo !== hi) {
            mi = (hi + lo) >> 1;
            if (!(this.compareDocumentPosition(childElements[mi]) & 0x2)) {
                hi = mi;
                continue;
            }
            lo = mi;
        }
        return childElements[hi] === this ? hi : -1;
      }
    });
})(window.Element || Node);

output.textContent = document.body.parentIndex;
output2.textContent = document.documentElement.parentIndex;

Body parentIndex is <b id="output"></b><br />
documentElements parentIndex is <b id="output2"></b>

Einschränkungen

• Diese Implementierung der Lösung funktioniert in IE8 und darunter nicht.

Binäre VS Lineare Suche Auf 200.000 Elementen (könnte einige mobile Browser zum Absturz bringen, ACHTUNG!):

• In diesem Test werden wir sehen, wie lange es dauert, bis eine lineare Suche das mittlere Element im Vergleich zu einer binären Suche findet. Warum das mittlere Element? Da es sich am durchschnittlichen Standort aller anderen Standorte befindet, werden alle möglichen Standorte am besten dargestellt.

Binäre Suche

(function(constructor){
   'use strict';
    Object.defineProperty(constructor.prototype, 'parentIndexBinarySearch', {
      get: function() {
        var searchParent = this.parentNode;
        if (searchParent === null) return -1;
        var childElements = searchParent.children,
            lo = -1, mi, hi = childElements.length;
        while (1 + lo !== hi) {
            mi = (hi + lo) >> 1;
            if (!(this.compareDocumentPosition(childElements[mi]) & 0x2)) {
                hi = mi;
                continue;
            }
            lo = mi;
        }
        return childElements[hi] === this ? hi : -1;
      }
    });
})(window.Element || Node);
test.innerHTML = '<div> </div> '.repeat(200e+3);
// give it some time to think:
requestAnimationFrame(function(){
  var child=test.children.item(99.9e+3);
  var start=performance.now(), end=Math.round(Math.random());
  for (var i=200 + end; i-- !== end; )
    console.assert( test.children.item(
        Math.round(99.9e+3+i+Math.random())).parentIndexBinarySearch );
  var end=performance.now();
  setTimeout(function(){
    output.textContent = 'It took the binary search ' + ((end-start)*10).toFixed(2) + 'ms to find the 999 thousandth to 101 thousandth children in an element with 200 thousand children.';
    test.remove();
    test = null; // free up reference
  }, 125);
}, 125);

<output id=output> </output><br />
<div id=test style=visibility:hidden;white-space:pre></div>

Rückwärts (`lastIndexOf`) Lineare Suche

(function(t){"use strict";var e=Array.prototype.lastIndexOf;Object.defineProperty(t.prototype,"parentIndexLinearSearch",{get:function(){return e.call(t,this)}})})(window.Element||Node);
test.innerHTML = '<div> </div> '.repeat(200e+3);
// give it some time to think:
requestAnimationFrame(function(){
  var child=test.children.item(99e+3);
  var start=performance.now(), end=Math.round(Math.random());
  for (var i=2000 + end; i-- !== end; )
    console.assert( test.children.item(
        Math.round(99e+3+i+Math.random())).parentIndexLinearSearch );
  var end=performance.now();
  setTimeout(function(){
    output.textContent = 'It took the backwards linear search ' + (end-start).toFixed(2) + 'ms to find the 999 thousandth to 101 thousandth children in an element with 200 thousand children.';
    test.remove();
    test = null; // free up reference
  }, 125);
});

<output id=output> </output><br />
<div id=test style=visibility:hidden;white-space:pre></div>

Vorwärts (`indexOf`) Lineare Suche

(function(t){"use strict";var e=Array.prototype.indexOf;Object.defineProperty(t.prototype,"parentIndexLinearSearch",{get:function(){return e.call(t,this)}})})(window.Element||Node);
test.innerHTML = '<div> </div> '.repeat(200e+3);
// give it some time to think:
requestAnimationFrame(function(){
  var child=test.children.item(99e+3);
  var start=performance.now(), end=Math.round(Math.random());
  for (var i=2000 + end; i-- !== end; )
    console.assert( test.children.item(
        Math.round(99e+3+i+Math.random())).parentIndexLinearSearch );
  var end=performance.now();
  setTimeout(function(){
    output.textContent = 'It took the forwards linear search ' + (end-start).toFixed(2) + 'ms to find the 999 thousandth to 101 thousandth children in an element with 200 thousand children.';
    test.remove();
    test = null; // free up reference
  }, 125);
});

<output id=output> </output><br />
<div id=test style=visibility:hidden;white-space:pre></div>

PreviousElementSibling Counter Search

Zählt die Anzahl der PreviousElementS Geschwister, um den parentIndex abzurufen.

(function(constructor){
   'use strict';
    Object.defineProperty(constructor.prototype, 'parentIndexSiblingSearch', {
      get: function() {
        var i = 0, cur = this;
        do {
            cur = cur.previousElementSibling;
            ++i;
        } while (cur !== null)
        return i; //Returns 3
      }
    });
})(window.Element || Node);
test.innerHTML = '<div> </div> '.repeat(200e+3);
// give it some time to think:
requestAnimationFrame(function(){
  var child=test.children.item(99.95e+3);
  var start=performance.now(), end=Math.round(Math.random());
  for (var i=100 + end; i-- !== end; )
    console.assert( test.children.item(
        Math.round(99.95e+3+i+Math.random())).parentIndexSiblingSearch );
  var end=performance.now();
  setTimeout(function(){
    output.textContent = 'It took the PreviousElementSibling search ' + ((end-start)*20).toFixed(2) + 'ms to find the 999 thousandth to 101 thousandth children in an element with 200 thousand children.';
    test.remove();
    test = null; // free up reference
  }, 125);
});

<output id=output> </output><br />
<div id=test style=visibility:hidden;white-space:pre></div>

Keine Suche

Für das Benchmarking wäre das Ergebnis des Tests, wenn der Browser die Suche optimiert hätte.

test.innerHTML = '<div> </div> '.repeat(200e+3);
// give it some time to think:
requestAnimationFrame(function(){
  var start=performance.now(), end=Math.round(Math.random());
  for (var i=2000 + end; i-- !== end; )
    console.assert( true );
  var end=performance.now();
  setTimeout(function(){
    output.textContent = 'It took the no search ' + (end-start).toFixed(2) + 'ms to find the 999 thousandth to 101 thousandth children in an element with 200 thousand children.';
    test.remove();
    test = null; // free up reference
  }, 125);
});

<output id=output> </output><br />
<div id=test style=visibility:hidden></div>

Der Zusammenstoß

Nach dem Anzeigen der Ergebnisse in Chrome sind die Ergebnisse jedoch das Gegenteil von den erwarteten Ergebnissen. Die dümmer vorwärts gerichtete lineare Suche war überraschend 187 ms, 3850%, schneller als die binäre Suche. Offensichtlich hat Chrome das auf magische Weise überlistet console.assertund optimiert, oder (optimistischer) Chrome verwendet intern ein numerisches Indizierungssystem für das DOM, und dieses interne Indizierungssystem wird durch die Optimierungen verfügbar gemacht, die Array.prototype.indexOfbei der Verwendung auf ein HTMLCollectionObjekt angewendet werden.

Verwenden Sie den binären Suchalgorithmus , um die Leistung zu verbessern, wenn der Knoten Geschwister mit großer Anzahl hat.

function getChildrenIndex(ele){
    //IE use Element.sourceIndex
    if(ele.sourceIndex){
        var eles = ele.parentNode.children;
        var low = 0, high = eles.length-1, mid = 0;
        var esi = ele.sourceIndex, nsi;
        //use binary search algorithm
        while (low <= high) {
            mid = (low + high) >> 1;
            nsi = eles[mid].sourceIndex;
            if (nsi > esi) {
                high = mid - 1;
            } else if (nsi < esi) {
                low = mid + 1;
            } else {
                return mid;
            }
        }
    }
    //other browsers
    var i=0;
    while(ele = ele.previousElementSibling){
        i++;
    }
    return i;
}

Ich hatte ein Problem mit Textknoten und es wurde ein falscher Index angezeigt. Hier ist die Version, um das Problem zu beheben.

function getChildNodeIndex(elem)
{   
    let position = 0;
    while ((elem = elem.previousSibling) != null)
    {
        if(elem.nodeType != Node.TEXT_NODE)
            position++;
    }

    return position;
}

Object.defineProperties(Element.prototype,{
group : {
    value: function (str, context) {
        // str is valid css selector like :not([attr_name]) or .class_name
        var t = "to_select_siblings___";
        var parent = context ? context : this.parentNode;
        parent.setAttribute(t, '');
        var rez = document.querySelectorAll("[" + t + "] " + (context ? '' : ">") + this.nodeName + (str || "")).toArray();
        parent.removeAttribute(t);            
        return rez;  
    }
},
siblings: {
    value: function (str, context) {
        var rez=this.group(str,context);
        rez.splice(rez.indexOf(this), 1);
        return rez; 
    }
},
nth: {  
    value: function(str,context){
       return this.group(str,context).indexOf(this);
    }
}
}

Ex

/* html */
<ul id="the_ul">   <li></li> ....<li><li>....<li></li>   </ul>

 /*js*/
 the_ul.addEventListener("click",
    function(ev){
       var foo=ev.target;
       foo.setAttribute("active",true);
       foo.siblings().map(function(elm){elm.removeAttribute("active")});
       alert("a click on li" + foo.nth());
     });

Könnten Sie so etwas tun:

var index = Array.prototype.slice.call(element.parentElement.children).indexOf(element);

https://developer.mozilla.org/en-US/docs/Web/API/Node/parentElement

<body>
    <section>
        <section onclick="childIndex(this)">child a</section>
        <section onclick="childIndex(this)">child b</section>
        <section onclick="childIndex(this)">child c</section>
    </section>
    <script>
        function childIndex(e){
            let i = 0;
            while (e.parentNode.children[i] != e) i++;
            alert('child index '+i);
        }
    </script>
</body>