Websiteentwicklung: JavaScript: DOM-Kern

Aus Wikibooks
Zur Navigation springen Zur Suche springen

Inhaltsverzeichnis

Der Kern des Dokument-Objekt-Modells (DOM-Core)[Bearbeiten]

Während der ECMA-Standard eher die Grundfunktionen einer Skriptsprache wie ECMA-script oder JavaScript beschreibt, beschreibt das Dokument-Objekt-Modell (DOM) den Aufbau von Dokumenten, beziehungsweise schlägt ein abstraktes Modell vor, mit welchem Darstellungsprogramme Dokumente intern repräsentieren können. Über das DOM kann dann auf Strukturen dieser Repräsentation zugegriffen werden und diese Strukturen können bei Bedarf geändert werden. Ein DOM-fähiges Darstellungsprogramm oder allgemeiner DOM-fähiges Programm wird also zur Interpretation eines Dokumentes eine solche Objekt-Repräsentation verwenden, um das Dokument zu präsentieren. Ein Skript, welches das DOM manipuliert, kann also ähnlich wie eine CSS-Datei oder eine XSL(T)-Datei als eine Stilvorlage interpretiert werden, mit welcher man allerdings praktisch alles an der Präsentation ändern kann. Die daraus resultierende Präsentation muß dann nicht mehr zwangsläufig etwas mit dem Inhalt des ursprünglichen Dokumentes zu tun haben, woraus besondere Anforderungen an Autoren resultieren, was Zugänglichkeit und Barrierefreiheit anbelangt.

Diskutiert wird in diesem Kapitel der Kern des DOMs, ohne spezifische Erweiterungen für (X)HTML, SVG, Stilvorlagen, Ereignisbehandlungen etc. Das DOM und den DOM-Kern gibt es in verschiedenen Versionen:

  • DOM 0 - unspezifizierter proprietärer Wildwuchs (also heute belanglos)
  • DOM Core 1 - 1998 ohne Namensräume (soweit relevant in folgenden Versionen enthalten)
  • DOM Core 2 - 2000 mit Namensräumen (die Version wird etwa von SVG 1.1 mindestens gefordert)
  • DOM Core 3 - 2004 einige neue Strukturen, Verwaltung von Fehlermeldungen (enthält auch Version 2 und 1)

Sofern nicht anders angegeben, sind die in diesem Kapitel beschriebenen DOM-Strukturen in DOM 2 definiert. Neuere Strukturen von DOM 3 werden hingegen explizit als solche bezeichnet.

Das DOM kann in verschiedenen Programmiersprachen angewendet werden und wird auch in verschiedenen Sprachen verwendet. Hier geht es nur um die Verwendung in Verbindung mit ECMA-script oder JavaScript. Das DOM kann auch für verschiedene Auszeichnungssprachen verwendet werden, in denen Dokumente verfaßt sind. Ausgerichtet ist das DOM allerdings auf Sprachen aus der Sprachfamilie XML und alternativ auch auf HTML. Die Sprachen (X)HTML und SVG etwa bieten jeweils ein Element script, mit welchem Skripte eingebunden werden können. Nicht alle XML-Formate haben ein Element mit dieser Funktion. Soll dennoch per Skript auf das DOM eines solchen XML-Dokumentes zugegriffen werden, kann entsprechend das script von SVG oder XHTML mit entsprechender Namensraumzuordnung als Fragment notiert werden, um diese Funktionalität bereitzustellen.

Wesentliche Unterschiede in der Anwendung bei HTML und XML ergeben sich aus einigen historisch bedingten Abweichungen von HTML gegenüber dem jüngeren, allgemeiner formulierten XML. Insbesondere gibt es in HTML keine Verarbeitungsanweisungen und keine Namensräume, wobei insbesondere letzteres die Nutzungs- und Kombinationsmöglichkeiten von HTML drastisch einschränkt und einige DOM-Anwendungen ausschließt. Ferner ist es bei HTML möglich, dass einige Strukturen, besonders Elemente, sofern sie vom Autor nicht notiert sind, aber notwendig sind, vom Darstellungsprogramm automatisch im DOM ergänzt werden, was bei XML ausgeschlossen ist. Ein anderer in diesem Zusammenhang zu nennender Unterschied ist, dass in HTML Namen von Elementen und Attributen unterschiedlich geschrieben werden können. Es kann willkürlich bei jedem Glyphen eines Elementnamens oder Attributnamens zwischen Groß- und Kleinschreibung gewechselt werden. Bei XML-Formaten gibt es nur eine Schreibweise für dasselbe Element oder Attribut, welche für das jeweilige Format genau definiert ist. Diese Unterschiede können zu Problemen bei HTML führen, weswegen es nicht nur aus diesem Grunde zu empfehlen ist, auch bei HTML-Dokumenten dieselben Elementnamen zu verwenden wie bei XML und keinesfalls auf notwendige Elemente zu verzichten.

Die Struktur eines Dokumentes, beziehungsweise seine Repräsentation wird im DOM in Form von Knoten beschrieben, die in ECMA-script oder JavaScript Objekten entsprechen. Typische Knoten sind die Elemente, Verarbeitungsanweisungen, Dokumenttypdeklarationen, Kommentare, CDATA-Bereiche und einfacher Text einschließlich Leerzeichen und Zeilenumbrüchen, Attribute von Elementen und deren Werte.

XML und HTML geben genau vor, wie die ersten Knoten eines Dokumentes aussehen dürfen. Einmal abgesehen vom formalen Vorspann ist das Wurzelelement eines Dokumentes für den DOM-Zugriff von zentraler Bedeutung. Dies enthält alle anderen Knoten des Dokumentes, die für den Zugriff über das DOM für die meisten Anwender wichtig sein werden. Bei Bedarf ist es aber auch möglich, mit dem DOM auf Knoten außerhalb des Wurzelelementes zuzugreifen.

Das DOM bietet für verschiedene Strukturen verschiedene Schnittstellen (englisch: 'interfaces'). Eine Schnittstelle beschreibt jeweils einen bestimmten Typ von Objekt oder Knoten. In einer Schnittstelle wird ferner unterschieden zwischen einerseits Attributen oder Eigenschaften und andererseits Methoden. Attribute oder Eigenschaften im Sinne von DOM haben nichts mit den gleichnamigen Strukturen von HTML, XML oder CSS zu tun. Im praktischen Gebrauch ist das später recht unproblematisch, weil die Bezeichnungen Attribut, Eigenschaft oder Methode im Sinne des DOMs im Quelltext des Skriptes gar nicht auftauchen, sondern nur im Sinne von HTML oder XML. Allenfalls in einer Beschreibung der Sprachelemente wie in dieser Anleitung kann die Namensgleichheit etwas verwirrend sein.

Hat zum Beispiel ein DOM-Objekt 'object' eine DOM-Eigenschaft oder ein DOM-Attribut namens 'attribute', so kann darauf mit der üblichen Punktverknüpfung zugegriffen werden:
var dummy = object.attribute
Dabei ist es auch möglich, dass das Objekt nur als Unterobjekt eines anderen Objektes verfügbar ist, zum Beispiel eines namens 'document', dann sieht der Zugriff etwa so aus:
var dummy = document.object.attribute

Hat zum Beispiel ein Objekt 'object' eine Methode namens 'method', so kann diese Methode wie eine Funktion Parameter haben, etwa 'p1' ,'p2' und 'p3'. Die Nutzung der Methode erfolgt auch über die Punktnotation, Parameterwerte werden hinten in Klammern angehängt:
var dummy = object.method(p1,p2,p3)
Die Klammern sind auch zu notieren, wenn eine Methode 'methode' keine Parameter hat:
var dummy = object.methode()
Entsprechend als Unterobjekt von einem Objekt namens 'document':
var dummy = document.object.methode()

Welche Attribute und Methoden für welche Objekte anwendbar sind und ob Objekte Unterobjekte von anderen Objekten sind, ist jeweils einzeln definiert. Auch was zurückgegeben wird, ist für das jeweilige Attribut und die jeweilige Methode einzeln definiert. Die Struktur der zurückgegebenen Objekte ist also jeweils zu berücksichtigen. Es ist aber auch nicht immer interessant, was zurückgegeben wird, es muß also nicht zwangsläufig eine Variable für die Rückgabe angegeben werden:
object.methode()

Vergleicht man die Skript/DOM-Methode, auf Dokument-Objekte zuzugreifen, mit den vermutlich ebenfalls gewöhnungsbedürftigen Methoden von CSS oder XSL(T), so erscheint die Skript/DOM-Methode wenig elegant und allein schon von der Schreibweise her wenig effizient. Immerhin läßt sich hier aber die Zugriffsmethode recht einfach mit dem ECMA-Script-Sprachkern verbinden, welcher Rechnungen, eigene Funktionen, Objekte, Programmschleifen etc recht einfach ermöglicht, was diese Zugriffsmethode dann doch wieder recht flexibel und vielseitig macht, wenn auch nicht besonders elegant oder effizient.

Durch die Flexibilität und Vielseitigkeit kommt aber auch auf den Autor viel Verantwortung zu. Letztlich sind ja solche Skripte auch nur eine weitere Möglichkeit neben CSS und XSL(T), um Dokumente zu dekorieren, in Sinne des Schichtenmodells also eine weitere Abstraktionsstufe relativ weit weg vom eigentlichen Inhalt. Im Sinne des Anspruchs, dass Skripte unaufdringlich sein sollen und im Sinne von Zugänglichkeit und Barrierefreiheit ändern die Skripte per Definition nicht die inhaltliche Aussage des Dokumentes selbst. Gleichzeitig bietet das DOM zusammen mit dem ECMA-Script-Sprachkern allerdings alle Möglichkeiten, um die Präsentation des ursprünglichen Inhaltes eines Dokumentes beliebig zu manipulieren oder scheinbar neuen Inhalt hinzuzufügen. Hier liegt das problematische und mächtige Potential der DOM-Manipulation, verschiedenen Nutzergruppen scheinbar unterschiedliche Inhalte anzubieten. Dem jeweiligen Nutzer einer DOM-manipulierten Präsentation ist der Unterschied zwischen dem Inhalt des Dokumentes und der Präsentation desselben meist nicht klar und es erfordert meist zumindest Grundkenntnisse in der Bedienung des jeweils genutzten Darstellungsprogrammes, um zwischen der nicht manipulierten Präsentation des Dokumentes und der DOM-manipulierten Präsentation hin- und herzuschalten, sofern letztere beim verwendeten Programm verfügbar ist.

Zugänglichkeitsprobleme zu vermeiden, überlassen die DOM-Empfehlungen allein der Verantwortung der Autoren. Die DOM-Empfehlungen stellen also anders als die meisten anderen Empfehlungen des W3C selbst keine Mechanismen zur Verfügung, um Zugänglichkeit und Barrierefreiheit zu gewährleisten. Zugänglichkeitsprobleme hingegen ergeben sich eigentlich auch erst durch die Verwendung des DOM innerhalb von JavaScript/ECMA-Script, um Dokument-Repräsentationen per anwenderseitigem Skript zu manipulieren, nicht direkt durch das DOM selbst, welches auch anderweitig verwendbar ist, etwa als Modul von PHP, dann also nicht anwenderseitig, sondern auf einem Dienstrechner vor der Ausgabe an das Publikum angewendet. Daher muß der Autor den Inhalt eines veröffentlichten Dokumentes in Formaten wie HTML, XHTML, SVG etc immer als primäre Ansicht ohne DOM-Manipulation durch anwenderseitige Skripte bereitstellen und die DOM-Manipulation per anwenderseitigem Skript wird dann im Anwendungsfalle auch nicht die inhaltliche Aussage des Dokumentes ändern, nur eine alternative Ansicht bereitstellen.

Zu beachten ist wie bereits angedeutet, dass strenggenommmen mit einer Manipulation nicht das Dokument selbst verändert wird, also weder inhaltlich noch im technischen Sinne, sondern nur dessen abstrakte Repräsentation im Dokument-Objekt-Modell des gerade verwendeten Darstellungsprogrammes. Anders als das Dokument selbst ist diese DOM-Repräsentation erst einmal immer ein transienter Zustand im Darstellungsprogramm, sie existiert nicht als eigenständige, referenzierbare oder eindeutig identifizierbare Instanz. Formal kann sich die inhaltliche Bedeutung eines Dokumentes also durch DOM-Anwendungen gar nicht ändern, weil das Dokument selbst unverändert bleibt. Möchte man als Autor oder Nutzer eine per Skript und DOM verändertes Repräsentation eines Dokumentes abspeichern oder auch nur den korrespondierenden Quelltext eines Dokumentes angucken, so ist dafür ein geeignetes Darstellungsprogramm zu verwenden, welches also eine dafür geeignete Funktionalität oder Ausgabe bereitstellt (Bei einer Erweiterung von Darstellungsprogrammen von Mozilla/Gecko findet sich etwa eine solche Funktionalität unter dem verwirrenden Begriff 'äußeres HTML', wobei diese Ausgabe nichts mit HTML zu tun haben braucht). Erst ein so abgespeichertes Dokument hat wieder eine eigenständige Existenz außerhalb des internen Modelles des Darstellungsprogrammes und kann somit neue inhaltliche Bedeutung annehmen.


