MDN’s new design is in Beta! A sneak peek: https://blog.mozilla.org/opendesign/mdns-new-design-beta/

Diese Übersetzung ist unvollständig. Bitte helfen Sie, diesen Artikel aus dem Englischen zu übersetzen.

Diese Sektion bietet eine kurze, konzeptuelle Einführung in das DOM: was es ist, wie es Struktur für HTML und XML Dokumente bietet, wie man darauf zugreifen kann, und wie diese API die Referenz-Information und Beispiele präsentiert. 

Was ist das DOM?

Das Document Object Model (DOM) ist eine Programmier-Schnittstelle für HTML und XML Dokumente. Es liefert eine strukturierte Repräsentation von dem Dokument und bietet Möglichkeiten die Struktur von einem Programm anzusprechen, sodass die Dokument-Struktur, Stil und Inhalt von diesem verändert werden kann. Das DOM bietet die Repräsentation des Dokuments als strukturierte Gruppe von Knoten (nodes) und Objekten, welche Eigenschaften und Methoden haben. Essentiell ist, dass es eine Verbindung von Webseiten mit den Skripte oder Programmiersprachen bietet.

Eine Webseite ist ein Dokument. Diese kann entweder im Browser-Fenster angzeigt werden, oder dessen HTML-Quellcode. In beiden Fällen ist es das gleiche Dokument. Das Dokument Objekt Modul (DOM) bietet einen anderen Weg zum Represäntieren, Lagern und Manipulieren von diesem Dokument. Das DOM ist eine vollkommen objekt-orientierte Repräsentation einer Webseite und kann mit Skript-Sprachen wie JavaScript modifiziert werden.

Der W3C DOM Standard formte die Basis für die Implementierung des DOM in den meisten modernen Browsern. Viele Browser bieten Erweiterung außerhalb vom W3C-Standard an, sodass Obacht beim Benutzen dieser im Web geboten werden sollte, da Dokumente vielleicht von verschiedenen Browsern unterschiedliche DOMs haben.

Als Beispiel definiert das W3D DOM die getElementsByTagName Methode und dessen Ausgabewert als eine Liste aller <p>-Elemente in dem Dokument:

var paragraphs = document.getElementsByTagName("P");
// paragraphs[0] is the first <p> element
// paragraphs[1] is the second <p> element, etc.
alert(paragraphs[0].nodeName);

Alle diese Eigenschaften, Methoden und Events werden als organisierte Objekte vom DOM zur Verfügung gestellt und dienen der Manipulation und dem Erstellen von Webseiten. Als Beispiel: das document Objekt, welches sich selbst repräsentiert, das table Objekt, welches die spezielle HTMLTableElement DOM-Eingabemaske für den Zugriff von HTML-Tabellen bietet, usw). Diese Dokumentation bietet eine von Objekt-zu-Objekt Referenz der DOM implementierten und Gecko-basiertem Browsern (z.B. Firefox).

DOM und JavaScript

Das kurze Beispiel oberhalb, wie nahezu alle Beispiele in dieser Referenz, ist JavaScript. Das heißt es ist in JavaScript geschrieben, aber es nutzt das DOM um Zugriff auf das Dokument und seine Elemente zu erhalten. Das DOM ist keine Programmiersprache, aber ohne dieses würde JavaScript überhaupt kein Model oder Darstellung der Web-Seite, XML-Seite und dessen Elemente haben, um welche es sich normalerweise kümmert. Jedes Element in einem Dokument - das Dokuement als Ganzes, der Kopf, Tabellen innerhalb des Dokuments, Tabellen-Köpfe, Text innerhalb der Tabellen-Zellen - sind Teile des Dokument-Objekt-Moduls für das Dokument. Also können diese alle über das DOM und einer Skriptsprache wie JavaScript angesprochen und manipuliert werden.

Am Anfang war JavaScript und das DOM stark verflochten, aber schließlich haben sich in eigenständiges Dasein entwickelt. Der Seiteninhalt wird im DOM gelagert und kann via JavaScript angesprochen und manipuliert werden, sodass wir diese ungefähre Gleichung schreiben können:

API (web or XML page) = DOM + JS (scripting language)

Das DOM wurde kreiert ohne eine Abhängigkeit von irgendeine spezielle Programmiersprache zu haben, welche die Struktur eines Dokuments repräsentiert und diese als eine einzelne, konsistente API (Programmierschnittstelle) zur Verfügung stellt. Obwohl wir uns in dieser Dokumentation speziell auf JavaScript konzentrieren, können die Inhalte des  DOM von jeder Programmiersprache, wie z.B. Python, genutzt werden - was dieses Beispiel demonstriert:

# Python DOM example
import xml.dom.minidom as m
doc = m.parse("C:\\Projects\\Py\\chap1.xml");
doc.nodeName # DOM property of document object;
p_list = doc.getElementsByTagName("para");

Für weitere Informationen darüber, welche Technologien in das Schreiben von JavaScript im Web involviert sind, siehe JavaScript Technologie Übersicht.

 

