Wie zu erkennen HTMLCollection/NodeList in JavaScript?

Ich bin nicht sicher, dass meine aktuellen Implementierung zur Verfügung steht die ganze Zeit:

function isNodeList(nodes) {
    var result = Object.prototype.toString.call(nodes);
    //modern browser such as IE9 /firefox /chrome etc.
    if (result === '[object HTMLCollection]' || result === '[object NodeList]') {
        return true;
    }
    //ie 6/7/8
    if (typeof(nodes) != 'object') {
        return false;
    }
    //detect length and item 
    if (!('length' in nodes) || !('item' in nodes)) {
        return false;
    }
    //use the trick NodeList(index),all browsers support
    try {
        if (nodes(0) === null || (nodes(0) && nodes(0).tagName)) return true;
    }
    catch (e) {
        return false;
    }
    return false;
}

Einer gemeinsamen situation ist {Länge:1,Artikelnummer:function(){return [];}}
Der Wert von Ergebnis, in chrome /safari /opera '[object NodeList]'.
In firefox und IE 9 , es ist '[object HTMLCollection]'.

Den standard-Wert?

Wie um zu überprüfen, ob ein Objekt eine Instanz einer NodeList im IE?
Ball -- typeof Knoten.item gibt 'Zeichenfolge' im ie6,nicht 'funktionieren'.also brauchen wir den Nachweis.

InformationsquelleAutor simon xu | 2011-08-30

javascript

30

Den folgenden zurückkehren sollte wahr, wenn der Knoten vom Typ NodeList
```
NodeList.prototype.isPrototypeOf(nodes)
```
@DavidSpector, für HTMLCollection können Sie ebenso verwenden :
```
HTMLCollection.prototype.isPrototypeOf(collection)
```
dies ist eine gute Antwort.
Ja, aber das beantwortet nicht die Frage: wie erkennen Sie, ob ein Objekt eine HTML-Collection.

InformationsquelleAutor vineethbc
22

Ich würde die Struktur der code anders:
```
function isNodeList(nodes) {
    var stringRepr = Object.prototype.toString.call(nodes);

    return typeof nodes === 'object' &&
        /^\[object (HTMLCollection|NodeList|Object)\]$/.test(stringRepr) &&
        (typeof nodes.length === 'number') &&
        (nodes.length === 0 || (typeof nodes[0] === "object" && nodes[0].nodeType > 0));
}
```
Hinweise:
- weniger Rückweg machen, einfacher lesbaren code
- - stick mit einer Art von Logik, wenn möglich (D. H. mit weniger negiert überprüft)
- "item" ist nicht zwingend in eine nodeList
- verwenden hasOwnProperty() statt in
- mit den eckigen Klammern um den index in die Liste
- Ich glaube nicht, dass ein try/catch ist wirklich notwendig, aber das könnte falsch sein - Sie entscheiden
- check für nodeType statt tagName als text-Knoten oder Kommentare haben nicht einen Namen
- mehr hinzufügen, prüft der && Kette, wenn Sie sehen, passen
gelegentlich diese Fehlermeldung bekommen live: '0.nodeType' is null or not an object . jede Idee, was könnte den Tisch gefallen?
dies sollte nun funktionieren, versuchen Sie es erneut.
warum haben sogar die Rückgabe true/false... einfach nur wieder den Wert, den Sie testen wollen, in der wenn. D. H. entfernen der if-Anweisung + zurück und ersetzen Sie es mit return.
nodes.hasOwnProperty('length') Rückgabe von false in Chrome für mich. vielleicht typeof nodes.length === 'number' ist besser?
Ja, das klappte zu der Zeit, aber anscheinend ändern sich die Dinge. Ich modifiziert habe meine Antwort dementsprechend, vielen Dank für das heads-up.

InformationsquelleAutor Tomalak

Skript:

Element.prototype.isNodeList = function() {return false;}
NodeList.prototype.isNodeList = HTMLCollection.prototype.isNodeList = function(){return true;}

Einsatz, wie dies:

var d; //HTMLCollection|NodeList|Element
if(d.isNodeList()){
  /*
    it is HTMLCollection or NodeList
    write your code here
  */
}else{
  /*
    it is not HTMLCollection and NodeList
    write your code here
  */
}

dies ist ein netter trick

InformationsquelleAutor Guja1501

8

Hier ist, wie um zu testen, ob ein Objekt ist eine NodeList in modernen Browsern:
```
if (nodes instanceof NodeList) {
  //It's a NodeList object
}
```
Sehr langsame Methode, die durch die Art und Weise.
warum ist das so?

InformationsquelleAutor rosell.dk
6

Überprüfen, ob variable eine HTMLcollection oder ein dom-element
```
  var foo = document.getElementById('mydiv');
  var foo2 = document.getElementsByClassName('divCollection');
  console.log(foo instanceof HTMLElement);
  console.log(foo instanceof HTMLCollection);
```
Ich hoffe, das hilft.
Danke! Ja, es hilft! Wie kann ich prüfen, ob es nicht instanceof HTMLCollection? Wo lege ich das (!) Ausrufezeichen?
Die gute Lösung... danke. @Horay Wahrscheinlich ist es zu spät, aber... if (!(Sachen instanceof)) { ... }

InformationsquelleAutor koech
3

Diese Antwort ist wohl wirklich, wirklich spät, aber....
```
if (nodes == '[object NodeList]') {
  //It's a nodeList
}
```
Das funktioniert nicht im IE8, obwohl = ("[object object]"

InformationsquelleAutor Mohamed Moustafa
0

Erstellt habe ich eine Messlatte für alle Antworten hier, um zu sehen, was ist die beste genehmigen in der Geschwindigkeit. Stellt sich heraus NodeList.prototype.isPrototypeOf(nodes) ist bei weitem die Schnellste. Aber in einer normalen use-case nodes instanceof NodeList wäre auch in Ordnung.

Ich persönlich würde es nur nicht, Holen Sie das isNodeList Funktion, da seine langsame, Brauch und zu viel overhead.

Ich bekomme einen 404 auf Ihre benchmark-link...
Ich bevorzuge, wenn (!!Knoten.Länge) // true
Die überprüfung, ob length - Eigenschaft verfügbar ist, nichts gemein hat mit der überprüfung, ob eine variable ist eine Art von NodeList.

InformationsquelleAutor eisbehr

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.