Für die Beispiele wird in diesem Kapitel vorrangig von SVG-Dokumenten ausgegangen, auch schon weil das restliche Buch sehr HTML-lastig ist. SVG als XML-Format bietet da ein geeignetes Gegengewicht mit ebenfalls breiter Anwendung. SVG selbst hat auch größere Erweiterung zum DOM-Kern, darauf wird in diesem Kapitel nicht weiter eingegangen. Zu SVG selbst gibt es ein eigenes Wikibook: SVG - die Beispiele sind allerdings recht einfach gehalten, besondere Vorkenntnisse werden sicher nicht schaden, aber auch nicht besonders wichtig sein.

Als Hilfe für SVG-unkundige Leser dieser Anleitung hier ein Beispiel für ein nahezu leeres SVG-Dokument ohne relevanten Inhalt; bei diesem wird das Skript im Element script notiert:

<?xml version="1.0" encoding="utf-8" ?>
<svg xmlns="http://www.w3.org/2000/svg" 
  version="1.1" xml:lang="de" 
  viewBox="-1000 -1000 2000 2000">
<title></title>
<desc></desc>

<!-- hier würde zum Beispiel der eigentliche graphische Inhalt stehen -->

<defs>
<script type="application/ecmascript">
// hier kommt der Quelltext des Skriptes rein
</script>
</defs>
</svg>

Bei einer externen Skriptdatei sieht das Beispiel etwa so aus:

<?xml version="1.0" encoding="utf-8" ?>
<svg xmlns="http://www.w3.org/2000/svg" 
  version="1.1" xml:lang="de" 
  viewBox="-1000 -1000 2000 2000"
  xmlns:xlink="http://www.w3.org/1999/xlink">
<title></title>
<desc></desc>

<!-- hier würde zum Beispiel der eigentliche graphische Inhalt stehen -->

<defs>
<script type="application/ecmascript"
  xlink:href="meinScript.js"/>
</defs>
</svg>

Das Dokument, Schnittstelle 'Document'[Bearbeiten]

Das vordefinierte Objekt 'document' ist zumeist Ausgangspunkt eines Zugriffs auf das DOM. Es ist ein abstrakter Knoten für das gesamte Dokument. Die Schnittstelle 'Document' beschreibt dieses Objekt. Mit einer anderen, noch zu beschreibenden Schnittstelle können allerdings auch eigene Objekte/Knoten vom Typ 'Document' erzeugt werden. Im Folgenden wird das vordefinierte Objekt 'document' stellvertretend für Objekte vom Typ 'Document' verwendet.

Attribute[Bearbeiten]

  • document.doctype vom Typ 'DocumentType', nur lesbar.

Sofern vorhanden gibt das die Schnittstelle zur Dokumenttypdeklaration zurück, sonst 'null'.

  • document.documentElement vom Typ 'Element', nur lesbar.

Rückgabe ist die Schnittstelle zum Wurzelelement

  • document.implementation vom Typ 'DOMImplementation', nur lesbar.

Rückgabe ist eine Schnittstelle zu einigen dokumentunabhängigen Methoden, unter anderem auch auf Information, was im Darstellungsprogramm implementiert ist.

  • document.documentURI ist eine Zeichenkette (DOM Core 3).

Die Zeichenkette bezeichnet die URI des Dokumentes, so weit bekannt, sonst null. Das Setzen des Attributes auf einen anderen Wert bewirkt offenbar nicht, dass sich das Dokument dann auch wirklich dort befindet, noch dass das Darstellungsprogramm versucht, auch bei vorhandenen Zugriffsrechten, dieses dort abzulegen.

  • document.domConfig ist nur lesbar und vom Typ 'DOMConfiguration'(DOM Core 3).

Konfiguration für die Methode document.normalizeDocument().

  • document.xmlStandalone ist entweder true oder false (DOM Core 3).

Bei true steht diese Angaben in der XML-Verarbeitungsanweisung, bei false nicht. Wird der Wert gesetzt, wird allerdings nicht geprüft, ob die das Dokument wirklich selbständig ist oder nicht.

  • document.xmlEncoding ist eine nur lesbare Zeichenkette (DOM Core 3).

Die Zeichenkette enthält die XML-Kodierungsangabe zum Dokument, also etwa 'UTF-8', sofern bekannt, sonst null.

  • document.inputEncoding ist eine nur lesbare Zeichenkette (DOM Core 3).

Die Zeichenkette enthält eine Kodierungsangabe zur Zeit der Interpretation durch das Darstellungsprogramm, also etwa 'UTF-8', sofern bekannt, sonst null. Dies kann insofern von document.xmlEncoding abweichen, als Dienstprogramme davon abweichende, dann vermutlich falsche Informationen senden können. Durch Vergleich beider Angaben kann man offenbar Problemen mit Kodierungsangaben auf die Schliche kommen.

  • document.strictErrorChecking ist entweder true oder false (DOM Core 3).

Bei true, der Voreinstellung, wird auf DOM-Fehler getestet, bei false nicht.

  • document.xmlVersion ist eine Zeichenkette (DOM Core 3).

Die Zeichenkette enthält die verwendete XML-Version, also entweder '1.0' oder '1.1', wobei sich letzteres wohl in der Praxis erledigt hat (1.0 wurde wohl insofern überarbeitet, dass 1.1 in der Praxis nicht gebraucht wird).

Da die Rückgabewerte bei den Attributen von Core 2 immer Schnittstellen sind, verwendet das folgende Beispiel im leichten Vorgriff auf die Beschreibung dieser Schnittstellen bereits Attribute oder Methoden von diesen, um eine relevante Zeichenkette als Ausgabe zu bekommen. Diese Attribute werden später noch beschrieben, ihre Namen geben aber meist bereits an, um was es geht:

<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
  "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<svg xmlns="http://www.w3.org/2000/svg" 
version="1.1" xml:lang="de" 
viewBox="-1000 -1000 2000 2000">
<title></title>
<desc></desc>
 
<defs>
<script type="application/ecmascript">
  // gucken, was das aktuelle Dokument ist 
  // und ob DOM 2.0 Core interpretiert wird
  var text='doctype: '+document.doctype.name
  text+='\ndocumentElement: '+document.documentElement.tagName
  text+='\nimplementation "Core", "2.0"?  '
  text+=document.implementation.hasFeature("Core", "2.0")
  alert(text)
</script>
</defs>
</svg>

Methoden[Bearbeiten]

  • document.createComment(Zeichenkette)

Mit dieser Methode wird ein Kommentar angelegt. Die Zeichenkette entspricht dem Inhalt des Kommentars. Rückgabewert ist ein Objekt vom Typ Comment.

Beispiel:

   // Kommentar setzen
   var kommentar=document.createComment('irgendein Text &lt;&amp;&gt;')
   document.documentElement.appendChild(kommentar)


  • document.createCDATASection(Zeichenkette)

Mit dieser Methode wird ein CDATA-Bereich angelegt. Die Zeichenkette entspricht dem Inhalt des CDATA-Bereiches. Solch ein Bereich wird bei XML nicht interpretiert, kann also insbesondere unmaskiert die für XML-Dokumente kritischen Zeichen <, > und & enthalten. Rückgabewert ist ein Objekt vom Typ 'CDATASection'. Bei HTML ist die Methode nicht zulässig.

Folgendes Beispiel erzeugt einen solchen Bereich und setzt diesen mit einer noch zu erklärenden Methode in ein Element mit dem Fragmentidentifizierer 'wohin'.

Dieses Element sollte dann auch vorhanden sein, in SVG wäre das typisch ein Element style, script, metadata, title, desc oder eines der Text-Elemente, weil die meisten anderen Elemente keinen Text enthalten. Die Verwendung solcher Bereiche ist allerdings außerhalb der Elemente style und script generell eher unüblich.

Um ein praktisches Beispiel zu bekommen, ist etwas vorzugreifen. Die Funktion der noch nicht erklärten Methoden ergibt sich ungefähr aus dem Namen und wird später noch genau erläutert.

   // CDATA in ein Element schreiben
   var cdata=document.createCDATASection('irgendein Text &lt;&amp;&gt;')
   document.getElementById("wohin").appendChild(cdata)


  • document.createElementNS(Namensraum,Elementname), document.createElement(Elementname)

Mit diesen Methoden kann ein Element erzeugt werden, die Parameter sind jeweils Zeichenketten, Namensraum also für eine Namensraumangabe wie 'http://www.w3.org/2000/svg' oder 'http://www.w3.org/1999/xhtml'. Elementname, im Bedarfsfalle mit Präfix, ist für den Namen eines Elementes im angegebenen Namensraum, also bei SVG wäre 'title' für ein Titel-Element ein Beispiel:
document.createElementNS('http://www.w3.org/2000/svg','title')
oder
document.createElementNS(null,'title')

Die Rückgabe ist ein Objekt namens Element.

Da HTML über keinen Mechanismus für Namensräume verfügt, wird die zweite Variante ohne Namensraum verwendet. Bei XML wird sonst kein Namensraum verwendet, entsprechend wenn bei der ersten Variante für den Namensraum 'null' angegeben wird. Bei XML sollte die erste Variante verwendet werden. Elemente ohne Verknüpfung mit einem Namensraum haben pauschal keine definierte inhaltliche Bedeutung, würden also etwa in einem SVG-Dokument auch nicht angezeigt werden, da es sich dann nicht um präsentierbare Elemente aus dem SVG-Namensraum handelt.

Man beachte auch, so wird das Element noch nicht im präsentierten Dokumentbaum untergebracht, sondern ist nur abstrakt mit dem Dokument verbunden.

Um ein praktisches Beispiel zu bekommen, ist wieder etwas vorzugreifen:

   // Kreis-Element erzeugen   
   var circle = document.createElementNS("http://www.w3.org/2000/svg", 'circle')
   // Attribut für den Radius mit dem Wert 20 setzen
   circle.setAttributeNS(null, 'r', '20')
   // Kreis hinten als letztes Kind des Wurzelelementes anhängen
   document.documentElement.appendChild(circle)


  • document.createAttributeNS(Namensraum,Attributname), document.createAttribute(Attributname)

Mit diesen Methoden kann ein Attribut erzeugt werden, die Parameter sind jeweils Zeichenketten, Namensraum also für eine Namensraumangabe, der für die gelegentlich verwendeten XML-Attribute ist übrigens "http://www.w3.org/XML/1998/namespace" und der für XLink: 'http://www.w3.org/1999/xlink'. Attributname, im Bedarfsfalle mit Präfix, ist für den Namen eines Attributes eines Elementes im angegebenen Namensraum, also bei SVG wäre 'fill' für die Füllfarbe ein Beispiel:
document.createAttributeNS('http://www.w3.org/2000/svg','fill')
oder
document.createAttributeNS(null,'fill')

Die Rückgabe ist ein Objekt namens Attr.

Da HTML über keinen Mechanismus für Namensräume verfügt, wird die zweite Variante ohne Namensraum verwendet. Bei XML wird sonst kein Namensraum verwendet, entsprechend wenn bei der ersten Variante für den Namensraum 'null' angegeben wird. Bei XML sollte die erste Variante verwendet werden.

Man beachte auch, so wird der Wert des Attributes noch nicht gesetzt, nur das Attribut. Beides in einem Schritt ist eleganter und geht mit einer noch zu erläuternden Methode für Elemente, dem im vorherigen Beispiel verwendeten setAttributeNS(), nicht direkt bei 'document'.

Um ein praktisches Beispiel zu bekommen, ist wieder etwas vorzugreifen:

   // umständliche Methode, ein Attribut zu erzeugen und dann zu setzen    
   var attr = document.createAttributeNS(null, 'fill')
   // Wert des Attributes setzen
   attr.value='red'
   // Attribut beim Wurzelelement setzen
   document.documentElement.setAttributeNode(attr)
  • document.createEntityReference(Entitätenname)

Die Methode erzeugt eine Entität. Entitätenname ist eine Zeichenkette, die den Namen einer Entität repräsentiert, die anderweitig definiert sein muß, etwa in der Dokumenttypdefinition oder der Dokumenttypdeklaration, es sei denn, es handelt sich um jene Entitäten, welche in XML immer definiert sind.

Rückgabe ist ein Objekt namens EntityReference


  • document.createProcessingInstruction(Ziel, Daten)

Die Methode erzeugt eine XML-Verarbeitungsanweisung. Daten ist eine Zeichenkette, welche den gesamten Inhalt der Anweisung beinhaltet. Ziel ist die Bezeichnung der Verarbeitungsanweisung, also etwa 'xml-stylesheet' für eine Stilvorlagenverarbeitungsanweisung.

Rückgabe ist ein Objekt namens ProcessingInstruction

Um ein praktisches Beispiel zu bekommen, ist wieder etwas vorzugreifen:

// Verarbeitungsanweisung setzen
var ziel='xml-stylesheet'
var text='type="text/css" href="Mein.css" title="Mein CSS"'
var va=document.createProcessingInstruction(ziel,text)
// und an passender Stelle ins Dokument einfügen
document.insertBefore(va, document.firstChild)


  • document.createTextNode(Zeichenkette)

Die Methode erzeugt einen Textknoten. Rückgabe ist ein Objekt namens Text.

Um ein praktisches Beispiel zu bekommen, ist wieder etwas vorzugreifen:

// Neues Textelement, Element mit Textinhalt erzeugen:
var neuText = document.createElementNS("http://www.w3.org/2000/svg","text")
// Textknoten erzeugen:
var neuTextInhalt = document.createTextNode("Neuer Text")
// Text in Element hinten einfügen, anhängen
neuText.appendChild(neuTextInhalt)
// Element als Kind an das Wurzelelement anhängen
document.documentElement.appendChild(neuText)


  • document.createDocumentFragment()

Mit der Methode wird ein Dokument-Fragment angelegt, das nicht im Dokumentbaum angesiedelt ist. Bei Bedarf können darin also Strukturen, Dokument-Fragmente oder -Zweige vorbereitet oder vorgehalten werden, um sie zu einem anderen Zeitpunkt in den Dokumentbaum einzufügen. Dies kann insbesondere nützlich sein, wenn etwa Navigationsstrukturen ein- und ausgeblendet werden sollen, insbesondere SVG hat allerdings auch andere Möglichkeiten, solche Strukturen vorzuhalten, etwa im Element defs'. Auch kann einfach das Präsentationsattribut display verwendet werden, um Inhalte ein- und auszublenden. XHTML und andere Formate haben solche Möglichkeiten nicht, dort kann diese Methode also relevanter sein. Beim Integrieren ins aktuelle Dokument wird übrigens nur der Inhalt des Fragmentes eingefügt, nicht dieses Fragment selbst.

Rückgabewert ist ein Objekt vom Typ DocumentFragment.

Beispiel:

   // Fragment erzeugen
   var frag = document.createDocumentFragment()
   // Element svg erzeugen
   var svge = document.createElementNS("http://www.w3.org/2000/svg","svg")
   svge.setAttributeNS(null,'id', 'svg')
   svge.setAttributeNS(null,'x', '200')
   svge.setAttributeNS(null,'y', '100')
   svge.setAttributeNS(null,'width', '200')
   svge.setAttributeNS(null,'height', '200')
   svge.setAttributeNS(null,'viewBox', '0 0 50 50')
   // svg-Element ins Fragment setzen
   frag.appendChild(svge) 
   // Kreis erzeugen
   var circle = document.createElementNS("http://www.w3.org/2000/svg","circle")
       circle.setAttributeNS(null,"r", 50)
       circle.setAttributeNS(null,"id", 'c0')
       circle.setAttributeNS(null,"fill", 'green')
   // Kreis ins erzeugte svg-Element einfügen    
   svge.appendChild(circle)
   
   // Fragmentinhalt in aktuelles Dokument einfügen
   document.documentElement.appendChild(frag) 
   // Kreis kopieren
   var cc=circle.cloneNode(true);
   cc.setAttributeNS(null,'cx', '-200')
   // aufgrund des anderen Koordinatensystems 
   // ist der natürlich kleiner und komplett dargestellt 
   document.documentElement.appendChild(cc)


  • document.getElementById(ID)

Mit der Methode wird auf ein Element zugegriffen, welches einen Fragmentidentifizierer hat. Dieser steht in der Zeichenkette ID. Sofern es solch ein Element gibt, ist der Rückgabewert dieses Element, ist also ein Objekt vom Typ Element, sonst ist der Rückgabewert 'null'.

Beispiel:

// Gruppen-Element erzeugen   
var g = document.createElementNS("http://www.w3.org/2000/svg", 'g')
// Fragmentidentifizierer setzen
g.setAttributeNS(null, 'id', 'g1')
// Gruppen hinten als letztes Kind des Wurzelelementes anhängen
document.documentElement.appendChild(g)
// Kreis-Element erzeugen   
var circle = document.createElementNS("http://www.w3.org/2000/svg", 'circle')
// Attribut für den Radius mit dem Wert 20 setzen
circle.setAttributeNS(null, 'r', '20')
// Kreis hinten als letztes Kind der Gruppe anhängen
document.getElementById('g1').appendChild(circle)
// Füllung für die Gruppe setzen
document.getElementById('g1').setAttributeNS(null, 'fill', 'blue')
// da die Variable g ja schon dem entsprechenden g-Element entspricht, 
// geht hier natürlich auch der direkte Zugriff auf die Variable, 
// hier um den Strich zu setzen
g.setAttributeNS(null, 'stroke', 'green')


  • document.getElementsByTagNameNS(Namensraum, Elementname), document.getElementsByTagName(Elementname)

Mit der Methode bekommt man als Rückgabe eine Knotenliste aller Elemente mit dem Namen, der mit dem Parameter 'Elementname' anzugeben ist. Dieser Parameter ist eine Zeichenkette für den gewünschten Namen, also etwa 'circle', 'ellipse', 'g' etc.

Es gibt eine Namensraum-Variante und eine ohne Namensraum. Letztere paßt dann offenbar für alle Elemente mit demselben Namen im Dokument, unabhängig davon, zu welchem Namensraum sie gehören. Für den Zweck kann man bei der Namensraum-Variante auch '*' angeben. Ähnlich kann man mit '*' bei beiden Varianten alle Element auswählen.

Beispiel, bei welchem die Halbachsen aller Ellipsen im Dokument geändert werden:

eliste=document.getElementsByTagNameNS('*','ellipse')
// der Reihe nach die Halbachsen ändern
if (eliste.length>0) {
  for (var i = 0; i < eliste.length; i++) {
    var ellipse = eliste[i]
    var rx=50*(1+3*Math.random())
    var ry=50*(1+3*Math.random())
    ellipse.setAttributeNS(null, 'rx', rx)
    ellipse.setAttributeNS(null, 'ry', ry)
  }
}
  • document.importNode(Knotenbezeichnung, Rekursion)

Mit der Methode kann aus einem (anderen) Dokument ein Knoten in das aktuelle Dokument kopiert werden. Knotenbezeichnung ist ein Knoten vom Typ 'Node' und Rekursion ist entweder true oder false. Bei true werden die Unterknoten mitkopiert, bei false nicht.

Rückgabewert ist der importierte Knoten, der dann im Bedarfsfalle wieder irgendwo einzufügen ist.

Ein Beispiel gibt es im nächsten Abschnitt zur Methode document.implementation.createDocument(), mit welcher ein neues Dokument erzeugt werden kann.

  • document.adoptNode(Quelle) (DOM Core 3)

Mit der Methode wird ein Knoten von einem anderen Dokument übernommen oder adoptiert. Es ändert sich also ownerDocument. Sofern die Quelle ein Elternelement hat, wird es aus der Liste von dessen Kindern entfernt. Der Parameter Quelle ist vom Typ 'Node'.

Der Rückgabewert ist vom Typ 'Node' und enthält den adoptierten Knoten.

Knoten vom Typ 'Document', 'DocumentType', 'Entity', 'Notation' können nicht adoptiert werden.

  • document.normalizeDocument() (DOM Core 3)

Die Methode hat keine Parameter und keinen Rückgabewert. Die Funktion besteht darin, die aktuelle Repräsentation des Dokumentes in einen Zustand zu versetzen, als sei diese frisch von einem statischen Dokument ermittelt worden. Zusätzlich werden auch alle Textknoten normalisiert.

  • document.renameNode(Knoten,Namensraum,Name) (DOM Core 3)

Mit der Methode können Knoten von Elementen und Attributen auf einen anderen Namen gesetzt werden. Weil Elemente oft andere Attribute haben und Attribute oft andere Anforderungen an den Attributwert, ergibt dies nur unter speziellen Bedingungen einen Sinn. Bei SVG könnte man etwa aus einem Element g ein Element a machen, aber nicht unbedingt umgedreht. Aus einem Attribut fill könnte man stroke machen und umgedreht.

Rückgabewert ist der umbenannte Knoten.


Implementierung, Schnittstelle 'DOMImplementation'[Bearbeiten]

Über die Schnittstelle erfolgt der Zugriff auf Methoden außerhalb des Dokument-Objekt-Modells.

Die Schnittstelle hat keine Attribute.

Methoden[Bearbeiten]

  • document.implementation.createDocument(Namensraum,Wurzelelement,Dokumenttyp)

Mit der Methode kann ein neues Dokument-Objekt vom Typ 'document' erzeugt werden. Der Rückgabewert ist ein solches Objekt. Entsprechend können dann auf dieses Objekt auch die gleichen Attribute und Methoden angewendet werden wie auf das Objekt 'document'.

Als Parameter sind der Namensraum als Zeichenkette anzugeben, dann der Name des Wurzelelementes des neuen Dokumentes als Zeichenkette, dann der Dokumenttyp oder 'null', wenn der nicht gebraucht wird. Dieser Parameter ist ein Objekt vom Typ 'DocumentType', siehe nächster Abschnitt.

Beispiel dazu und zur Methode document.importNode():

   // eigenes Dokument erzeugen, um darin Inhalte vorzuhalten ...
   var meindokument=document.implementation.createDocument("http://www.w3.org/2000/svg", "svg", null)
   var svge = meindokument.documentElement
   svge.setAttributeNS(null,'id', 'svg')
   svge.setAttributeNS(null,'x', '200')
   svge.setAttributeNS(null,'y', '100')
   svge.setAttributeNS(null,'width', '200')
   svge.setAttributeNS(null,'height', '200')
   svge.setAttributeNS(null,'viewBox', '0 0 50 50')
   var circle = meindokument.createElementNS("http://www.w3.org/2000/svg","circle")
       circle.setAttributeNS(null,"r", 50)
       circle.setAttributeNS(null,"id", 'c0')
       circle.setAttributeNS(null,"fill", 'green')
   svge.appendChild(circle)
   
   // Wurzelelelement des erzeugten Dokumentes in aktuelles Dokument einfügen
   document.documentElement.appendChild(meindokument.documentElement) 
   // Kreis kopieren
   var cc=circle.cloneNode(true);
   cc.setAttributeNS(null,'cx', '-200')
   // aufgrund des anderen Koordinatensystems 
   // ist der natürlich kleiner und komplett dargestellt 
   document.documentElement.appendChild(cc) 
   
   // svg-Element verschieben
   svge.setAttributeNS(null,'x', '-600')
   // svg-Element aus dem anderen Dokument importieren  
   var imp=document.importNode(meindokument.documentElement,true)
   // und hinten anhängen
   document.documentElement.appendChild(imp)


  • document.implementation.createDocumentType(Name,PublicId,SystemId)

Mit der Methode wird ein Dokumenttypknoten erzeugt, Rückgabewert ist ein solches Objekt vom Typ 'DocumentType'.

Paramter sind drei Zeichenketten. Name ist der Name des Wurzelelementes, für welchen der Dokumenttyp gilt, also etwa 'svg'. PublicId ist der öffentliche Identifizierer. SystemId ist der Systemidentifizierer.

Beispiel:

   // DTD setzen 
   var dname='svg'
   var dpid='-//W3C//DTD SVG 1.1//EN'
   var dsid='http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd'
   var dtd=document.implementation.createDocumentType(dname,dpid,dsid)


  • document.implementation.hasFeature(Merkmal, Version)

Mit dem Merkmal kann geprüft werden, ob ein Merkmal oder eine Erweiterung des Dokument-Objekt-Modells implementiert wird. Rückgabe ist entweder true für implementiert oder false für nicht.

Die beiden Parameter sind Zeichenketten. Die Werte sind von den jeweiligen Erweiterungen definiert. Für das Kernmodul von DOM 2 wird zum Beispiel 'Core', '2.0' notiert. Bei SVG 1.1 ist das Merkmal gegeben durch einen der Werte für requiredFeatures und die Version ist '1.1'.

Beispiel siehe Attribute zum Typ 'document'.


  • document.implementation.getFeature(Merkmal,Version) (DOM Core 3)

Die Methode dient dazu, ein bestimmtes Merkmal in Form eines Objektes zurückzugeben, wobei die Parameter Merkmal und Version dazu dienen, das Objekt eindeutig zu identifizieren. Beides sind Zeichenketten. Rückgabewert ist ein dazu passendes Objekt des DOM, sofern vorhanden, sonst null.


Fragment, Schnittstelle 'DocumentFragment'[Bearbeiten]

Diese Schnittstelle stellt ein Dokumentfragment bereit. In diesem können Inhalte ähnlich wie in einer Zwischenablage untergebracht werden, die zu einem anderen Zeitpunkt wieder verwendet werden. Beispiel und weitere Erläuterungen siehe Methode document.createDocumentFragment()

Knoten, Schnittstelle 'Node'[Bearbeiten]

Mit der Schnittstelle kann allgemein auf jegliche Knoten in einem Dokument zugegriffen werden.

Hinweis zur Notation: Sei im Folgenden 'Knoten' ein bereits vorhandener Knoten, für den das jeweilige Attribut oder die jeweilige Methode sinnvoll anwendbar ist.