Wie greife ich auf das DOM zu?

Du brauchst nichts besonderes machen um das DOM zu nutzen. Verschiedene Browser haben unterschiedliche Ausführungen vom DOM, und diese Ausführungen  weisen unterschiedliche Konformitätsgrade des eigentlichen DOM Standards auf - ein Thema, welches wir in dieser Dokumentation vermeiden zu versuchen. Aber jeder Browser benutzt ein Dokument-Objekt-Modl um eine Webseite für Skripte zugänglich zu machen.

Wenn du ein Skript erstellst - ob in-line im <script>-Element oder eingebunden in der Webseite, das bedeutet von einer Anweisung, welches ein Skript lädt, - kannst du die API sofort nutzen um die document oder window Elemente des Dokuments selbst zu manipulieren oder zu dessen Kind-Elemente zu gelangen, welche eine Vielzahl an Elementen in einer Webseite sind. Deine DOM-Programmierung könnte vielleicht so simpel sein wie das Folgende, welches eine Aufruf-Nachricht (alert message) beim Ausführen der alert() Funktion von dem window Objekt ist. Oder du nutzt anspruchsvollere DOM-Methoden um neue Inhalte zu erstellen, wie im folgenden Beispiel unterhalb.

<body onload="window.alert('welcome to my home page!');">

Neben dem <script> Element, in welchem das JavaScript definiert ist, setzt dieses JavaScript eine Funktion in Gange, wenn das Dokument geladen ist (und wenn das ganze DOM zum Gebrauch erreichbar ist).

Diese Funktion erstellt ein neues H1 Element, fügt Text zum Element, und dann fügt es die H1 in den Baum des Dokuments hinein:

<html>
  <head>
    <script>
       // Diese Funktion ausführen, wenn das Dokument geladen ist.
       window.onload = function() {

       // Erstellen Sie ein paar Elemente in einer ansonsten leeren HTML-Seite
       var heading = document.createElement("h1");
       var heading_text = document.createTextNode("Big Head!");
       heading.appendChild(heading_text);
       document.body.appendChild(heading);
      }
    </script>
  </head>
  <body>
  </body>
</html>

Wichtige Daten-Typen

Diese Dokumenation versucht eine vielzahl an Objekten und Typen so leicht wie möglich zu erklären. Aber es gibt eine Anzahl verschiedener Daten-Typen, welche sich rund um die API behandelt werden - also achte darauf. Einfachheitshalber sind die Syntax-Beispiele in dieser API-Referenz referenzieren typischerweise an nodes (Knoten) als Elemente, an Arrays von nodes als nodeLists (oder einfach elements), und an Attribut-Knoten (attribute nodes), einfach als attributes.

Die folgende Tabelle beschreibt kurz diese Daten-Typen:

document

Wenn ein Mitglied ein Objekt des Typs document wiedergibt (z.B. die ownerDocument Eigenschaft eines Elements gibt das document wieder, zu welchem es gehört), ist diese Objekt das oberste document Objekt selbst. Das Kapitel DOM document Referenz  beschreibt  das document Objekt.

element

element gehört zu einem Element oder einer node des Typs element, wiedergegeben von einem Mitglied der DOM API. Anstatt zu sagen, dass die document.createElement() Methode ein Objekt wiedergibt, welches zu einer node referenziert wird, sagen wir dass die Methode ein element wiedergibt, dass gerade in dem DOM erstellt wurde. Element Objekte implementieren das DOM Element-Interface und ebenso das einfachere Node-Interface, welche diese Referenz beide beinhaltet.

nodeList

Eine nodeList ist eine Ansammlung von Elementen, ähnlich wie diese von der Methode document.getElementsByTagName() zurückgegeben werden. Inhalte in einer nodeList werden könne auf zwei Wegen anhand des Indexes angesprochen werden. Diese beiden sind gleichwertig:

  • list.item(1)
  • list[1]

Im Ersten item() ist die einzelne Methode auf das nodeList Objekt. Das Zeichen nutzt die typische Array-Syntax um den zweiten Inhalt in der Liste abzuholen.

attribute When an attribute is returned by a member (e.g., by the createAttribute() method), it is an object reference that exposes a special (albeit small) interface for attributes. Attributes are nodes in the DOM just like elements are, though you may rarely use them as such.
namedNodeMap

Eine namedNodeMap ist wie ein Array. Aber die Inhalte werden beim Namen oder Index angesprochen. Obwohl dieser letztere Fall nur eine Bequemlichkeit für die Aufzählung ist, da sie in keiner bestimmten Reihenfolge in der Liste sind. Eine namedNodeMap hat eine item() Methode für diesen Fall - du kannst ebenfalls Inhalte zu einer namedNodeMap hinzufügen oder entfernen.

DOM Schnittstellen

This guide is about the objects and the actual things you can use to manipulate the DOM hierarchy. It's often a matter of indifference that the object representing the HTML FORM element gets its name property from the HTMLFormElement interface but its className property from the HTMLElement interface proper. In both cases, the property you want is simply in the form object.

