Sprachen in JavaScript
- Beispieldokument für diese Lektion
userpage.fu-berlin.de/~ram/pub/xhtml_jf47ht81Ht/main
Sprachen
Wir haben schon gesehen, daß bestimmte Seiten die Bedeutung bestimmter Wörter beschreiben.
developer.mozilla.org/en/docs/Web/API/NodenodeType
- Art des Kontexts als Zahl (1=Element, 3=Text, 8 = Kommentar, 9=Dokument)
nodeName
- Der Name des Typs des Kontexts
developer.mozilla.org/en/docs/Web/API/ParentNodefirstElementChild
- Das erste im Kontext enthaltene Element
Wir können sagen, daß solch eine Seite einem Wort eine Bedeutung gibt und nennen solche Seiten daher auch Sprachen, um etwas unabhängiger von der Aufteilung der Informationen auf Seiten zu werden. Bei einer Sprache kommt es nicht mehr auf die Aufteilung auf Seiten an, eine Sprache ist eine benannte Liste von Wörtern mit jeweils einer Erklärung zu jedem Wort.
- Die Sprache »Node«
nodeType
- Art des Kontexts als Zahl (1=Element, 3=Text, 8 = Kommentar, 9=Dokument)
nodeName
- Der Name des Typs des Kontexts
- Die Sprache »ParentNode«
firstElementChild
- Das erste im Kontext enthaltene Element
Etymologie Der Begriff „Sprache“ kommt daher, daß eine Sprache etwas ist, daß einem Wort seine Bedeutung gibt. Beispielsweise gibt die englische Sprache dem Wort “locker ” die Bedeutung „Schließfach“, und die deutsche „lose“.
Die Sprachen dienen zunächst zur Information von Programmierern, also von Menschen, über die Bedeutung von Wörtern. Sie können nicht unbedingt auch in einem JavaScript -Ausdruck verwendet werden (obwohl später zur Veranschaulichung einige Beispiele gezeigt werden werden, in denen Sprachen teilweise in einem JavaScript -Ausdruck verwendet werden werden). Sprachen in dem hier vorgestellten Sinne sind aber nicht das gleiche wie „Programmiersprachen“ (wie JavaScript ) oder „natürliche Sprachen“ (wie Deutsch).
Quellen für die einzelnen Sprachen
Die folgende Quelle ist die maßgebliche Beschreibung des DOM und der Sprachen »Node« und »ParentNode« einschließlich der Klausel zu »nodeType«, »nodeName« und »firstElementChild«. Diese Beschreibung sollte für alle modernen Browser gelten, aber es könnte sein, daß es Browser gibt, die sie nicht richtig umgesetzen.
- Quelle
- http://www.w3.org/TR/dom/
Die folgende Quelle ist die Beschreibung des Lemmas »Node« vom Hersteller des Browsers Firefox.
- Quelle
- http://developer.mozilla.org/en/docs/Web/API/Node/nodeType
Obwohl ein Browser im Idealfall alles aus der Seite »http://www.w3.org/TR/dom/« genau umsetzen sollte, ist es doch möglich, daß er manchmal davon abweicht. Deswegen muß man, um das DOM eines speziellen Browsers programmieren zu können, manchmal auch noch die Dokumentation des Herstellers des Browsers heranziehen.
Im DOM gibt es neben »nodeType«, »nodeName« und »firstElementChild« auch noch viele andere interessante Einträge, von denen einige im weiteren Verlauf dieses Kurses noch vorgestellt werden.
Das folgenden Begriffssystem zur Beschreibung von Teilen der Dokumentation wird in den zehner Jahren entwickelt. Während dieser Entwicklung ist es möglich, daß die darin vorkommenden Begriffe („Lemma“, „Oberfläche“, „Proklamation“, „Prosa“, „Klausel“ und so weiter) in verschiedenen Quellen noch nicht einheitlich verwendet werden.
Klauseln
Den Teil einer Sprache, welcher die Bedeutung eines bestimmten Wortes festlegt, nennen wir auch eine Klausel. Eine Sprache ist dann eine Liste von Klauseln, weswegen wir sie auch manchmal als eine Klauselsprache bezeichnen.
- Die Klausel zu »nodeType« aus der Sprache »Node«
nodeType
- Art des Kontexts als Zahl (1=Element, 3=Text, 8 = Kommentar, 9=Dokument)
Etymologie Der Begriff „Klausel“ kommt daher, daß in der Informatik solche Angaben auch als „Kontrakt“ bezeichnet werden. Der Begriff „Kontrakt“ konnte hier aber nicht verwendet werden, da ein spezieller Begriff für den Kontrakt zu einem einzelnen Wort benötigt wurde. Da Teile eines Kontraktes (also eines Vertrags) oft als „Klauseln“ bezeichnet werden, wurde hier jener Begriff gewählt.
Lemmata
Die einzelnen Wörter einer Sprache nennen wir auch Lemmata der Sprache.
Beispielsweise ist »nodeType« ein Lemma der Sprache »Node«.
- Lemmata und ihre Sprachen
Lemma Sprache
nodeName Node
nodeType Node
firstElementChild ParentNode
Man kann Sprachen entweder an Hand der Dokumentation von Lemmata unterscheiden, oder auch daran, daß Sprachen in der Regel mit einem großen Anfangsbuchstaben geschrieben werden und Lemmata mit einem kleinen.
Etymologie Der Begriff „Lemma“ kommt hier daher, daß die einzelnen Schlagwörter eines Wörterbuchs ebenfalls „Lemmata“ (Plural) genannt werden.
Proklamationen
Das Nummernzeichen »#«
Da ein Lemma in verschiedenen Sprachen vorkommen könnte, ist es manchmal hilfreich, dem Lemma seine Sprache voranzustellen, um deutlich zu machen, was genau gemeint ist. So kann man dann das Lemma »nodeType« der Sprache »Node« auch als »Node#nodeType« schreiben. Das Nummernzeichen »#« trennt dabei Sprache und Lemma.
Das Nummernzeichen »#« dient in dieser Notation zur Verständigung von Menschen untereinander. Es kann so nicht in einem JavaScript -Ausdruck verwendet werden.
Das Größer-Zeichen »>« zwischen Sprache und Lemma
Mit dem Größer-Zeichen zwischen einer Sprache und einem Lemma drücken wir aus, daß das Lemma von einer Klause der Sprache beschrieben wird.
So bedeutet »Node > nodeType«, daß die Sprache »Node« das Lemma »nodeType« beschreibt.
- Beziehungen
Node > nodeName
Node > nodeType
ParentNode > firstElementChild
- Erklärung einiger Symbole
- > Wenn der linksstehende Name eine Sprache bezeichnet, und der rechtsstehende Name ein Lemma, so bedeutet dies, daß das Lemma in der Sprache enthalten ist, das heißt, daß es eine Klausel in der Sprache gibt, welche dieses Lemma beschreibt.
Das Größer-Zeichen »>« dient in dieser Notation zur Verständigung von Menschen untereinander. Es kann so nicht in einem JavaScript -Ausdruck verwendet werden.
Implementation von Proklamationen
Wir sagen, daß ein JavaScript -Verzeichnisses eine bestimmte Proklamation implementiere, wenn das Verzeichnis die Proklamation als Eintrag enthält.
Ein Verzeichnis, das eine Proklamation enthält, bezeichnen wir auch als eine Implementation jener Proklamation.
Beispielsweise implementiert das Verzeichnis »Ⓖ.document« die Proklamation »nodeType«.
Implementation von Klauseln
Wir sagen, daß ein JavaScript -Verzeichnisses eine bestimmte Klausel implementiere, wenn jenes Verzeichnis das Lemma der Klausel als Eintrag enthält, und auch alles in der Klausel über das Lemma ausgesagte auf den Eintrag zutrifft.
Ein Verzeichnis, das ein Lemma enthält, bezeichnen wir auch als eine Implementation jener Klausel.
Beispielsweise implementiert das Verzeichnis »Ⓖ.document« die Klausel der Sprache »Node« zum Lemma »nodeType«. Denn jenes Verzeichnis enthält nicht nur den Eintrag »nodeType«, sondern auch die Aussagen der Klausel treffen auf jenen Eintrag zu. Beispielsweise besagt, die Klausel, daß das Lemma für ein Zahl steht, und der Eintrag steht auch tatsächlich für eine Zahl.
Solch ein Implementation, bei der auch alle Aussagen der Klausel umgesetzt werden, nennen wir auch eine semantische Implementation. Also eine Implementation, welche auch die Bedeutung, welche die Klausel einem Lemma verleiht, berücksichtig. Im Vergleich dazu nennen wir das bloße Vorhandensein des Lemmas auch eine formale Implementation.
- Klausel
i
- Eine Zahl zwischen 0 und 9.
- Auswertung mit einem Verzeichnis v, das überhaupt keine Implementation der Klausel darstellt
v.i
undefined
- Auswertung mit einer nur formalen Implementation f
f.i
22
- Auswertung mit einer semantischen Implementation s
s.i
7
Implementation einer Sprache
Wir sagen, daß ein Verzeichnis eine bestimmte Sprache spreche, verstehe oder implementiere, wenn alle Klauseln jener Sprache vom Verzeichnis implementiert werden.
Solch ein Verzeichnis nennen wir dann auch eine Implementation jener Sprache.
Beispielsweise ist das Verzeichnis »Ⓖ.document« eine Implementation der Sprachen »Node«.
Dies bedeutet, daß alle Beschreibungen von der Seite »Node« auf die entsprechenden Einträge von »Ⓖ.document« zutreffen.
- Die Seite »Node«
developer.mozilla.org/en/docs/Web/API/Node
Dies macht es auch deutlich, was der Nutzen von Sprachen ist.
Der Sinn von Sprachen besteht darin, Einträge von Verzeichnissen zu beschreiben.
Es ist aber nicht so, daß es zu jedem Verzeichnis immer eine Sprache gibt. Vielmehr kann ein Verzeichnis durch mehrere Sprachen beschrieben werden oder umgekehrt kann eine Sprache mehrere Verzeichnisse beschreiben. Dies erlaubt es einerseits Verzeichnisse übersichtlich durch eine Zerlegung in verschiedene Sprachen zu untergliedern und andererseits eine Sprache in mehreren verschiedenen Verzeichnissen ökonomisch wiederverwenden zu können.
Formale und semantische Implementation einer Sprache
Wir sprechen von einer formalen Implementation einer Sprache, wenn ein Verzeichnis alle Lemmata einer Sprache enthält, es aber offengelassen werden soll, ob auch alle Aussagen aus den Klauseln erfüllt werden.
Wir sprechen von einer semantischen Implementation einer Sprache, wenn betont werden soll, daß auch alle Aussagen aus den Klauseln der Sprache erfüllt werden.
Wenn nur das Wort „Implementation“ verwendet wird, so kann in der Regel angenommen werden, daß damit eine semantische Implementation gemeint ist.
Das Größer-Zeichen »>« zwischen Verzeichnis und Sprache
Wir schreiben die Tatsache, daß das Verzeichnis »Ⓖ.document« die Sprachen »Node« implementiert auch kurz mit einem Größer-Zeichen »>« als »Ⓖ.document. > Node«.
- Eine Implementationsrelation
- Ⓖ.document. > Node
- Erklärung einiger Symbole
- > Wenn der linksstehende Name für ein Verzeichnis und der rechtstehende Name für ein Sprache steht, dann bedeutet das Größer-Zeichen »>«, daß jenes Verzeichnis jene Sprache implementiert. Das heißt alle Lemmata der Sprache sind auch als Einträge im Verzeichnis vorhanden, und ihre Bedeutung ist wie durch die entsprechenden Klauseln der Sprache festgelegt.
Wir können die bisherigen Informationen auch in einer Liste von Beziehungen zusammenfassen.
- Beziehungen
Ⓖ.document. > Node > nodeName
Ⓖ.document. > Node > nodeType
Ⓖ.document. > ParentNode > firstElementChild
- Erklärung einiger Symbole
- > Wenn der linksstehende Name für ein Verzeichnis und der rechtstehende Name für ein Sprache steht, dann bedeutet das Größer-Zeichen »>«, daß jenes Verzeichnis jene Sprache implementiert. Das heißt alle Lemmata der Sprache sind auch als Einträge im Verzeichnis vorhanden, und ihre Bedeutung ist wie durch die entsprechenden Klauseln der Sprache festgelegt.
- > Wenn der linksstehende Name eine Sprache bezeichnet, und der rechtsstehende Name ein Lemma, so bedeutet dies, daß das Lemma in der Sprache enthalten ist, das heißt, daß es eine Klausel in der Sprache gibt, welche dieses Lemma beschreibt.
Das Größer-Zeichen »>« dient in dieser Notation zur Verständigung von Menschen untereinander. Es kann so nicht in einem JavaScript -Ausdruck verwendet werden.
Menüs
Eine Zusammstellung von Proklamationen nennen wir auch ein Menü.
Der Unterschied zwischen einer Gruppe und einer Sprache besteht darin, daß das Menü nur die Proklamationen enthält, aber keine Prosa. Eine Gruppe listet also die einzelnen Proklamationen nur auf, ohne ihnen – wie eine Sprache – auch eine Bedeutung zu verleihen.
Prosatexte werden zur Kommunikation von Menschen untereinander verwendet und sind in einer natürlichen Sprache wie Deutsch oder Englisch verfaßt.
Computer können Prosa nicht verstehen.
Deswegen „sehen“ Computer von einer Sprache nur bestimmte Teile, die sie verstehenden können, diese Teile bilden das Menü.
Vieles, was hier für Sprachen gesagt wurde, gilt entsprechend auch für Menüs, wenn man sich vorstellt, daß die Prosatexte bei einem Menü alle leer sind.
- Die Gruppe »Node«
nodeType
nodeName
- Die Sprache »Node«
nodeType
- Art des Kontexts als Zahl (1=Element, 3=Text, 8 = Kommentar, 9=Dokument)
nodeName
- Der Name des Typs des Kontexts
Implementation von Menüs durch Verzeichnisse
Wir sagen, daß ein Verzeichnisse ein Menü implementiert, wenn alle Proklamationen des Menüse als Proklamationen von Einträgen in dem Verzeichnis vorkommen.
Alles hier für Sprachen Gesagte soll entsprechend auch für Menüs gelten, nur daß an Stelle der Klauseln lediglich die Proklamation verwendet werden.
JavaScript -Implementationen
Der hier vorgestellte Begriff der Implementation eines Lemmas, einer Klausel oder einer Sprache ist von einer JavaScript -Implementation zu unterscheiden.
Eine JavaScript-Implementation ist eine Maschine, die JavaScript -Ausdrücke auswerten kann.
Das Wort „Implementation“ bedeutet in jedem Falle soviel wie „Verwirklichung“ oder „Umsetzung“. Man kann einen Menschen, der Deutsch sprechen kann, beispielsweise als eine Implementation der Sprache Deutsch ansehen.
»instanceof« zwischen Verzeichnissen und Gruppen
Einige Gruppen sind auch der JavaScript -Implementation bekannt, so daß man mit Hilfe von JavaScript zumindest ausdrücken kann, daß ein Verzeichnis eine Gruppe implementiert.
- Auswertung
this.document instanceof Node
true
»this.document instanceof Node« bedeutet, daß das Verzeichnis »this.document« die Gruppe »Node« implementiert. Das Ergebnis »true« bedeutet, daß diese Aussage wahr ist.
Jedoch kann man nicht alle Implementationsrelationen auf diese Weise auch durch einen JavaScript -Ausdruck ausdrücken.
Beispielsweise implementiert das Verzeichnis »this.document« auch die Gruppe »ParentNode«, doch ist diese Gruppe JavaScript -Implementationen nicht bekannt. Obwohl »this.document instanceof ParentNode« ebenfalls »true« sein sollte, kann dies so nicht mit JavaScript -Implementationen ausgewertet werden.
Teilsprache
Wir haben bisher gelernt, daß »nodeType« und »firstElementChild« Lemmata zweier Sprachen (»Node« beziehungsweise »ParentNode«) sind, die beide von »this.document« implementiert werden.
Diese beiden Lemmata finden sich aber noch in einer anderen Sprache wieder, nämlich der Sprache »Document«, wo sie aber in genau derselben Weise beschrieben werden wie in »Node« beziehungsweise »ParentNode«.
Dies ist kein Zufall, sondern liegt daran, daß alle Klauseln von »Node« und »ParentNode« auch Teil der Sprache »Document« sind.
Wenn alle Klauseln einer Sprache auch Klauseln einer anderen Sprache sind, dann sagen wir, daß die zweite Sprache die erste umfaßt oder inkludiert, oder daß die erste eine Teilsprache der zweiten ist. Wir nennen die Beziehung zwischen zweien solcher Sprachen auch eine Inklusionsrelation.
Die Sprachen »Node« und »ParentNode« werden also von der Sprache »Document« umfaßt, sie sind Teilsprachen von Document.
Tatsächlich implementiert »Ⓖ.document« zunächst erst einmal die fast gleichnamige Sprache »Document«. Diese umfaßt dann ihrerseits die Sprachen »Node« und »ParentNode«.
- Auswertung
this.document instanceof Document
true
Das Größer-Zeichen »>« zwischen zwei Sprachen
Mit dem Größer-Zeichen »>« zwischen zwei Sprachen drücken wir aus, daß die linke Sprache die rechte umfaßt.
»Document > Node« bedeutet beispielsweise, daß die Sprache »Document« die Sprache »Node« umfaßt, also, daß alle Klauseln der Sprache »Node« auch zur Sprache »Document« gehören.
- Beziehungen zwischen Sprachen
- Document > Node (»Document« umfaßt »Node«)
- Document > ParentNode (»Document« umfaßt »ParentNode«)
- Erklärung einiger Symbole
- > Wenn der rechtsstehende Name und der linksstehende Name jeweils eine Sprache bezeichnen, dann ist die rechtstehende Sprache eine Teilsprache der linksstehenden. Das heißt alle Klauseln der rechtsstehenden Sprache gehören auch zur linksstehenden. Da die linksstehende Sprache aber noch mehr Klauseln enthalten kann ist sie sozusagen „größer“ als die rechtstehende.
Auch hier können statt Sprachen auch Gruppen verwendet werden.
Das Dokument »Ⓖ.document« implementiert die Sprache »Document«, welche dann ihrerseits die beiden Sprachen »Node« und »ParentNode« umfaßt, die ihrerseits dann die Lemmata »nodeName«, »nodeType« und »firstElementChild« enthalten. Dies ist der Grund dafür, daß das Dokument »Ⓖ.document« die Einträge »nodeName«, »nodeType« und »firstElementChild« enthält, und die Beschreibungen der einschlägigen Klauseln der erwähnten Sprachen auf diese Einträge zutreffen.
Das Größer-Zeichen »>« dient in dieser Notation zur Verständigung von Menschen untereinander. Es kann so nicht in einem JavaScript -Ausdruck verwendet werden.
Das Größer-Zeichen »>«
Wir können die bisherigen Informationen auch in einer Liste von Beziehungen zusammenfassen.
- Beziehungen
Verzeichnis "Ⓖ.document." > Sprache "Document" > Sprache "Node" > Lemma "nodeName"
Verzeichnis "Ⓖ.document." > Sprache "Document" > Sprache "Node" > Lemma "nodeType"
Verzeichnis "Ⓖ.document." > Sprache "Document" > Sprache "ParentNode" > Lemma "firstElementChild"
- Erklärung einiger Symbole
- > Wenn der linksstehende Name für ein Verzeichnis und der rechtstehende Name für ein Sprache steht, dann bedeutet das Größer-Zeichen »>«, daß jenes Verzeichnis jene Sprache implementiert. Das heißt alle Lemmata der Sprache sind auch als Einträge im Verzeichnis vorhanden, und ihre Bedeutung ist wie durch die entsprechenden Klauseln der Sprache festgelegt.
- > Wenn der rechtsstehende Name und der linksstehende Name jeweils eine Sprache bezeichnen, dann ist die rechtstehende Sprache eine Teilmenge der linksstehenden. Das heißt alle Klauseln der rechtsstehenden Sprache gehören auch zur linksstehenden. Da die linksstehende Sprache aber noch mehr Klauseln enthalten kann ist sie sozusagen „größer“ als die rechtstehende.
- > Wenn der linksstehende Name eine Sprache bezeichnet, und der rechtsstehende Name ein Lemma, so bedeutet dies, daß das Lemma in der Sprache enthalten ist, das heißt, daß es eine Klausel in der Sprache gibt, welche dieses Lemma beschreibt.
Man kann das Größer-Zeichen »>« in solchen Diagrammen in der Regel als „enthält“ aussprechen.
Normalerweise verwenden wir aber keine Gattungsbezeichnungen in den Darstellung von Beziehungen und schreiben sie wie folgt.
- Beziehungen
Ⓖ.document. > Document > Node > nodeName
Ⓖ.document. > Document > Node > nodeType
Ⓖ.document. > Document > ParentNode > firstElementChild
Dies könnte man auch folgendermaßen schreiben, um Wiederholungen zu vermeiden.
- Beziehungen
Verzeichnis Sprache Sprache Lemma
this.document ---> Document ---.---> Node ---.-----> nodeName
| |
| '-----> nodeType
|
'---> ParentNode ---> firstElementChild
Das Größer-Zeichen »>« dient in dieser Notation zur Verständigung von Menschen untereinander. Es kann so nicht in einem JavaScript -Ausdruck verwendet werden.
Das folgende Diagramm zeigt eine Vielzahl von Inklusionen an.
- Inklusionsdiagramm
Document > Node
Element > Node
DocumentType > Node
DocumentFragment > Node
CharacterData > Node
Zur Vereinfachung soll das Komma in dem folgenden Diagramm bedeuten, daß die Beziehungen für jeden der durch ein Komma getrennten Namen gelten sollen. Das folgende Diagramm kann also als eine Abkürzung des voranstehenden Diagramms verwendet werden.
- Inklusionsdiagramm
Document, Element, DocumentType, DocumentFragment, CharacterData > Node
Sprachen als Untergliederungen von Verzeichnissen
Man kann sich Sprachen auch als Untergliederungen eines Verzeichnisses vorstellen, dessen Einträge inhaltlich danach zusammengefaßt werden können, ob sie zu einer Sprache gehören und, wenn ja, zu welcher. Eine Sprache eines Verzeichnisses kann man daher ähnlich wie ein Kapitel eines Buches als eine Untergliederung ansehen, welche Einträge (als Lemmata der Sprache) zusammenfaßt, die inhaltlich zusammengehören.
Damit helfen Sprachen dabei, die vielen Einträge eines Verzeichnisses übersichtlich zu untergliedern.
- Das Verzeichnis »Ⓖ.document«
this.document
.-----------------------------------.
| Sprache "Node" |
| - nodeName |
| - nodeType |
| |
|-----------------------------------|
| Sprache "ParentNode" |
| - firstElementChild |
| |
|-----------------------------------|
| ... |
'-----------------------------------'
Neben den Einträgen, die Lemmata einer Sprache sind, können Verzeichnisse auch noch zusätzliche Einträge enthalten, die kein Lemma einer Sprache sind.
Standardsprachen
Eine Sprache kann in mehreren verschiedenen Verzeichnissen vorkommen. Wenn man diese Sprache schon kennt, dann muß man sie nicht noch einmal neu lernen, wenn man ihr in einem anderen Verzeichnis wiederbegegnet. Dies ist ein Vorteil der Wiederverwendung von Sprachen in mehreren verschiedenen Verzeichnissen.
Eine solche Sprache, die von mehreren Verzeichnissen implementiert werden kann, nennen wir auch ein Standardsprache.
Beispielsweise sind »this.document« und »this.document.firstElementChild« in der Regel zwei verschiedene Verzeichnisse. Sie sprechen aber beide dieselbe Sprache »Node«. Wenn man diese Sprache schon kennt, braucht man sie also für das zweite Verzeichnis nicht erneut zu erlernen. (Diese beiden Verzeichnisse könnten sich aber noch unterscheiden, es ist beispielsweise möglich, daß »this.document.firstElementChild« noch eine andere Sprache spricht, welche »this.document« nicht spricht.)
- Zwei verschiedene Verzeichnisse mit einer gemeinsamen Sprache
this.document this.document.firstElementChild
.-----------------------------------. .-----------------------------------.
| Sprache "Node" | | Sprache "Node" |
| - nodeName | | - nodeName |
| - nodeType | | - nodeType |
| | | |
|-----------------------------------| |-----------------------------------|
| ... | | ... |
| | | |
| | | |
'-----------------------------------' '-----------------------------------'
Sprachen im DOM4 finden und verstehen
Das DOM4 (»http://www.w3.org/TR/2015/REC-dom-20151119/«) schreibt umfaßte Sprachen manchmal mit einem von Leerzeichen umgebenen Doppelpunkt »:« getrennt hinter die Namen der Sprachen.
- DOM4 (»http://www.w3.org/TR/2015/REC-dom-20151119/«)
- 4.5 Interface Document
Document : Node
Im DOM4 bedeutet »Document : Node«, daß die Sprache »Document« die Sprache »Node« umfaßt. (Jede Klausel von »Node« wird damit zu einer Klausel von »Document«.)
Das DOM4 (»http://www.w3.org/TR/2015/REC-dom-20151119/«) werden umfaßte Sprachen manchmal aber auch mit dem Worte »implements« getrennt hinter die Namen der umfassenden Sprachen geschrieben.
- DOM4 (»http://www.w3.org/TR/2015/REC-dom-20151119/«)
- 4.2.3 Interface ParentNode
Document implements ParentNode;
Im DOM4 bedeutet »Document implements ParentNode«, daß die Sprache »Document« die Sprache »ParentNode« umfaßt. (Jede Klausel von »ParentNode« wird damit zu einer Klausel von »Document«.)
Auch das MDN hat Quellen zu diesen Sprachen, die besonders für Firefox -Nutzer relevant sind.
- Die Sprache »Document«
- MDN Document
http://developer.mozilla.org/en-US/docs/Web/API/Document
- Die Sprache »Node«
- MDN Node
http://developer.mozilla.org/en-US/docs/Web/API/Node
- Der Eintrag »nodeType«
- MDN NodeType
http://developer.mozilla.org/en-US/docs/Web/API/Node/nodeType
Die Bedeutung von Sprachen und ihrer Inklusion
Wir können uns Sprachen auch anschaulich vorstellen:
Document- Dokument
- Diese Sprache wird von einem Dokumentelement gesprochen. Ein Verzeichnis, das diese Sprache spricht, steht für das ganze Dokument.
Node- Teil
- Diese Sprache wird von einem beliebigen Teil des Dokuments gesprochen. Ein Verzeichnis, das diese Sprache spricht, steht für einen Teil eines Dokumentes.
ParentNode- Behälter
- Diese Sprache wird von einem Teil des Dokuments gesprochen, der andere Teile enthalten kann. Ein Verzeichnis, das diese Sprache spricht, steht für einen Teil eines Dokumentes, der andere Dokumentteile enthalten kann.
Dies veranschaulicht auch die Mehrsprachigkeit von Verzeichnissen und die Teilsprachen:
- Weil jedes Dokument sowohl ein Teil eines Dokumentes ist als auch selber andere Teile eines Dokuments enthalten kann, versteht es sowohl die Sprache »Node« als auch die Sprache »ParentNode«.
- Weil jedes Dokument auch ein Teil eines Dokumentes ist, umfaßt die Sprache »Document« die Sprache »Node«.
Wir können uns die Inklusionrelationen von Sprachen auch anschaulich vorstellen:
- Document > Node
- Jedes Dokument ist ein Teil (»Node«). (Das gesamte Dokument gilt auch als Teil seiner selbst.)
- Document > ParentNode
- Jedes Dokument ist ein Behälter (»ParentNode«). (Das Dokument kann Teile enthalten.)
Man kann das Größer-Zeichen »>« zwischen zwei Sprachen also als „ist ein“ lesen.
Wir werden uns nun noch weitere JavaScript -Ausdrücke ansehen, die solche anschaulichen Bedeutungen von Sprachen noch weiter illustrieren werden.
Der Auszeichnungstyp »html«
Das Verzeichnis »Ⓖ.document.firstElementChild« repräsentiert den wesentlichen Inhalt des gesamten Dokuments, also das html-Element.
document<!DOCTYPE HTML>
<html xmlns="http://www.w3.org/1999/xhtml" lang="de" xml:lang="de">
<head>
<meta charset="UTF-8" /><title>Hallo</title><style type="text/css">
...- Das Dokument als Baum (Stammbaumdarstellung) von Elementen
document
|
| firstElementChild
|
html
|
|
|
.-------------'-------------.
| |
head body
| |
.---------:---------. .--------'--------.
| | | | |
meta title style p pre
|
code
|
script
Das Ergebnis der folgenden Auswertung bedeutet, daß der Typ des ersten im Dokument enthaltenen Elementes gleich »html« ist.
Falls das Dokument vom Browser als »HTML5« (im Gegensatz zu »XHTML5«) interpretiert wird, ergibt die Auswertung statt dessen »HTML« in Großbuchstaben.
- Auswertung
this.document.firstElementChild.nodeName
"html"
»Ⓖ.document.firstElementChild«, also das html-Element, versteht eine Sprache namens »HTMLHtmlElement«, welche die Sprache »HTMLElement« umfaßt, welche die Sprache »Element« umfaßt, welche die Sprache »Node« umfaßt, welche ein Lemma namens »nodeName« enthält.
- Inklusionsdiagramm
Ⓖ.document.firstElementChild > HTMLHtmlElement > HTMLElement > Element > Node > nodeName
Zur Bedeutung der verschiedenen im Inklusionsdiagramm verwendeten Bezeichnungen:
HTMLHtmlElement- Die meisten Elemente verstehen zunächst eine Sprache, deren Bezeichnung sich durch Einsetzen ihres Elementtyps in »HTML…Element« ergibt. Dabei wird nur der erste Buchstabe des Elementtyps groß geschrieben.
- Da es sich hier um ein Element mit dem Typ »html« handelt, ist die primäre Sprache dieses Verzeichnisses zunächst die Sprache »HTMLHtmlElement«.
HTMLElement- Die Sprachen, mit Namen wie »HTML…Element« umfassen in der Regel die Sprache »HTMLElement«.
- Sprachen mit Namen wie »HTML…Element« enthalten Lemmata, die nur für den speziellen Elementtyp »…« sinnvoll sind.
- Die Sprache »HTMLElement« enthält dann die Lemmata, welche für alle Elementtypen, die in HTML vorkommen, sinnvoll sind.
- »HTMLElement« bedeutet nicht „Element mit dem Elementtyp »html«“ (das wäre »HTMLHtmlElement«), sondern „Element mit einem Elementtyp, der in HTML verwendet wird“!
Element- Die Sprache »Element« enthält Lemmata, welche für alle Elementtypen sinnvoll sind, auch solche, die in HTML nicht verwendet werden. Solche Elementtypen finden sich beispielsweise in manchen XML-Dokumenten. Das DOM ist auch für XML gedacht.
Node- Die Sprache »Node« enthält Lemmata, welche für alle Inhalte eines Dokuments sinnvoll sind. Neben den Elementen findet man in einem HTML-Dokument ja auch noch andere Inhalte, wie beispielsweise Text -Inhalte (Inhaltstyp 3 ). Jedes Element ist ein Teil, aber nicht jeder Teil ist ein Element!
- Die Sprache »Node« kennen wir bereits. Hier zeigt sich einer der Vorteile der Verwendung von Sprachen. Da eine Sprache von mehreren verschiedenen Verzeichnissen gesprochen werden kann, müssen wir bei einem neuen Verzeichnis nicht immer auch eine neue Sprache erlernen, da ein Verzeichnis eine Sprache sprechen kann, die wir schon kennen.
- Beziehungen
- Das Inklusionsdiagramm „Ⓖ.document.firstElementChild > HTMLHtmlElement > HTMLElement > Element > Node > nodeName“ drückt folgende Beziehungen aus:
- »Ⓖ.document.firstElementChild« ist ein Verzeichnis, das die Sprache » HTMLHtmlElement« spricht. Dies bedeutet hier, daß jenes Verzeichnis für ein Element mit dem Elementtyp »html« steht.
- Jedes Element mit dem Elementtyp »html« (ein »HTMLHtmlElement«) ist ein Element mit einem Elementtyp der HTML-Spezifikation (ein »HTMLElement«). (Die Sprache »HTMLHtmlElement« umfaßt die Sprache »HTMLElement«.)
- Jedes Element mit einem Elementtyp der HTML-Spezifikation (ein »HTMLElement«) ist ein Element (ein » Element«). (Die Sprache »HTMLElement« umfaßt die Sprache »Element«.)
- Jedes Element (ein » Element«) ist ein Teil (ein » Node«). (Die Sprache »Element« umfaßt die Sprache »Node«.)
- Die Sprache »Node« enthält ein Lemma »nodeName«
Unter Mozilla Firefox 38 können wir einige der Inklusionsrelationen auch mit Hilfe von JavaScript veranschaulichen.
Die folgende Auswertung zeigt, daß das Verzeichnis »Ⓖ.document.firstElementChild« die Gruppe »HTMLHtmlElement« implementiert.
- Auswertung
this.document.firstElementChild instanceof HTMLHtmlElement
true
Die folgende Auswertung zeigt, daß Mozilla Firefox 38 die Gruppe »HTMLElement« aus der DOM4 -Spezifikation nicht kennt. Diese Spezifikation verlangt auch nicht, daß »instanceof« wie im vorigen Beispiel gezeigt verwendet werden kann. Die hier gezeigten Beispiele dienen nur der Veranschaulichung, und diese ist nicht bei jeder Sprache möglich.
- Auswertung
this.document.firstElementChild instanceof HtmlElement
ReferenceError: HtmlElement is not defined
Die folgende Auswertung zeigt, daß das Verzeichnis »Ⓖ.document.firstElementChild« die Gruppe »Element« implementiert. Dies liegt daran, daß es die Gruppe »HTMLHtmlElement« implementiert, und die Gruppe »HTMLHtmlElement« die Gruppe »Element« enthält.
- Auswertung
this.document.firstElementChild instanceof Element
true
Die folgende Auswertung zeigt, daß das Verzeichnis »Ⓖ.document.firstElementChild« die Gruppe »Node« implementiert. Dies liegt daran, daß es die Gruppe »HTMLHtmlElement« implementiert, und die Gruppe »HTMLHtmlElement« die Gruppe »Node« enthält.
- Auswertung
this.document.firstElementChild instanceof Node
true
Die folgende Auswertung illustrieren noch einmal, daß das Verzeichnis »Ⓖ.document.firstElementChild« die Gruppe »Node« implementiert, indem sie zeigen, daß das Lemma »nodeType« aus dieser Gruppe auch wirklich ein Eintrage jenes Verzeichnisses ist.
- Auswertung
this.document.firstElementChild.nodeType
1
Hier folgende noch einige einschlägige Quellen.
- Dokumentation des Auszeichnungstyps »HTML«
developer.mozilla.org/en-US/docs/Web/HTML/Element/html
- Dokumentation der Sprache des Auszeichnungstyps (»HTMLHtmlElement«)
developer.mozilla.org/en-US/docs/Web/API/HTMLHtmlElement
- Dokumentation der Sprache »HtmlElement«
developer.mozilla.org/en-US/docs/Web/API/HTMLElement
- Dokumentation der Sprache »Element«
developer.mozilla.org/en-US/docs/Web/API/Element
- Dokumentation der Sprache »Node«
developer.mozilla.org/en-US/docs/Web/API/Node
Der Auszeichnungstyp »head«
Das Verzeichnis »Ⓖ.document.firstElementChild.firstElementChild« repräsentiert in dem hier gewählten Beispieldokument den wesentlichen Inhalt des html-Elements, also das head-Element.
document<!DOCTYPE HTML>
<html xmlns="http://www.w3.org/1999/xhtml" lang="de" xml:lang="de">
<head>
<meta charset="UTF-8" /><title>Hallo</title><style type="text/css">
...- Das Dokument als Baum (Stammbaumdarstellung) von Elementen
document
|
| firstElementChild
|
html
|
|
firstElementChild |
.-------------'-------------.
| |
head body
| |
.---------:---------. .--------'--------.
| | | | |
meta title style p pre
|
code
|
script- Auswertung
this.document.firstElementChild.firstElementChild.nodeName
"head"
Das Ergebnis der Auswertung bedeutet, daß der Typ des ersten im ersten Element des Dokuments enthaltenen Elementes gleich »head« ist.
Falls das Dokument vom Browser als »HTML5« (im Gegensatz zu »XHTML5«) interpretiert wird, ergibt die Auswertung statt dessen »HEAD« in Großbuchstaben.
- Auswertung
this.document.firstElementChild.firstElementChild.nodeName
"HEAD"
»Ⓖ.document.firstElementChild.firstElementChild« versteht eine Sprache namens »HTMLHeadElement«, welche die Sprache »HTMLElement« umfaßt.
Die Sprache »HTMLElement« haben wir schon weiter oben behandelt, und gesehen, daß sie ein Lemma »nodeName« enthält.
- Die Abstammung von »nodeName«
Ⓖ.document.firstElementChild.firstElementChild : HTMLHeadElement > HTMLElement > Element > Node # nodeName
- Dokumentation des Auszeichnungstyps »HEAD«
developer.mozilla.org/en-US/docs/Web/HTML/Element/head
- Dokumentation des Auszeichnungstyps »HTMLHeadElement«
developer.mozilla.org/en-US/docs/Web/API/HTMLHeadElement
Der Auszeichnungstyp »meta«
Das Verzeichnis »Ⓖ.document.firstElementChild.firstElementChild.firstElementChild« repräsentiert in dem hier gewählten Beispieldokument den ersten wesentliche Inhalt des head-Elements, also das meta-Element.
document<!DOCTYPE HTML>
<html xmlns="http://www.w3.org/1999/xhtml" lang="de" xml:lang="de">
<head>
<meta charset="UTF-8" /><title>Hallo</title><style type="text/css">
...- Das Dokument als Baum (Stammbaumdarstellung) von Elementen
document
|
| firstElementChild
|
html
|
|
firstElementChild |
.-------------'-------------.
| |
head body
firstElementChild | |
.---------:---------. .--------'--------.
| | | | |
meta title style p pre
|
code
|
script- Auswertung
this.document.firstElementChild.firstElementChild.firstElementChild.nodeName
"meta"
Das Ergebnis der Auswertung bedeutet, daß der Typ des ersten im ersten Element des ersten Elements des Dokumentes enthaltenen Elementes gleich »meta« ist.
Falls das Dokument vom Browser als »HTML5« (im Gegensatz zu »XHTML5«) interpretiert wird, ergibt die Auswertung statt dessen »META« in Großbuchstaben.
- Auswertung
this.document.firstElementChild.firstElementChild.firstElementChild.nodeName
"META"
»Ⓖ.document.firstElementChild.firstElementChild.firstElementChild« versteht eine Sprache namens »HTMLMetaElement«, welche die Sprache »HTMLElement« umfaßt.
Die Sprache »HTMLElement« haben wir schon weiter oben behandelt, und gesehen, daß sie ein Lemma »nodeName« enthält.
- Die Abstammung von »nodeName«
Ⓖ.document.firstElementChild.firstElementChild.firstElementChild : HTMLMetaElement > HTMLElement > Element > Node # nodeName
- Dokumentation des Auszeichnungstyps »META«
developer.mozilla.org/en-US/docs/Web/HTML/Element/meta
- Dokumentation des Auszeichnungstyps »HTMLMetaElement«
developer.mozilla.org/en-US/docs/Web/API/HTMLMetaElement
Lehrvergleich Restaurant *
Man kann sich eine Sprache wie die Speisekarte eines Restaurants vorstellen.
Die Speisekarte enthält Namen der Gerichte (Lemmata ) und Beschreibungen der Gerichte (Klauseln ).
- Die Sprache »Speisekarte«
- Carpaccio
- Marinierte Rinderfiletscheiben
- Grillteller Spezial
- Koteletts, Schweinefilet und Würste
- Haustopf
- Gemüse mit Champignons und Kartoffeln
Aber, wenn man nur eine Speisekarte hat, dann wird man noch nicht satt, man braucht auch noch Kellner, Köche und eine Küche (Implementation).
Die Gerichte, die auf den Tisch gestellt werden, sollten nicht nur so heißen wie in der Speisekarte beschrieben (formale Implementation), sondern sie sollten auch die Beschreibungen aus der Speisekarte erfüllen (semantische Implementation).
Man kann eine Speisekarte, die viele Gerichte enthält, übersichtlicher gestalten, indem man sie in verschiedene Abschnitte (umfaßte Sprachen, Teilsprache) unterteilt.
- Die Teilsprache »Vorspeisen«
- Carpaccio
- Marinierte Rinderfiletscheiben
- Die Teilsprache »Hauptgerichte«
- Grillteller Spezial
- Koteletts, Schweinefilet und Würste
- Haustopf
- Gemüse mit Champignons und Kartoffeln
- Inklusionsrelationen
- Restaurant > Speisekarte > Vorspeisen > Carpaccio
- D.h., das Restaurant (Implementation) implementiert eine Speisekarte (Sprache), welche Vorspeisen (Teilsprache) enthält, zu denen Carpaccio (Lemma) gehört.
Gleichzeitig kann es Kunden helfen, sich in Restaurants zurechtzufinden, wenn nicht jedes Restaurant neue Gerichte erfindet, sondern es bestimmte Gerichte gibt, die in verschiedenen Restaurants gleich sind (Standardsprachen, Standardlemmata), beispielsweise sind Begriffe wie „Wiener Schnitzel“ allgemein bekannt, während „Berliner Schnitzel“ erklärt werden müßte.
Weil die Sprachen die Bedeutung von Wörtern definieren, reicht es dann bei einer Bestellung zum Kellner (zur Implementation) nur das Wort „Carpaccio“ zu sagen, um marinierte Rinderfiletscheiben zu erhalten.