Attribute[Bearbeiten]

  • Knoten.ownerDocument vom Typ 'Document', nur lesbar.

Das Dokument, zu dem der Knoten gehört; null falls es dieses nicht gibt.

  • Knoten.parentNode vom Typ 'Node', nur lesbar.

Elternknoten des Knotens. Attr, Document, DocumentFragment, Entity, and Notation haben keinen Elternknoten, dort null.

  • Knoten.childNodes vom Typ 'NodeList', nur lesbar.

Sofern vorhanden gibt das eine Listen von Knoten zurück, die Kinder jenes Knotens sind, auf den das Attribut angewendet wird, sonst null

  • Knoten.firstChild vom Typ 'Node', nur lesbar.

Sofern vorhanden gibt dies den ersten Kindknoten jenes Knotens zurück, auf den das Attribut angewendet wird, sonst null.

  • Knoten.lastChild vom Typ 'Node', nur lesbar.

Sofern vorhanden gibt dies den letzten Kindknoten jenes Knotens zurück, auf den das Attribut angewendet wird, sonst null.

  • Knoten.nextSibling vom Typ 'Node', nur lesbar.

Sofern vorhanden gibt dies den nächstse Geschwisterknoten jenes Knotens zurück, auf den das Attribut angewendet wird, sonst null.

  • Knoten.previousSibling vom Typ 'Node', nur lesbar.

Sofern vorhanden gibt dies den vorherigen Geschwisterknoten jenes Knotens zurück, auf den das Attribut angewendet wird, sonst null.

  • Knoten.attributes vom Typ 'NamedNodeMap', nur lesbar.

Sofern vorhanden gibt das eine Liste von Attributen zurück, sonst null.

  • Knoten.localName Zeichenkette, nur lesbar.

Gibt für den Knoten vom Typ Element oder Attribut, auf den das Attribut angewendet wird, den lokalen Namen (ohne Präfix) zurück, sonst null.

  • Knoten.prefix Zeichenkette.

Gegebenenfalls das Präfix eines Elementes oder Attributes, sonst null.

  • Knoten.namespaceURI Zeichenkette, nur lesbar.

Gegebenenfalls die Namensraumangabe für den Zeitpunkt, als der Knoten erzeugt wurde. Falls keine Namensraumangabe verfügbar ist, null. Zu beachten ist dabei auch, dass ein Attribut nicht den Namensraum von dem Element erbt, bei dem es angegeben ist. Sofern für ein Attribut kein Präfix für einen Namensraum angegeben ist, bestimmt das Element allenfalls die Bedeutung des Attributes.

  • Knoten.nodeType Zahl, nur lesbar.

Typ des Knotens mit folgender Zuordnung:

1: Elementknoten
2: Attributknoten
3: Textknoten
4: CData-Knoten
5: Entitäten-Referenz-Knoten
6: Entitäts-Konten
7: Verarbeitungsanweisungs-Knoten
8: Kommentar-Knoten
9: Dokument-Knoten
10: Dokumenttyp-Knoten
11: Dokumentfragment-Knoten
12: Anmerkungsknoten

  • Knoten.nodeName Zeichenkette, nur lesbar.

Name des Knotens, siehe Tabelle.

  • Knoten.nodeValue Zeichenkette.

Wert des Knotens, siehe Tabelle.

Knoten-Attribute bei verschiedenen Schnittstellen
Schnittstelle nodeName nodeValue Attribute
Attr Name des Attributes Wert des Attributes null
CDATASection #cdata-section content of the CDATASection null
Comment #comment Inhalt des Kommentars null
Document #document null null
DocumentFragment #document-fragment null null
DocumentType document type name null null
Element Elementname null NamedNodeMap
Entität Name der Entität null null
EntityReference Name der Entitäten-Referenz null null
Notation Name der Notation null null
ProcessingInstruction Ziel Kompletter Inhalt des Ziels null
Text #text Inhalt des Textknotens null


  • Knoten.baseURI nur lesbare Zeichenkette für die Basis-URI (DOM Core 3).

Sofern nicht feststellbar, wird null zurückgegeben. (X)HTML hat eine eigene Methode, um diese URI für das gesamte Dokument anzugeben. XML hat ein generisches Attribut xml:base, um diese URI bei Bedarf bei jedem Element samt seinem Inhalt festzulegen. Ob explizit angegeben oder nicht, hat jedenfalls jedes Element solch eine Basis-URI, nicht notwendig allerdings jeder Knoten.

  • Knoten.textContent ist eine Zeichenkette (DOM Core 3).

Die Zeichenkette repräsentiert den Textinhalt eines Knotens einschließlich des Textinhaltes aller Kindknoten. Wird das Attribut gesetzt, werden gegebenenfalls vorhandene Kindknoten entfernt und durch den neuen Textinhalt der angegebenen Zeichenkette ersetzt.

Beispiel:

<?xml version="1.0" encoding="utf-8" ?>
<svg xmlns="http://www.w3.org/2000/svg" version="1.1" 
     xml:lang="de" viewBox="-200 -200 400 400">
<title></title>
<desc></desc>
 
<text id="t" x="0" y="0" text-anchor="middle">
<title>Titel</title>
Text
<tspan fill="red">rot</tspan>
Text
<tspan>
  <title>tspan-Titel</title>  
</tspan>
</text>


<defs>
<script type="application/ecmascript">
var t=document.getElementById('t')
alert(t.textContent)
</script>
</defs>
</svg>

Methoden[Bearbeiten]

  • Knoten.appendChild(Kindknoten)

'Kindknoten' ist dabei ein Objekt vom Typ 'Node', welches an den Knoten 'Knoten' als letztes Kind angehängt wird. Ist 'Kindknoten' bereits im Dokumentbaum eingeordnet, wird es vor dem Anhängen aus seiner früheren Postion entfernt. Der Knoten wird also nur verschoben, nicht kopiert oder an verschiedenen Stellen verfügbar gemacht.

Rückgabewert ist der angehängte Knoten.

  • Knoten.cloneNode(Rekursion)

Mit der Methode wird 'Knoten' dupliziert. Der Parameter Rekursion ist mit true anzugeben, falls der Knoten ein Element ist und einschließlich Inhalt dupliziert werden soll, sonst wird false angegeben.

Rückgabewert ist das Duplikat.

  • Knoten.insertBefore(NeuerKindknoten, AlterKindknoten)

Mit der Methode wird ein neuer Kindknoten 'NeuerKindknoten' vor einem bereits vorhandenen 'AlterKindknoten' eingesetzt. 'AlterKindknoten' ist demzufolge eine bereits vorhandenes Kind von 'Knoten'. Statt 'AlterKindknoten' kann auch 'null' angegeben werden, dann wird 'NeuerKindknoten' hinter allen vorhandenen Kindern von 'Knoten' angehängt. Ist 'Kindknoten' bereits im Dokumentbaum eingeordnet, wird es vor dem Einfügen aus seiner früheren Postion entfernt.

Rückgabewert ist der eingesetzte 'NeuerKindknoten'.

  • Knoten.removeChild(VorhandenerKindknoten)

Mit der Methode kann ein bereits vorhandener Kindknoten 'VorhandenerKindknoten' von 'Knoten' entfernt werden. Der Rückgabewert ist der entfernte Knoten, der somit bei Bedarf anderweitig wieder eingesetzt werden kann.

  • Knoten.replaceChild(NeuerKindknoten,VorhandenerKindknoten)

Mit der Methode wird ein vorhandener Kindknoten 'VorhandenerKindknoten' von 'Knoten' durch einen neuen Kindknoten 'NeuerKindknoten' ersetzt. Ist 'NeuerKindknoten' bereits im Dokumentbaum eingeordnet, wird es vor dem Einfügen aus seiner früheren Postion entfernt. 'VorhandenerKindknoten' ist noch als Rückgabewert verfügbar.

  • Knoten.hasAttributes()

Falls der Knoten Attribute hat, ist der Rückgabewert true, sonst false.

  • Knoten.hasChildNodes()

Falls der Knoten Kindknoten hat, ist der Rückgabewert true, sonst false.

  • Knoten.isSupported(Merkmal, Version)

Mit der Methode kann getestet werden, ob ein als Zeichenkette 'Merkmal' repräsentiertes Merkmal für den Knoten 'Knoten' implementiert und interpretiert wird. Die Notation und Bedeutung entspricht ansonsten der Methode document.implementation.hasFeature(Merkmal, Version)

Falls das Merkmal in der Version implementiert und für den Knoten interpretiert wird, ist der Rückgabewert true, sonst false.

  • Knoten.normalize()

Mit der Methode werden alle Kinder, die Textknoten von 'Knoten' sind normalisiert, das heißt, aufeinander folgende Textknoten werden zu einem zusammengefaßt und leere Textknoten werden entfernt. Dies wird rekursive auf alle Unterknoten von 'Knoten' einschließlich der Attribute angewendet. Dies kann eine einheitliche Behandlung von 'Knoten' erleichtern, es sollte sich also für alle Anwendungen dieselbe Anzahl von Kindtextknoten ergeben.

Es gibt keinen Rückgabewert.

  • Knoten.compareDocumentPosition(andererKnoten) (DOM Core 3)

Die Methode vergleicht die Position der Knoten Knoten und andererKnoten hinsichtlich ihrer Reihenfolge im DOM.

Rückgabewert ist eine Zahl mit folgender Bedeutung:

ZahlBezeichnung der zugehörigen KonstanteBedeutung
1DOCUMENT_POSITION_DISCONNECTEDAnordnung aufgelöst, abhängig von der Implementierung
2DOCUMENT_POSITION_PRECEDINGKnoten liegt hinter andererKnoten
4DOCUMENT_POSITION_FOLLOWINGKnoten liegt vor andererKnoten
8DOCUMENT_POSITION_CONTAINSKnoten liegt innerhalb von andererKnoten
16DOCUMENT_POSITION_CONTAINED_BYandererKnoten liegt innerhalb von Knoten
32DOCUMENT_POSITION_IMPLEMENTATION_SPECIFICPosition von der Implementierung abhängig

Sofern mehrere Bedeutungen zutreffen, werden die Zahlen für das Ergebnis addiert.

Beispiel:

<?xml version="1.0" encoding="utf-8" ?>
<svg xmlns="http://www.w3.org/2000/svg" 
     version="1.1" xml:lang="de" 
     viewBox="-250 -250 500 500">
<title>Teste compareDocumentPosition</title>
<desc>
Test per Skript für die Methode compareDocumentPosition().  
</desc>
 
<circle id="c" cx="-100" cy="100" r="100" fill="blue" /> 

<circle id="d" cx="100" cy="-100" r="100" fill="yellow">
  <title id="t">Titel</title> 
</circle>  

<defs>
<script type="application/ecmascript">
var c=document.getElementById('c')
var d=document.getElementById('d')
var t=document.getElementById('t')
 
var v1=c.compareDocumentPosition(d) 
var v2=d.compareDocumentPosition(c)
var v3=d.compareDocumentPosition(t)
var v4=t.compareDocumentPosition(d)
var v5=c.compareDocumentPosition(t)
var v6=t.compareDocumentPosition(c)

var aus='c zu d: '+v1
aus+='\nd zu c: '+v2
aus+='\nd zu t: '+v3
aus+='\nt zu d: '+v4
aus+='\nc zu t: '+v5
aus+='\nt zu c: '+v6
alert(aus)
</script>
</defs>
</svg>
  • Knoten.getFeature(Merkmal,Version) (DOM Core 3)

Die Methode dient dazu, ein bestimmtes Merkmal in Form eines Objektes zurückzugeben, wobei die Parameter Merkmal und Version dazu dienen, das Objekt eindeutig zu identifizieren. Beides sind Zeichenketten. Rückgabewert ist ein dazu passendes Objekt des DOM, sofern vorhanden, sonst null.


  • Knoten.setUserData(Schlüssel,Daten,Behandler) (DOM Core 3)

Mit der Methode kann ein Objekt selbst definiert werden, welches mit dem Knoten verknüpft ist. Schlüssel ist eine Zeichenkette, welche dazu dient, das Objekt per Knoten.getUserData(Schlüssel) abzurufen. Daten ist vom Typ 'DOMUserData' mit den Daten oder null, um die Daten zu löschen. Behandler ist vom Typ 'UserDataHandler' oder null.


  • Knoten.getUserData(Schlüssel) (DOM Core 3)

Die Methode dient dazu, auf ein zuvor mit Knoten.setUserData() selbst definiertes, mit einem Knoten verknüpftes Objekt zuzugreifen.

Schlüssel ist eine Zeichenkette, zuvor mit Knoten.setUserData() festgelegt.

Rückgabe ist das mit dem Schlüssel verknüpfte Objekt, sofern vorhanden, sonst null.


  • Knoten.isDefaultNamespace(Namensraum) (DOM Core 3)

Mit der Methode kann geprüft werden, ob die mit der Zeichenkette Namensraum angegebenen URI für den Namensraum der vorgeingestellte Namensraum ist oder nicht.