But the relationship between objects and the interfaces that they implement in the DOM can be confusing, and so this section attempts to say a little something about the actual interfaces in the DOM specification and how they are made available.

Schnittstellen und Objekte

Many objects borrow from several different interfaces. The table object, for example, implements a specialized HTML Table Element Interface, which includes such methods as createCaption and insertRow. But since it's also an HTML element, table implements the Element interface described in the DOM element Reference chapter. And finally, since an HTML element is also, as far as the DOM is concerned, a node in the tree of nodes that make up the object model for a web page or an XML page, the table element also implements the more basic Node interface, from which Element derives.

When you get a reference to a table object, as in the following example, you routinely use all three of these interfaces interchangeably on the object, perhaps without knowing it.

var table = document.getElementById("table");
var tableAttrs = table.attributes; // Node/Element interface
for (var i = 0; i < tableAttrs.length; i++) {
  // HTMLTableElement interface: border attribute
  if(tableAttrs[i].nodeName.toLowerCase() == "border")
    table.border = "1"; 
}
// HTMLTableElement interface: summary attribute
table.summary = "note: increased border";

Interne Schnittstellen des DOM

This section lists some of the most commonly-used interfaces in the DOM. The idea is not to describe what these APIs do here but to give you an idea of the sorts of methods and properties you will see very often as you use the DOM. These common APIs are used in the longer examples in the DOM Examples chapter at the end of this book.

Document and window objects are the objects whose interfaces you generally use most often in DOM programming. In simple terms, the window object represents something like the browser, and the document object is the root of the document itself. Element inherits from the generic Node interface, and together these two interfaces provide many of the methods and properties you use on individual elements. These elements may also have specific interfaces for dealing with the kind of data those elements hold, as in the table object example in the previous section.

The following is a brief list of common APIs in web and XML page scripting using the DOM.

Das DOM API testen

This document provides samples for every interface that you can use in your own web development. In some cases, the samples are complete HTML pages, with the DOM access in a <script> element, the interface (e.g, buttons) necessary to fire up the script in a form, and the HTML elements upon which the DOM operates listed as well. When this is the case, you can cut and paste the example into a new HTML document, save it, and run the example from the browser.

There are some cases, however, when the examples are more concise. To run examples that only demonstrate the basic relationship of the interface to the HTML elements, you may want to set up a test page in which interfaces can be easily accessed from scripts. The following very simple web page provides a <script> element in the header in which you can place functions that test the interface, a few HTML elements with attributes that you can retrieve, set, or otherwise manipulate, and the web user interface necessary to call those functions from the browser.

You can use this test page or create a similar one to test the DOM interfaces you are interested in and see how they work on the browser platform. You can update the contents of the test() function as needed, create more buttons, or add elements as necessary.

<html>
  <head>
    <title>DOM Tests</title>
    <script type="application/javascript">
    function setBodyAttr(attr,value){
      if (document.body) eval('document.body.'+attr+'="'+value+'"');
      else notSupported();
    }
    </script>
  </head> 
  <body>
    <div style="margin: .5in; height: 400;"> 
      <p><b><tt>text</tt>color</b></p> 
      <form> 
        <select onChange="setBodyAttr('text',
        this.options[this.selectedIndex].value);"> 
          <option value="black">black 
          <option value="darkblue">darkblue 
        </select>
        <p><b><tt>bgColor</tt></b></p>
        <select onChange="setBodyAttr('bgColor',
        this.options[this.selectedIndex].value);"> 
          <option value="white">white 
          <option value="lightgrey">gray
        </select>
        <p><b><tt>link</tt></b></p> 
        <select onChange="setBodyAttr('link',
        this.options[this.selectedIndex].value);">
          <option value="blue">blue
          <option value="green">green
        </select>  <small>
        <a href="http://www.brownhen.com/dom_api_top.html" id="sample">
        (sample link)</a></small><br>
      </form>
      <form>
        <input type="button" value="version" onclick="ver()" />
      </form>
    </div>
  </body>
</html>

To test a lot of interfaces in a single page-for example, a "suite" of properties that affect the colors of a web page-you can create a similar test page with a whole console of buttons, textfields, and other HTML elements. The following screenshot gives you some idea of how interfaces can be grouped together for testing.

Bild 0.1 Beispiel DOM Test Seite
Image:DOM_Ref_Introduction_to_the_DOM.gif

In this example, the dropdown menus dynamically update such DOM-accessible aspects of the web page as its background color (bgColor), the color of the hyperlinks (aLink), and color of the text (text). However you design your test pages, testing the interfaces as you read about them is an important part of learning how to use the DOM effectively.

Schlagwörter des Dokuments und Mitwirkende

Schlagwörter: 
 Mitwirkende an dieser Seite: StevenS77, carodb, Patrick_St.
 Zuletzt aktualisiert von: StevenS77,