Rückgabewert ist true, wenn dem so ist, sonst nicht.


  • Knoten.isEqualNode(andererKnoten) (DOM Core 3)

Mit der Methode wird verglichen, ob die beiden Knoten Knoten und andererKnoten gleich sind, es muß sich also nicht unbedingt um denselben Knoten handeln. Rückgabe ist true, falls ja, sonst nein.


  • Knoten.isSameNode(andererKnoten) (DOM Core 3)

Mit der Methode wird verglichen, ob die beiden Knoten Knoten und andererKnoten dieselben sind. Rückgabe ist true, falls ja, sonst nein.


  • Knoten.lookupNamespaceURI(Präfix) (DOM Core 3)

Die Methode liefert den zum Präfix gehörigen Namensraum. Präfix ist entsprechend eine Zeichenkette mit der Namensraumangabe; null liefert den voreingestellten Namensraum. Rückgabewert ist eine Zeichenkette für die Namensraumangabe, sofern vorhanden, sonst null.


  • Knoten.lookupPrefix(Namensraum) (DOM Core 3)

Die Methode liefert zu dem als Zeichenkette angegebenen Namensraum den zugehörigen Präfix als Zeichenkette, sofern vorhanden, sonst null.


Beispiel zur Behandlung von Knoten und Knotenlisten[Bearbeiten]

Beispiel zu einigen Knoten-Attributen und -Methoden mit deutlichem Vorgriff auf DOM-Ereignisbehandlung:

<?xml version="1.0" encoding="utf-8" ?>
<svg xmlns="http://www.w3.org/2000/svg" version="1.1" 
     xml:lang="de" viewBox="-500 -500 1000 1000" 
     font-size="20" font-family="sans-serif">
<title>Beispiel zur interaktiven DOM-Knotenbehandlung</title>
<desc>
Per Skript können Füllung, Fülldurchsichtigkeit und Strich 
von Elementen und Elementgruppen per Klick geändert werden.
Eine Ausgabe per Text gibt den aktuellen Status dieser
Attribute an.
Zudem wird die Zeichenreihenfolge geändert.
</desc>
 
<g fill="#ccf" stroke="#ccc" stroke-width="10">
  <rect x="-400" y="-400" width="700" height="700" />
  <rect x="-400" y="-300" width="700" height="700" />
  <rect x="-300" y="-300" width="700" height="700" /> 
  <rect x="-300" y="-400" width="700" height="700" /> 
</g>  

<g fill="red" stroke-width="5"> 
  <circle cx="0" cy="0" r="120" />  
  <circle cx="100" cy="100" r="120" fill="blue" /> 
  <circle cx="-100" cy="100" r="120" fill="green" /> 
  <circle cx="-100" cy="-100" r="120" fill="yellow" /> 
  <circle cx="100" cy="-100" r="120" fill="magenta" /> 
</g>
 
<text id="info" x="0" y="480" text-anchor="middle"> </text>
 
<defs>
<script type="application/ecmascript">
// Ereignisbehandlung - wird ein Element geklickt? 
// Wenn ja, Funktion klick ausführen 
document.documentElement.addEventListener("click", klick, false);

function klick(e) {
     // bei welchem Element ist das Ereignis eingetreten?
     // (nur wenn ein Element dargestellt wird, ist es anklickbar)
     var ele = e.target
     // in diesem Falle Ermittlung des trivialen Dokumentknotens
     var owner=ele.ownerDocument
     // wechselt die Schriftfamilie für das Wurzelelements
     var ff = owner.documentElement.getAttributeNS(null,'font-family')
     if (ff=='serif'){
       owner.documentElement.setAttributeNS(null,'font-family','sans-serif')
     } else {
       owner.documentElement.setAttributeNS(null,'font-family','serif')
     }
     // Elternknoten ermitteln
     var mutti=ele.parentNode
     // Aufräumen
     mutti.normalize()
     // Kinder des Elternelementes
     var kinder=mutti.childNodes
     var anzahl= kinder.length
     // Strich vom Elternelement ermitteln und wechseln
     var st = mutti.getAttributeNS(null,'stroke')
     if (st!='black'){    
      mutti.setAttributeNS(null,'stroke','black') 
      // Element nach oben setzen, als letztes Kind des Elternelementes
      ele.parentNode.appendChild(ele);
      var ii=0
      for (var i = 0; i &lt; anzahl; i++){
       // nur wenn es ein Element ist, Durchsichtigkeit setzen
       if (kinder.item(i).nodeType==1) {
         ii+=0.1
         var fo=0.3+ii
         kinder.item(i).setAttributeNS(null,'fill-opacity',fo)
       }
      }
     } else {
      mutti.setAttributeNS(null,'stroke','#aaa')
      // Element nach unten setzen, als erstes Kind des Elternelementes, 
      // falls es das nicht schon ist
      if (ele.previousSibling) {
        ele.parentNode.insertBefore(ele,ele.parentNode.firstChild);
      } 
      var ii=0     
      for (var i = 0; i &lt; anzahl; i++){
       // nur wenn es ein Element ist, Durchsichtigkeit setzen
       if (kinder.item(i).nodeType==1) {
         ii+=0.1
         var fo=0.7-ii
         kinder.item(i).setAttributeNS(null,'fill-opacity',fo)
       }
      }     
     }
     // Textausgabe
     var T=document.getElementById('info')
     var fi=ele.getAttributeNS(null,'fill')
     var fo=ele.getAttributeNS(null,'fill-opacity')
     st=ele.parentNode.getAttributeNS(null,'stroke')
     T.firstChild.nodeValue='fill:'+fi+' | fill-opacity:'+fo+' | stroke: '+st      
}
</script>
</defs>
</svg>

Knotenliste, Schnittstelle 'NodeList'[Bearbeiten]

Diese Schnittstelle ermöglicht den Zugang zu einer Liste von Knoten, typisch etwa allen Kindknoten eines Knotens. Für den Zugriff ist die Liste durchnumeriert, die Numerierung beginnt mit 0 für das den ersten Knoten der Liste.

Hinweis zur Notation: Sei im Folgenden 'Liste' eine bereits vorhandene Knotenliste.

Beispiel zur Knotenliste siehe vorherigen Abschnitt über Knoten.

Attribut[Bearbeiten]

  • Liste.length ist eine nicht negative ganze Zahl, nur lesbar

Vorhandene Listenpunkte sind von 0 bis Liste.length - 1 durchnumeriert

Methode[Bearbeiten]

  • Liste.item(Listenpunktnummer)

Die Methode gibt als Rückgabewert jenen Listenpunkt zurück, der die Nummer 'Listenpunktnummer' hat, sofern vorhanden, sonst null. Folglich ist 'Listenpunktnummer' eine Zahl zwischen 0 und Liste.length - 1

Liste benannter Knoten, Schnittstelle 'NamedNodeMap'[Bearbeiten]

Diese Schnittstelle ermöglicht den Zugriff auf eine Liste benannter Knoten. Die Reihenfolge der Listenpunkte ist allerdings nicht - etwa durch die Reihenfolge der Listenpunkte im Dokument festgelegt. Sofern also über den vorhandenen Index zugegriffen wird, ist das Ergebnis für die jeweilige Implementierung und die jeweilige Liste eindeutig, kann sich aber bei Änderung der Liste wieder ändern oder bei einer anderen Implementierung anders sein.

Hinweis zur Notation: Sei im Folgenden 'Karte' eine bereits vorhandene Liste benannter Knoten.

Attribut[Bearbeiten]

Hinweis zur Notation: Sei im Folgenden 'Liste' eine bereits vorhandene Knotenliste.

  • Karte.length ist eine nicht negative ganze Zahl, nur lesbar

Vorhandene Listenpunkte sind von 0 bis Karte.length - 1 durchnumeriert

Methoden[Bearbeiten]

  • Karte.item(Listenpunktnummer)

Die Methode gibt als Rückgabewert jenen Listenpunkt zurück, der die Nummer 'Listenpunktnummer' hat, sofern vorhanden, sonst null. Folglich ist 'Listenpunktnummer' eine Zahl zwischen 0 und Karte.length - 1

  • Karte.getNamedItemNS(Namensraum,Name), Karte.getNamedItem(Name)

Mit der Methode kann auf einen Knoten über seinen Namen 'Name' zugegriffen werden. Rückgabewert ist dann der Knoten, sofern vorhanden, sonst null. Bei der Namensraum-Variante kann wieder mit 'Namensraum' der Namensraum angegeben werden, zu welchem der Knoten gehört. Beide Parameter sind Zeichenketten.

  • Karte.removeNamedItemNS(Namensraum,Name), Karte.removeNamedItem(Name)

Mit der Methode kann ein Listenpunkt mit dem Namen 'Name' aus der Liste entfernt werden. Rückgabewert ist der entfernte Knoten, sofern vorhanden, sonst gibt es eine entsprechende Fehlermeldung. Bei der Namensraum-Variante kann wieder mit 'Namensraum' der Namensraum angegeben werden, zu welchem der Knoten gehört. Beide Parameter sind Zeichenketten.

  • Karte.setNamedItemNS(Knoten), Karte.setNamedItem(Knoten)

Mit der Methode kann ein benannter Knoten, repräsentiert durch den Parameter 'Knoten' vom Typ 'Node' in eine benannte Liste gesetzt werden. Ist solch ein Knoten bereits in der Liste, wird der alte Knoten durch den neuen ersetzt. Falls ein Knoten ersetzt wurde, wird der alte Knoten zurückgegeben. Wird nur ein neuer Knoten gesetzt, wird dieser zurückgegeben, sonst null. Bei der Namensraum-Variante wird der Namensraum automatisch mitgesetzt, sofern vorhanden.

Attribute, also Objekte vom Typ 'Attr', die bereits bei einem Elementen verwendet werden, können nicht erneut bei einem anderen gesetzt werden. Zuvor sind diese im Bedarfsfalle zu duplizieren.

Beispiel[Bearbeiten]

<?xml version="1.0" encoding="utf-8" ?>
<svg xmlns="http://www.w3.org/2000/svg" version="1.1" 
     xml:lang="de" viewBox="-200 -200 400 400"
     fill="#f80">
<title>Skript-Test zu den Schnittstellen 'NamedNodeMap' und 'Attr' </title>
<desc>
Bei Skriptinterpretation wird zunächst die Attributliste
des dargestellten Kreises einschließlich einiger Attribute 
des jeweiligen Attributes ausgegeben und die Füllfarbe angegeben.
Dann wird das Attribut fill entfernt, weswegen die Füllung vom
Wurzelelement geerbt wird. 
Nachdem der diesbezügliche Hinweis quittiert wird, wird das
zuvor entfernte Attribut wieder hinzugefügt.
</desc>

<circle id="c" cx="0" cy="0" r="100" fill="blue" stroke="green" /> 

<defs>
<script type="application/ecmascript">
// ein Attribut per Skript setzen
document.getElementById('c').setAttributeNS('MeinNamensraum','hallo','du')  
// Attributliste in Variable 
var a = document.getElementById('c').attributes
// Länge der Liste
var al= a.length
// Alle Attributnamen aufzählen
if (al &gt; 0) {
  var T='Attribute: \n'
  //Alle Attribute analysieren
  for (var i = 0; i &lt; al; i++){
    // das Attributobjekt
    var at= a.item(i)
    // sein Name
    var an= at.name
    // das zugehörige Element und sein Name
    var ao= at.ownerElement.nodeName
    // ist das Attribut bereits im Originaldokument angegeben?
    var as= at.specified
    // Attributwert
    var av= at.value
    T+=an+'="'+av+'" ('+ao+' '+as+'), \n'
  }
}
// Füllung auslesen
var fill = a.getNamedItemNS(null,'fill').nodeValue
T+='\nFüllung ist: '+fill
// Befund mitteilen
alert(T)
// Füllung entfernen
var weg=a.removeNamedItemNS(null,'fill')
// Änderung mitteilen
var text='Der Kreis sollte jetzt eine geerbte orange Füllung haben'
text+=',\ngleich wieder eine blaue.'
alert(text)
// Änderung wieder rückgängig machen
a.setNamedItemNS(weg)
</script>
</defs>
</svg>

Nicht interpretierter Text, Schnittstelle 'CharacterData'[Bearbeiten]

Diese Schnittstelle wird vorrangig von anderen Schnittstellen benötigt, bei denen es um Text oder allgemeiner Zeichenketten geht. Insbesondere die Schnittstellen 'Text', 'Comment' und 'CDATASection' beerben diese Schnittstelle.

Sei C im Folgenden ein Objekt vom Typ 'Text', 'Comment' oder 'CharacterData', auf welches Attribute und Methoden dieser Schnittstelle anwendbar sind.

Attribute[Bearbeiten]

  • C.data ist vom Typ Zeichenkette und beinhaltet den Textknoten C.
  • C.length ist eine nicht negative ganze Zahl und gibt die Anzahl der Zeichen des Textknotens C an,

die Länge kann also auch null sein, wenn keine Zeichen vorhanden sind.

Methoden[Bearbeiten]

  • C.appendData(Zeichenkette)

Die Methode hängt die Zeichenkette 'Zeichenkette' an den Textknotens C an. Es gibt keinen Rückgabewert, auf die neue Zeichenkette kann mit dem Attribut C.data zugegriffen werden.

  • C.deleteData(Anfang,Anzahl)

Mit der Methode wird ein Teil des Textknotens C der Länge Anzahl ab Position Anfang entfernt. Anfang und Anzahl sind nicht negative ganze Zahlen. Anfang liegt zwischen 0 und C.length-1. Ist der zu entfernende Teil größer als die Zeichenkette im Textknoten, wird bis zum Ende des Textknotens entfernt. Es gibt keinen Rückgabewert, auf die neue Zeichenkette kann mit dem Attribut C.data zugegriffen werden.

  • C.insertData(Position,Zeichenkette)

Die Methode setzt die Zeichenkette an der angegeben Position ein. Zeichenkette ist also vom Typ Zeichenkette und Position ist eine ganze Zahl zwischen 0 und C.length. Es gibt keinen Rückgabewert, auf die neue Zeichenkette kann mit dem Attribut C.data zugegriffen werden.

  • C.replaceData(Anfang,Anzahl,Zeichenkette)

Die Methode ersetzt einen Teil des Textknotens C der Länge Anzahl ab Position Anfang mit der angegebenen Zeichenkette. Anfang und Anzahl sind nicht negative ganze Zahlen. Anfang liegt zwischen 0 und C.length-1. Ist der zu entfernende Teil größer als die Zeichenkette im Textknoten, wird bis zum Ende des Textknotens entfernt. An die Stelle des entfernten Teils wird die angegebene Zeichenkette gesetzt. Es gibt keinen Rückgabewert, auf die neue Zeichenkette kann mit dem Attribut C.data zugegriffen werden.

  • C.substringData(Anfang,Anzahl)

Die Methode erlaubt den Zugriff auf eine Teilzeichenkette des Textknotens C der Länge Anzahl ab Position Anfang. Anfang und Anzahl sind nicht negative ganze Zahlen. Anfang liegt zwischen 0 und C.length-1. Ist der angegebene Bereich länger als bis zum Ende der Zeichenkette, so geht die Teilzeichenkette nur bis zum Ende der Zeichenkette. Rückgabewert ist eine Zeichenkette, die der Teilzeichenkette entspricht.

Beispiel[Bearbeiten]

<?xml version="1.0" encoding="utf-8" ?>
<svg xmlns="http://www.w3.org/2000/svg" version="1.1" 
     xml:lang="de" viewBox="-300 -100 600 200">
<title>Skript-Test zum Schnittstelle 'CharacterData'</title>
<desc>
Bei Skriptinterpretation wird auf irgendeinen Text zugegriffen, 
auf diesen werden verschiedene Attribute und Methoden angewendet
und das Ergebnis wird jeweils zur Kenntnisnahme ausgegeben.
</desc>

<text id="T" text-anchor="middle">Irgendein Text</text> 
 
<defs>
<script type="application/ecmascript">
// das Textelement  
var T = document.getElementById('T')
// Textknoten
var Tk=T.firstChild
// Daten davon
var text=Tk.data
// Länge, Anzahl der Zeichen
var lang=text.length
// Ausgabe
alert('Text: "'+text+'" Textlänge: '+lang)
// Text anhängen
Tk.appendData(' - noch mehr Text!')
text=Tk.data
lang=text.length
alert('Text: "'+text+'" Textlänge: '+lang)
// Teile des Textes entfernen
Tk.deleteData(17,5)
text=Tk.data
lang=text.length
alert('Text: "'+text+'" Textlänge: '+lang)
// Text einsetzen
Tk.insertData(17,'etwas ')
text=Tk.data
lang=text.length
alert('Text: "'+text+'" Textlänge: '+lang)
// Text ersetzen
Tk.replaceData(17,5,'noch')
text=Tk.data
lang=text.length
alert('Text: "'+text+'" Textlänge: '+lang)
// Teilzeichenkette
text=Tk.substringData(10,1)+Tk.substringData(18,1)+Tk.substringData(25,1)
lang=text.length
alert('Text: "'+text+'" Textlänge: '+lang)
// Text aufteilen
var Tk2= Tk.splitText(10)
text=Tk2.data
lang=text.length
alert('Text: "'+text+'" Textlänge: '+lang)
</script>
</defs>
</svg>

Attribut, Schnittstelle 'Attr'[Bearbeiten]

Die Schnittstelle dient dem Zugriff auf ein Attribut, also ein Objekt vom Typ 'Attr'. 'Attr' beerbt die Schnittstelle 'Node'.

Sei im Folgenden A ein Objekt vom Typ 'Attr', also ein Attribut.

Beispiel siehe Schnittstelle 'NamedNodeMap'.

Attribute[Bearbeiten]

  • A.name ist vom Typ Zeichenkette und nur lesbar.

Die Zeichenkette repräsentiert den Namen des Attributes, also etwa 'fill' für das Attribut fill.

  • A.ownerElement ist vom Typ 'Element' und ist nur lesbar.

Die Zeichenkette repräsentiert das Element, bei welchem das Attribut notiert ist. Falls es bei keinem Element notiert ist, ist der Wert null.

  • A.specified ist entweder true oder false und nur lesbar.

true liegt vor, wenn das Attribut bereits im Originaldokument notiert war, sonst false.

  • A.value ist vom Typ Zeichenkette und beinhaltet den Wert vom Attribut A.

Das Kern-DOM kümmert sich also nicht um anderweitig vorhandene Informationen über den möglichen oder erlaubten Wert, dies ist hier immer eine Zeichenkette, die gegebenfalls etwa in eine Zahl zu konvertieren ist.

  • A.isId ist nur lesbar und entweder true oder false (DOM Core 3).

Die Rückgabe hängt maßgeblich davon ab, ob das Darstellungsformat die Funktion des betreffenden Attributes kennt oder nicht. Falls das Attribut wie id in (X)HTML oder SVG zur Aufnahme eines Fragmentidentifizierers dient, so ist der zurückgegebene Wert true, sonst false.

  • A.schemaTypeInfo ist nur lesbar und vom Typ 'TypeInfo' (DOM Core 3).

Das Attribut gibt Auskunft über den Typ des Attributes.

Element, Schnittstelle 'Element'[Bearbeiten]

Die Schnittstelle dient dem Zugriff auf ein Element, also ein Objekt vom Typ 'Element'. 'Element' beerbt die Schnittstelle 'Node'.

Sei im Folgenden E ein Objekt vom Typ 'Element', also ein Element.

Attribute[Bearbeiten]

  • E.tagName ist vom Typ Zeichenkette und nur lesbar.

Die Zeichenkette repräsentiert den Namen eines Elementes, also etwa 'circle' für das Element circle. Man beachte dabei, dass im Falle von HTML der Elementname aus traditionellen Gründen immer in Großbuchstaben genannt wird. Bei XML ist das nicht der Fall, also insbesondere nicht bei XHTML. Möchte man also ein Skript sowohl für HTML als auch für XHTML gemeinsam verwenden, so ist es notwendig, die Zeichenkette in Kleinbuchstaben zu konvertieren, bevor man sie weiterverwendet.

  • E.schemaTypeInfo ist ein nur lesbares Objekt vom Typ 'TypInfo' (DOM Core 3).

Methoden[Bearbeiten]

  • E.getAttributeNS(Namensraum,Attributname), E.getAttribute(Attributname)

Die Methode erlaubt den Zugriff auf den Attributwert des angegebenen Attributes des Elementes. Der erste Parameter ist die Namensraumangaben, die zweite der Attributname, beides sind Zeichenketten. Bei der einfachen Variante entfällt natürlich die Angabe des Namensraumes.

Rückgabewert ist eine Zeichenkette mit dem Attributwert, sofern vorhanden, sonst ist der Rückgabewert der voreingestellte Wert des Attributes, sofern vorhanden, sonst eine leere Zeichenkette.

  • E.getAttributeNodeNS(Namensraum,Attributname), E.getAttributeNode(Attributname)

Die Methode erlaubt den Zugriff auf den Attributknoten des angegebenen Attributes des Elementes. Der erste Parameter ist die Namensraumangaben, die zweite der Attributname, beides sind Zeichenketten. Bei der einfachen Variante entfällt natürlich die Angabe des Namensraumes.

Rückgabewert ist der Attributknoten vom Typ 'Attr', sofern vorhanden, sonst null.

  • E.getElementsByTagNameNS(Namensraum,Elementname), E.getElementsByTagName(Elementname)

Mit der Methode werden alle Nachfahren vom Element 'E' in eine Liste vom Typ 'NodeList' eingetragen, die als Rückgabewert verfügbar ist. Der erste Parameter ist die Namensraumangaben, die zweite der Attributname, beides sind Zeichenketten. Bei der einfachen Variante entfällt natürlich die Angabe des Namensraumes. Wie bei der gleichnamigen Methode für 'document' kann auch hier für Namensraum oder Elementname auch jeweils ein '*' angegeben werden, um alle Nachfahren zu bekommen.

Das Attribut 'length' der zurückgegebenen 'NodeList' hat den Wert 0, es gibt also keinen gültigen Index, eine Untersuchung der Liste ergibt dann also immer den Wert null.

  • E.hasAttributeNS(Namensraum,Attributname), E.hasAttribute(Attributname)

Mit der Methode wird abgefragt, ob das Element 'E' das angegebene Attribut hat. Attributname ist dabei eine Zeichenkette für den Attributnamen, wie gehabt Namensraum eine Zeichenkette für den Namensraum.

true wird zurückgegeben, wenn das Attribut bei dem Element 'E' gesetzt ist oder aber per Voreinstellung das Attribut einen Wert hat, sonst false.

  • E.removeAttributeNS(Namensraum,Attributname), E.removeAttribute(Attributname)

Mit der Methode wird ein gesetzter Attributwert entfernt, beziehungsweise, sofern eine Voreinstellung vorhanden ist, auf diese gesetzt. Attributname ist dabei eine Zeichenkette für den Attributnamen, wie gehabt Namensraum eine Zeichenkette für den Namensraum.

Einen Rückgabewert gibt es nicht.

  • E.removeAttributeNode(Attributknoten)

Mit der Methode wird ein gesetzter Attributknoten entfernt, beziehungsweise, sofern eine Voreinstellung für den Attributwert vorhanden ist, wird der Wert auf diese gesetzt. Attributknoten ist dabei ein Attributknoten vom Typ 'Attr', der Namensraum wird gegebenenfalls automatisch bestimmt.

Rückgabewert ist ein Knoten vom Typ 'Attr' mit dem entfernten Attributknoten.

  • E.setAttributeNS(Namensraum,Attributname,Attributwert), E.setAttribute(Attributname,Attributwert)

Die Methode erlaubt das Setzen des Attributes und des Attributwertes des angegebenen Attributes des Elementes. Sofern es das Attribut schon gibt, wird nur der Attributwert neu gesetzt. Der erste Parameter ist die Namensraumangabe, der zweite der Attributname, der dritte der Attributwert, alles sind Zeichenketten. Bei der einfachen Variante entfällt natürlich die Angabe des Namensraumes.

Einen Rückgabewert gibt es nicht.

  • E.setAttributeNodeNS(Attributknoten), E.setAttributeNode(Attributknoten)

Die Methode erlaubt das Setzen des Attributknotens des angegebenen Attributes des Elementes. Sofern es den Attributknoten schon gibt, wird der alte ersetzt. Der Parameter Attributknoten ist vom Typ 'Attr'.

Der Rückgabewert ist ein Knoten vom Typ 'Attr'. Sofern ein vorhandener Knoten ersetzt wurde, wird dieser zurückgegeben, sonst null.

Zu beachten ist, dass ein bereits bei einem anderen Element gesetzter Attributknoten nicht erneut gesetzt werden darf, sonst gibt es eine Fehlermeldung.

  • E.setIdAttributeNS(Namensraum,Name,ID), E.setIdAttribute(Name,ID) (DOM Core 3)

Mit der Methode kann ein vom Autor definierter Fragmentidentifizierer als solcher gekennzeichnet werden oder diese Zuordnung kann wieder entfernt werden. Offenbar dient die Zeichenkette Namensraum dazu, einen Namensraum anzugeben, die Zeichenkette Name dient dazu, den Namen des Attributes anzugeben. ID ist auf true zu setzen, wenn das Attribut als solch ein Fragmentidentifizierer verwendet werden soll, false wenn nicht.

Einen Rückgabewert gibt es nicht.

Hintergrund ist, dass Darstellungsprogramme bei beliebigen XML-Formaten nicht notwendig wissen, welches Attribut als Fragmentidentifizierer dient, etwa weil sie das zugehörige Schema des Formates nicht kennen oder es ignorieren. Auch der für XML generische Fragmentidentifizierer xml:id ist nicht allgemein beliebt oder erwünscht. So ergibt sich hier unabhängig von den Geschmackseinstellungen von Entwicklern von Darstellungsprogrammen und auch unabhängig von Schemata jedenfalls für das DOM die Möglichkeit, ein Attribut als Fragmentidentifizierer zu kennzeichnen. Natürlich sollten im Dokument dann auch die Werte eines solchen Attributes bei verschiedenen Elementen unterschiedlich gesetzt sein, um die Aufgabe wahrnehmen zu können.

  • E.setIdAttributeNode(Attr,ID) (DOM Core 3)

Die Methode ähnelt den zuvor beschriebenen, nur erfolgt hier die Zuordnung direkt über einen Attributknoten, nicht über den Namen und den Namensraum. Entsprechend ist Attr ein Objekt vom Typ 'Attr' für das Attribut mit der Funktion eines vom Autor definierten Fragmentidentifizierers. ID ist auf true zu setzen, wenn das Attribut als solch ein Fragmentidentifizierer verwendet werden soll, false wenn nicht.

Einen Rückgabewert gibt es nicht.


Beispiel[Bearbeiten]

<?xml version="1.0" encoding="utf-8" ?>
<svg xmlns="http://www.w3.org/2000/svg" version="1.1" 
     xml:lang="de" viewBox="-200 -200 400 400">
<title>Skript-Test zu den Schnittstelle 'Element'</title>
<desc>
  Bei Skriptinterpretation werden Attribute und Methoden 
  der DOM-Schnittstelle 'Element' an einem inhaltlich 
  belanglosen Beispiel eines Kreises mit Titel und
  Beschreibung durchprobiert.
</desc>
 
<circle id="c" cx="0" cy="0" r="100" 
  fill="#af0" stroke="#041" 
  stroke-width="20" stroke-opacity="0.5">
    <title>Testkreis</title>
    <desc>Dieser Testkreis hat keine inhaltliche Bedeutung.</desc>
</circle>
 
<defs>
<script type="application/ecmascript">
// Element finden und identifizieren  
var c= document.getElementById('c')
// Name des Elementes (hier natürlich 'circle')
var ename=c.tagName
var text='Element: '+ename
// Wert des Attributes stroke-opacity
var so=c.getAttributeNS(null,'stroke-opacity')
text+='\nstroke-opacity: '+so
// Knoten für das Attribut stroke, ist vom Typ Attr
var st= c.getAttributeNodeNS(null,'stroke')
// Name und Wert
var stn=st.name
var stv=st.value
text+='\n'+stn+': '+stv
// title-Kindelement-Liste heraussuchen
var ct=c.getElementsByTagNameNS('http://www.w3.org/2000/svg','title')
// Inhalt des Titels
var title=ct.item(0).firstChild.data
text+='\nTitel: '+title
// dito Beschreibung...
var cd=c.getElementsByTagNameNS('http://www.w3.org/2000/svg','desc')
// Inhalt des Titels
var desc=cd.item(0).firstChild.data
text+='\nBeschreibung: '+desc

// Hat das Element ein Attribut r notiert? (offenbar ja/true)
var hatr= c.hasAttributeNS('http://www.w3.org/2000/svg','r')
// Hat das Element ein Attribut e 
// aus dem Namensraum 'meinRaum' notiert? (offenbar nein/false)
var hate= c.hasAttributeNS('meinRaum','e')
text+='\nAttribut r vohanden?: '+hatr
text+='\nAttribut e aus dem Namensraum "meinRaum" vohanden?: '+hate
// Info zur Kenntnis bringen
alert(text)
// Attribut entfernen
c.removeAttributeNS(null,'fill')
var hatf= c.hasAttributeNS('http://www.w3.org/2000/svg','fill')
text='Attribut fill noch vorhanden? '+hatf
// Attributknoten für stroke, siehe oben, entfernen
c.removeAttributeNode(st)
// sollte nun kein Attribut stroke mehr haben...
var hats= c.hasAttributeNS('http://www.w3.org/2000/svg','stroke')
text+='\nAttribut stroke noch vorhanden? '+hats
alert(text)
// schwarzer Kreis ist langweilig, also fill und stroke wieder setzen
c.setAttributeNS(null,'fill','#fcd')
c.setAttributeNodeNS(st)
</script>
</defs>
</svg>


Text, Schnittstelle 'Text'[Bearbeiten]

Dies ist eine Schnittstelle für Textinhalte. Die Schnittstelle 'CharacterData' wird beerbt.

Sei im Folgenden T ein Objekt vom Typ 'Text'.

Beispiel siehe auch Schnittstelle 'CharacterData'.

Attribute[Bearbeiten]

  • T.isElementContentWhitespace (DOM Core 3)

Die Rückgabe ist true, falls ein Text-Knoten nur Leerzeichen enthält, false sonst.

  • T.wholeText (DOM Core 3)

Rückgabe ist eine Zeichenkette mit allen Zeichenketten eines Text-Knotens, einschließlich der Zeichenketten in allen Kindknoten in der Reihenfolge, wie sie im Quelltext stehen.

Methoden[Bearbeiten]

  • T.splitText(Position)

Die Methode teilt den Textknoten 'T' in zwei Geschwister-Knoten auf. Dies passiert an der Position 'Position'. Position ist eine nicht negative ganze Zahl. Der erste Knoten enthält die Zeichen von 0 bis einschließlich Position, der zweite Knoten den Rest. Wenn es keinen Rest gibt, ist der zweite Knoten ein leerer Knoten.

Rückgabewert ist der neue Knoten, der Typ ist derselbe wie für den alten.

  • T.replaceWholeText(Zeichenkette) (DOM Core 3)

Mit der Methode wird der komplette Textinhalt von T durch die angegebene Zeichenkette ersetzt. T darf kein Element als Inhalt haben, sonst gibt es eine Fehlermeldung. Rückgabe ist der Textknoten, der sich als neuer Textinhalt ergibt. Ist Zeichenkette leer, so wird allerdings null zurückgegeben. Ist hingegen der zu ersetzende Inhalt nur lesbar, so ist die Rückgabe der aktuelle Knoten


Kommentar, Schnittstelle 'Comment'[Bearbeiten]

Dies ist eine Schnittstelle für Kommentare, also was bei einem HTML- oder XML-Dokument zwischen folgenden Zeichenketten steht: '<!--' und '-->' Die Schnittstelle 'CharacterData' wird beerbt, Beispiel siehe sinngemäß dort.

Ansonsten hat die Schnittstelle keine speziellen Attribute oder Methoden.

CDATA-Bereich, Schnittstelle 'CDATASection'[Bearbeiten]

Dies ist eine Schnittstelle für CDATA-Bereiche. Die Schnittstelle ist nicht anwendbar für HTML. normalize der Schnittstelle 'Node' ist nicht anwendbar. Die Schnittstelle 'Text' wird beerbt, Beispiel siehe sinngemäß dort.

Ansonsten hat die Schnittstelle keine speziellen Attribute oder Methoden.

Dokumenttyp, Schnittstelle 'DocumentType'[Bearbeiten]

Die Schnittstelle ist nicht anwendbar für HTML. Jedes Dokument kann maximal eine Dokumenttypdeklaration haben. Die Schnittstelle erlaubt den Zugriff darauf.

Sei im Folgenden DTD dieses Objekt.

Attribute[Bearbeiten]

  • DTD.entities vom Typ 'NamedNodeMap', nur lesbar.

Rückgabe ist also eine Liste von Entitäten, die in der Dokumenttypdeklaration und der Dokumenttypdefinition angegeben sind.

  • DTD.internalSubset eine nur lesbare Zeichenkette für die interne Teilmenge, also offenbar was in der Dokumenttypdeklaration notiert ist.
  • DTD.name eine nur lesbare Zeichenkette für den Namen des Wurzelelementes, also der Begriff, der direkt auf 'DOCTYPE' folgt.
  • DTD.notations vom Typ ' NamedNodeMap', nur lesbar. Rückgabe ist eine Liste von Vermerken (notations). Jeder Knoten der Liste ist vom Typ 'Notation'.
  • DTD.publicId eine nur lesbare Zeichenkette für den öffentlichen Identifizierer der externen Teilmenge.
  • DTD.systemId eine nur lesbare Zeichenkette für den Systemidentifizierer der externen Teilmenge.

Vermerke, Schnittstelle 'Notation'[Bearbeiten]

Die Schnittstelle ist nicht anwendbar für HTML. Die Schnittstelle erlaubt den Zugriff auf die Vermerke in der DTD.

Sie im Folgenden V dieses Objekt.

Das Attribut 'nodeName' des zugehörigen Knotens des Vermerkes beinhaltet den Namen des Vermerkes.

Attribute[Bearbeiten]

  • V.publicId eine nur lesbare Zeichenkette für den öffentlichen Identifizierer.
  • V.systemId eine nur lesbare Zeichenkette für den Systemidentifizierer.

Entität, Schnittstelle 'Entity'[Bearbeiten]

Die Schnittstelle ist nicht anwendbar für HTML. Die Schnittstelle erlaubt den Zugriff auf Entitäten, also nicht auf deren Deklaration, sondern auf die Entitäten selbst.

Sei im Folgenden E ein Objekt des Typs 'Entity'.

Das Attribut 'nodeName' des zugehörigen Knotens der Entität beinhaltet den Namen der Entität.

Attribute[Bearbeiten]

  • E.notationName eine nur lesbare Zeichenkette.

Bei einer analysierten Entität ist dies null. Sonst ist es der Name des Vermerks der Entität.

  • E.publicId eine nur lesbare Zeichenkette für den öffentlichen Identifizierer mit der Eintität der externen Teilmenge.
  • E.systemId eine nur lesbare Zeichenkette für den Systemidentifizierer mit der Eintität der externen Teilmenge.
  • E.xmlEncoding ist eine nur lesbare Zeichenkette (DOM Core 3).

Die Zeichenkette enthält die XML-Kodierungsangabe zum Dokument, also etwa 'UTF-8', sofern bekannt, sonst null.

  • E.inputEncoding ist eine nur lesbare Zeichenkette (DOM Core 3).

Die Zeichenkette enthält eine Kodierungsangabe zur Zeit der Interpretation durch das Darstellungsprogramm, also etwa 'UTF-8', sofern bekannt, sonst null. Dies kann insofern von document.xmlEncoding abweichen, als Dienstprogramme davon abweichende, dann vermutlich falsche Informationen senden können. Durch Vergleich beider Angaben kann man offenbar Problemen mit Kodierungsangaben auf die Schliche kommen.

  • E.xmlVersion ist eine Zeichenkette (DOM Core 3).

Die Zeichenkette enthält die verwendete XML-Version, also entweder '1.0' oder '1.1', wobei sich letzteres wohl in der Praxis erledigt hat (1.0 wurde wohl insofern überarbeitet, dass 1.1 in der Praxis nicht gebraucht wird).


Entitäten-Referenz, Schnittstelle 'EntityReference'[Bearbeiten]

Die Schnittstelle ist nicht anwendbar für HTML. Die Schnittstelle erlaubt den nur lesbaren Zugriff auf Entitäten-Referenzen.

Die Schnittstelle hat keine speziellen Attribute oder Methoden.

Verarbeitungsanweisung, Schnittstelle 'ProcessingInstruction'[Bearbeiten]

Die Schnittstelle ist nicht anwendbar für HTML. Die Schnittstelle erlaubt den Zugriff auf Verarbeitungsanweisungen im Dokument.

Sei im Folgenden P ein Objekt des Typs 'ProcessingInstruction'.

Attribute[Bearbeiten]

  • R.target ist eine Zeichenkette, die das Ziel einer Verarbeitungsanweisung enthält.

Für XML-Verarbeitungsanweisungen ist dies also 'xml', für XML-Stilvorlagen-Verarbeitungsanweisungen ist dies entsprechend 'xml-stylesheet'.


  • R.data ist eine Zeichenkette, die den Inhalt einer Verarbeitungsanweisung enthält.

Der Inhalt ist der restliche Text in der Verarbeitungsanweisung, also ausgenommen das, was bereits mit R.target vermerkt ist. Für eine XML-Stilvorlagen-Verarbeitungsanweisungen ist das sinngemäß solch eine Zeichenkette: type="text/css" href="Mein.css" title="Mein CSS"' oder auch: 'type="text/css" href="css/Nachts.css" title="Nachts: hell auf dunkel" alternate="yes"'

Letzteres für R.data repräsentiert dann insgesamt mit R.target="xml-stylesheet" folgende Verarbeitungsanweisung:

<?xml-stylesheet 
  type="text/css" 
  href="css/Nachts.css" 
  title="Nachts: hell auf dunkel" 
  alternate="yes" ?>


Schnittstelle 'DOMUserData' (DOM Core 3)[Bearbeiten]

Die Schnittstelle dient der Angabe von Daten durch den Autor. In ECMAScript kann DOMUserData jeden Typ annehmen, der demzufolge vom Autor festgelegt wird. Für Java ist DOMUserData immer ein Objekt.


Schnittstelle 'DOMObject' (DOM Core 3)[Bearbeiten]

Die Schnittstelle dient der Angabe von Daten durch den Autor. In ECMAScript und Java ist DOMUserData ein Objekt.


Schnittstelle 'DOMStringList' (DOM Core 3)[Bearbeiten]

Die Schnittstelle definiert eine Liste von Zeichenketten, definiert allerdings keine näheren Details über diese Liste. Die Liste ist nur durchnumeriert, beginnend mit 0.

Sei L eine solche Liste

Attribut[Bearbeiten]

  • L.length ist eine nur lesbare ganze Zahl nicht kleiner als 0.

Der Index der Liste geht von 0 bis length-1.


Methoden[Bearbeiten]

  • L.contains(Zeichenkette)

Die Methode testet, ob die angegebene Zeichenkette in der Liste vorkommt. Rückgabe ist true falls ja, sonst nein.

  • L.item(Index)

Mit der Methode wird der Listenpunkt mit der Nummer Index ausgewählt. Index liegt also zwischen 0 und length-1, sonst wird null zurückgegeben. Wird der Listenpunkt gefunden, wird die zugehörige Zeichenkette zurückgegeben.


Schnittstelle 'NameList' (DOM Core 3)[Bearbeiten]

Die Schnittstelle definiert eine Listen von Paaren - Name und Namensraum (beides Zeichenketten), definiert allerdings keine näheren Details über diese Liste. Die Liste ist nur durchnumeriert, beginnend mit 0.

Sie N eine solche Liste.


Attribut[Bearbeiten]

  • N.length ist eine nur lesbare ganze Zahl nicht kleiner als 0.

Der Index der Liste geht von 0 bis length-1.


Methoden[Bearbeiten]

  • N.containsNS(Namensraum,Name), N.contains(Name)

Die Methode testet, ob der angegebene Name in der Liste vorkommt. Rückgabe ist true falls ja, sonst nein. Bei der Namensraumvariante kann auch der Namensraum bei der Suche berücksichtigt werden, ist das nicht der Fall, kann null angegeben werden.


  • N.getName(Index)

Mit der Methode wird auf den Listenpunkt mit der Nummer Index zugegriffen. Index liegt also zwischen 0 und length-1, sonst wird null zurückgegeben. Wird der Listenpunkt gefunden, wird die zugehörige Name als Zeichenkette zurückgegeben.


  • N.getNamespaceURI(Index)

Mit der Methode wird auf den Listenpunkt mit der Nummer Index zugegriffen. Index liegt also zwischen 0 und length-1, sonst wird null zurückgegeben. Wird der Listenpunkt gefunden, wird die zugehörige Namensraum als Zeichenkette zurückgegeben.


Schnittstelle 'DOMImplementationList' (DOM Core 3)[Bearbeiten]

Die Schnittstelle bietet eine Abstraktion implementierter Merkmale in Form einer Liste, definiert allerdings keine näheren Details über diese Liste. Die Liste ist nur durchnumeriert, beginnend mit 0.

Sei I eine solche Liste.


Attribut[Bearbeiten]

  • I.length ist eine nur lesbare ganze Zahl nicht kleiner als 0.

Der Index der Liste geht von 0 bis length-1.

Methode[Bearbeiten]

  • I.item(Index)

Mit der Methode wird der Listenpunkt mit der Nummer Index ausgewählt. Index liegt also zwischen 0 und length-1, sonst wird null zurückgegeben. Wird der Listenpunkt gefunden, wird das zugehörige Objekt vom Typ DOMImplementation zurückgegeben.


Schnittstelle 'DOMImplementationSource' (DOM Core 3)[Bearbeiten]

Darstellungsprogramme können mehrere Implementierungen anbieten, wobei das eigentlich nur relevant ist, wenn jüngere Implementierungen inkompatibel zu alten sind, in dem Sinne, daß Merkmale eine andere Bedeutung bekommen, was bei schlecht durchdachten oder fehlerhaften Implementierungen und Formate leicht vorkommen kann.

Sei S eine solche Quelle.

Methode[Bearbeiten]

  • S.getDOMImplementation(Merkmale)

Mit der Methode wird angegeben, welche Merkmale benötigt werden. Merkmale ist dabei eine Zeichenkette, eine mit Leerzeichen separierte Liste von Merkmalen, optional gefolgt von einem Leerzeichen und einer Versionsangabe. Zum Beispiel bedeutet "Core 3.0 Events 2.0" offenbar das Kernmodul in der Version 3, vom Ereignismodul reicht hingegen bereits Version 2.0.

Rückgabe ist ein Objekt vom Typ 'DOMImplementation', also eine Implementierung repräsentiert, welche die Anforderungen erfüllt. Ist keine solche vorhanden, ist der Rückgabewert null.


Schnittstelle 'TypeInfo' (DOM Core 3)[Bearbeiten]

Mit der Schnittstelle kann für Elemente und Attribute auf eine Charakterisierung des Typs zugegriffen werden, sofern dies über ein Schema verfügbar ist, insbesondere um diese Strukturen zu validieren.

Sei I ein Objekt vom Typ 'TypeInfo'


Attribute[Bearbeiten]

  • I.typeName ist eine nur lesbare Zeichenkette.

Rückgabe ist der Name der Typdeklaration, sofern vorhanden, sonst 0.

  • I.typeNamespace ist eine nur lesbare Zeichenkette.

Rückgabe ist der Namensraum der Typdeklaration, sofern vorhanden, sonst 0.


Methode[Bearbeiten]

  • I.isDerivedFrom(Namensraum,Name,Wie)

Mit der Methode kann bestimmt werden, ob es eine Abstammungsbeziehung zwischen I und Name gibt, also ob I von Name abstammt. Entsprechend ist Name also der Name einer anderen 'TypeInfo', Namensraum gegebenenfalls der zugehörige Namensraum, beides Zeichenketten. Wie gibt an, wie die Rückgabe bestimmt wird:

ZahlBezeichnung der zugehörigen KonstanteBedeutung
1DERIVATION_RESTRICTIONBei einem XML-Schema ist die Abstammung per Einschränkung zu bestimmen.
2DERIVATION_EXTENSIONBei einem XML-Schema ist die Abstammung per Erweiterung zu bestimmen.
4DERIVATION_UNIONBei einem XML-Schema ist die Abstammung per Vereinigung einfacher Typen zu bestimmen.
8DERIVATION_LISTBei einem XML-Schema repräsentiert dies eine Liste.

Treffen mehrere Dinge zu, kann addiert werden. Bei 0 ist die Abstammung durch Rekursion zu bestimmen. Hat man kein XML-Schema, sondern etwa eine DTD, so ist Wie offenbar belanglos.

Rückgabe ist true oder false. Handelt es sich beim Schema um eine DTD oder gibt es gar kein Schema, so trifft false zu. Bei einem XML-Schema wird true zurückgegeben, wenn die Abstammung wie mit Wie angegeben ist, sonst false.


Schnittstelle 'UserDataHandler' (DOM Core 3)[Bearbeiten]

Wenn ein Objekt mit einem Schlüssel für einen Konten K mittels K.setUserData() verknüpft wird, so kann eine Behandlungsfunktion vom Typ 'UserDataHandler' beim Duplizieren, Importieren, beim Ändern des Namens ausgeführt werden.

Sei U von diesem Typ.

Methode[Bearbeiten]

  • U.handle(Was,Schlüssel,Daten,Quelle,Ziel)

Diese Methode wird aufgerufen, wenn der Knoten, für welchen dieser Behandler definiert ist, dupliziert oder importiert wird.

Was ist eine Zahl, die angibt, was gemacht werden soll. Folgende Zahlen haben eine definierte Bedeutung:

ZahlBezeichnung der zugehörigen KonstanteBedeutung
1NODE_CLONEDDer Knoten wird dupliziert
2NODE_IMPORTEDDer Knoten wird importiert
3NODE_DELETEDDer Knoten wird gelöscht
4NODE_RENAMEDDer Name des Knotens wird geändert
5NODE_ADOPTEDDer Knoten wird adoptiert

Schlüssel ist eine Zeichenkette, die den Schlüssel angibt, für welchen der Behandler aufgerufen wird.

Daten ist vom Typ 'DOMUserData' und gibt die Daten an, für welche der Behandler aufgerufen wird.

Quelle ist null, wenn der Knoten gelöscht werden soll, ansonsten gibt es den Knoten an, der zum Duplizieren, Adoptieren, Importieren oder Ändern des Namens verwendet werden soll.

Ziel gibt den Zielknoten der Operation an, also den so neu erzeugten Knoten oder null.

Einen Rückgabewert gibt es nicht.


Schnittstelle 'DOMError' (DOM Core 3)[Bearbeiten]

Die Schnittstelle beschreibt im DOM gegebenenfalls auftretende Fehler.

Sei E ein Objekt vom Typ 'DOMError'.

Attribute[Bearbeiten]

  • E.location ist nur lesbar und vom Typ 'DOMLocator' und gibt an, wo der Fehler aufgetreten ist.
  • E.message ist eine nur lesbare Zeichenkette mit einer Beschreibung des Fehlers, welche je nach verwendetem Darstellungsprogramm unterschiedlich ausfalle kann.
  • E.relatedData ist nur lesbar und vom Typ 'DOMObject' und beinhaltet Daten, die vom Typ des Fehlers abhängig sind.
  • E.relatedException ist nur lesbar und vom Typ 'DOMObject' und gibt, sofern vorhanden, eine korrelierte Behandlung des Fehlers an.
  • E.severity ist eine nur lesbare Zahl 1,2 oder 3 und gibt an, wie schwerwiegend der Fehler ist.

1 steht für eine Warnung, 2 für einen Fehler, 3 für einen fatalen Fehler.

  • E.type ist eine nur lesbare Zeichenkette, die den Typ des Fehlers angibt.

Mit dem Attribut wird insbesondere angegeben, welche Daten für E.relatedData zu erwarten sind. Für jeden Fehler ist wiederum definiert, was der zugehörige Typ ist.


Schnittstelle 'DOMErrorHandler' (DOM Core 3)[Bearbeiten]

Die Schnittstelle dient der Fehlerbehandlung und wird aufgerufen, wenn ein Fehler aufgetreten ist.

Sei H vom Typ 'DOMErrorHandler'.

Methode[Bearbeiten]

  • H.handleError(Fehler)

Die Methode behandelt einen Fehler. Der Parameter Fehler ist vom Typ 'DOMError' und beschreibt den aufgetretenen Fehler.

Rückgabewert ist true, wenn das Skript weiterläuft, sonst falsch.


Schnittstelle 'DOMLocator' (DOM Core 3)[Bearbeiten]

Mit der Schnittstelle wird etwas lokalisiert, primär für Fehler verwendet.

Sei L vom Typ 'DOMLocator'.

Attribute[Bearbeiten]

  • L.byteOffset ist eine nur lesbare Zahl, die eine Lokalisierung im Quelltext in Bytes angibt oder -1, falls dies nicht verfügbar ist.
  • L.columnNumber ist eine nur lesbare Zahl, die eine Lokalisierung im Quelltext in Spalten angibt oder -1, falls dies nicht verfügbar ist.
  • L.lineNumber ist eine nur lesbare Zahl, die eine Lokalisierung im Quelltext in Zeilen angibt oder -1, falls dies nicht verfügbar ist.
  • L.relatedNode ist nur lesbar und vom Typ 'Node', das ist der Knoten, worin die zu lokalisierende Stelle zu finden ist oder null, falls solch ein Knoten nicht verfügbar ist.
  • L.uri ist eine nur lesbare Zeichenkette mit IRI/URI mit der zu lokalisierenden Stelle, null falls diese nicht verfügbar ist.
  • L.utf16Offset ist eine nur lesbare Zahl, die eine Lokalisierung im Quelltext per Versatz nach UTF-16 oder -1, falls dies nicht verfügbar ist.


Schnittstelle 'DOMConfiguration' (DOM Core 3)[Bearbeiten]

Die Schnittstelle verwaltet eine Liste von Parametern zur Normalisierung von Dokumenten mit der Methode document.normalizeDocument().

Sei C ein Objekt von diesem Typ.

Attribute[Bearbeiten]

  • C.parameterNames ist nur lesbar und vom Typ 'DOMStringList'.

Die Liste beinhaltet die interpretierten Parameter.

Methoden[Bearbeiten]

  • C.canSetParameter(Name,Wert)

Testet, ob Name und Wert eines Parameters gesetzt werden können, ohne dies selbst zu tun. Name ist der Name des Parameters, Wert sein Wert. Name ist eine Zeichenkette, Wert ist vom Typ 'DOMUserData'. Rückgabe ist true, wenn das Setzen geklappt, false wenn nicht.

  • C.getParameter(Name)

Gibt den Wert des mit der Zeichenkette Name angegebenen Parameters zurück, sofern vorhanden, sonst null. Der Rückgabewert ist vom Typ DOMUserData.


  • C.setParameter(Name,Wert)

Setzt Name und Wert eines Parameters. Name ist der Name des Parameters, Wert sein Wert. Name ist eine Zeichenkette, Wert ist vom Typ 'DOMUserData' oder null, um den aktuellen Wert zu löschen. Einen Rückgabewert gibt es nicht.