/
einbindung.html
245 lines (229 loc) · 22.3 KB
/
einbindung.html
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
<!DOCTYPE html>
<html lang="de">
<head>
<meta charset="utf-8">
<title>JavaScript: Einbindung in HTML mit dem script-Element</title>
<meta name="viewport" content="width=device-width">
<link rel="stylesheet" href="js-doku.css">
</head>
<body>
<div id="nav">
<p>Hier entsteht eine <strong>JavaScript-Dokumentation</strong> von <a href="https://molily.de/">molily</a>. Derzeit ist sie noch lückenhaft, wächst aber nach und nach. Kommentare und Feedback werden gerne per <a href="mailto:molily@mailbox.org">E-Mail</a> entgegen genommen.</p>
<p class="contents-link"><a href="./">Zum Inhaltsverzeichnis</a></p>
</div>
<h1>JavaScript: Einbindung in HTML mit dem <code>script</code>-Element</h1>
<div class="section" id="ueber">
<h2>Vorbemerkung</h2>
<p>Es gibt viele Möglichkeiten, JavaScript in HTML-Dokumente einzubetten. In dieser Einführung werden nur wenige gängige vorgestellt und empfohlen. Dieses Kapitel geht davon aus, dass HTML und JavaScript möglichst getrennt werden und sich JavaScripte eigenständig hinzuschalten. Die Hintergründe zu diesem Ansatz finden Sie im Kapitel <a href="einsatz.html">Sinnvoller JavaScript-Einsatz</a>.</p>
</div>
<div class="section" id="script-element">
<h2>Das script-Element</h2>
<p>Zur Einbindung von JavaScript-Code in ein HTML-Dokument existiert das HTML-Element <code>script</code>. Dieses darf sowohl im Kopf (<code>head</code>-Element) als auch im Körper (<code>body</code>-Element) eines HTML-Dokuments auftauchen. Es kann entweder direkt JavaScript-Code beinhalten, wie in diesem Beispiel:</p>
<pre>
<!DOCTYPE html>
<html lang="de">
<head>
<meta charset="utf-8">
<title>Dokument mit integriertem JavaScript</title>
</head>
<body>
<h1>Dokument mit integriertem JavaScript</h1>
<script>
<strong class="js">window.alert("Hallo Welt!");</strong>
</script>
</body>
</html></pre>
<p>Oder es kann leer sein und auf eine externe Datei mit JavaScript-Code verweisen. Diese Nutzungsweise sollten Sie vorziehen und Ihre JavaScripte möglichst in separate Dateien auslagern.</p>
<p>Schreiben Sie dazu Ihren JavaScript-Code in eine eigene Datei und speichern Sie sie mit der Dateiendung <code>.js</code> ab. Notieren Sie am Dokument-Ende ein <code>script</code>-Element, das den Browser auf die externe JavaScript-Datei hinweist. Dazu notieren Sie im <code>src</code>-Attribut die Adresse (<abbr title="Uniform Resource Locator">URL</abbr>), unter der das Script abrufbar ist.</p>
<pre><!DOCTYPE html>
<html lang="de">
<head>
<meta charset="utf-8">
<title>Dokument mit externem JavaScript</title>
</head>
<body>
<h1>Dokument mit externem JavaScript</h1>
<script <strong>src="script.js"</strong>></script>
</body>
</html></pre>
<p>In der Datei <var>script.js</var> können Sie nun JavaScript-Anweisungen, Funktionen, Objekte und so weiter notieren. Schreiben Sie zum Test einmal folgende Anweisung in die JavaScript-Datei:</p>
<pre>
window.alert('Hallo Welt!');
</pre>
<p>Sie können mit dieser Methode auch mehrere Scripte einbinden. Platzieren Sie dazu mehrere <code>script</code>-Elemente untereinander.</p>
<p>Beachten Sie, dass diese eingebundenen Dateien direkt JavaScript-Code enthalten müssen. HTML-Code darf darin nicht vorkommen – in JavaScript-Strings ist er natürlich noch erlaubt. Insbesondere ist es nicht nötig, den JavaScript-Code in der separaten Datei noch einmal in ein <code>script</code>-Element zu verpacken. Dies würde dazu führen, dass der Browser den JavaScript-Code nicht korrekt ausführt.</p>
<p>Ihre Script-Dateien können Sie – genauso wie Stylesheets, Grafiken usw. – auch in Unterverzeichnissen und sogar auf anderen Webservern unterbringen. Solange die angegebene URL korrekt ist, wird ein JavaScript-fähiger Browser sie beim Anzeigen des Dokuments herunterladen und ausführen.</p>
</div>
<div class="section" id="ausfuehrung">
<h2>Ausführung von script-Elementen</h2>
<p>Mit dem <code>script</code>-Element können Sie sowohl Scripte im Dokumentkopf <code><head>…</head></code> als auch im Dokumentkörper <code><body>…</body></code> einbetten. Die Ausführung des Scriptcodes läuft nach gewissen Regeln ab, die wir im Folgenden betrachten.</p>
<p>Sobald der Browser das HTML-Dokument vom Webserver empfängt, beginnt er damit, den Quelltext zu verarbeiten und in eine interne Speicherstruktur, das <a href="dom.html">Document Object Model (DOM)</a> zu überführen. Das dafür zuständige Browser-Modul nennt sich <dfn>Parser</dfn> und der Verarbeitungsvorgang <dfn>Parsen</dfn>.</p>
<p>Sobald der Parser auf ein <code>script</code>-Element trifft, wird das Parsen des HTML-Dokuments angehalten und der JavaScript-Code innerhalb des <code>script</code>-Elements ausgeführt. Das gilt auch für externe JavaScript-Dateien: Der HTML-Parser stoppt, lädt die externe JavaScript-Datei vom Webserver, führt den JavaScript-Code aus und fährt erst dann mit der Verarbeitung des restlichen HTML-Quelltextes fort.</p>
<p>Diese Vorgehensweise, den JavaScript-Code direkt beim Einlesen des HTML-Dokuments auszuführen, hat verschiedene Konsequenzen.</p>
<div class="section" id="script-reihenfolge">
<h3>Scripte haben Zugriff auf die Objekte vorher eingebundener Scripte</h3>
<p>Der JavaScript-Code in <code>script</code>-Elementen bzw. der externe Script-Code wird in der Reihenfolge ausgeführt, in der die <code>script</code>-Elemente im HTML-Quelltext notiert sind. Wenn Sie verschiedene Scripte haben, die aufeinander aufbauen, so müssen Sie sie nacheinander einbinden.</p>
<pre>
<script src="grundlagenscript.js"></script>
<script src="aufbauscript.js"></script>
<script>
// Anwendung der Scripte
helferfunktion();
</script></pre>
<p>Das Beispiel bindet drei Scripte ein, die ersten beiden als externe Dateien, das dritte direkt im HTML-Code. Der Browser führt die Scripte in der Reihenfolge ihrer Einbindung aus. Daher können spätere Scripte die Objekte, Funktionen und Variablen nutzen, die die vorher eingebundenen Scripte definiert haben.</p>
<p>Im Beispiel wird zuerst <var>grundlagenscript.js</var> eingebunden, heruntergeladen und ausgeführt. Das darauffolgende Script aus der Datei <var>aufbauscript.js</var> kann die darin notierten Funktionen nutzen. Schließlich kann das dritte Script eine Funktion nutzen, die in <var>aufbauscript.js</var> definiert wurde.</p>
</div>
<div class="section" id="script-verzoegerung">
<h3>Externe Scripte verzögern den Aufbau des Dokuments</h3>
<p>Dass der Browser die eingebundenen Scripte nicht erst <em>nach</em>, sondern bereits <em>während</em> des Einlesens des HTML-Codes ausführt, hat Vor- und Nachteile.</p>
<p>Einerseits werden Scripte so schnell wie möglich ausgeführt und es ist garantiert, dass ein externes Script ausgeführt wird, bevor ein nachfolgendes internes Script abgearbeitet wird.</p>
<p>Andererseits verlangsamt sich der Seitenaufbau, wenn große externe Scriptdateien vom Webserver heruntergeladen werden.</p>
<p>Es ist daher empfehlenswert, alle <code>script</code>-Elemente in der notwendigen Reihenfolge <em>am Dokument-Ende</em> zu platzieren. Dadurch wird der Aufbau des Dokumentes nicht durch das Herunterladen und Ausführen von JavaScript unterbrochen.</p>
</div>
<div class="section" id="script-document-write">
<h3>Scripte können während des Ladens das Dokument mit <code>document.write</code> ergänzen</h3>
<p>Mit der Methode <code>document.write</code> kann ein Script schon während des Ladens das Dokument direkt beeinflussen und einige Weichen stellen. <code>document.write</code> nimmt HTML-Code als String entgegen. Es fügt den HTML-Code an der Stelle ins Dokument ein, an der das zugehörige <code>script</code>-Element steht.</p>
<pre>
<!DOCTYPE html>
<html lang="de">
<head>
<meta charset="utf-8">
<title>Zugriff auf das DOM während dem Parsen des Dokuments</title>
<script>
<strong>document.write("<link rel='stylesheet' href='stylesheet.css'>");</strong>
</script>
</head>
<body>
<script>
<strong>document.write("<p><a href='javascript:location.reload()'>" +
"Seite mittels JavaScript neu laden<\/a><\/p>");</strong>
</script>
</body>
</html>
</pre>
<p>Das Beispiel enthält zwei Scripte mit <code>document.write</code>-Aufrufen. Diese schreiben HTML-Elemente ins Dokument, einmal ein Verweis auf ein Stylesheet und einmal ein Textabsatz mit einem JavaScript-Link.</p>
<p><code>document.write</code> ist beim <a href="einsatz.html#unobtrusive-javascript">Unobtrusive JavaScript</a> nur selten sinnvoll. Es gibt zwar Inhalte, die nur bei verfügbarem JavaScript sichtbar sein sollen, da sie auf JavaScript-Funktionalität beruhen. Im Beispiel ist das ein Link, der die Seite mittels JavaScript neu lädt. Allerdings sollten Sie solche Inhalte ohne <code>document.write</code> dynamisch ins Dokument einfügen. Die dazu nötigen Techniken werden wir noch kennenlernen.</p>
<p><code>document.write</code> hat zwei möglichen Anwendungsfälle, von denen wir einen kennenlernt haben: Das Ergänzen eines Dokuments <em>während</em> der Browser den HTML-Code einliest. Wenn <code>document.write</code> jedoch <em>nach</em> dem Einlesen des HTML-Codes aufgerufen wird, hat die Methode einen ganz anderen Effekt: Sie überschreibt den gesamten Inhalt des Dokuments. Sie eignet sich also nicht dazu, das vorhandene Dokument gezielt via JavaScript zu ändern.</p>
</div>
<div class="section" id="script-dom-zugriff">
<h3>Ein Script hat Zugriff auf die Elemente vor dem zugehörigen <code>script</code>-Element</h3>
<p>Die häufigste Aufgabe von JavaScripten ist der Zugriff auf das Dokument über die DOM-Schnittstelle. Diese macht die Elemente und deren Textinhalte als Knotenobjekte zugänglich.</p>
<p>Ein Script wird wie gesagt während des Einlesens des HTML-Dokuments ausgeführt. Zu diesem Zeitpunkt hat es noch keinen Zugriff auf den gesamten DOM-Elementbaum. Stattdessen kann es nur auf einen Teil-Baum zugreifen, nämlich auf die Elemente, die <em>vor</em> dem zugehörigen <code>script</code>-Element liegen und somit bereits eingelesen wurden.</p>
<pre>
<!DOCTYPE html>
<html lang="de">
<<strong>head</strong>>
<<strong>title</strong>>Zugriff auf das DOM während dem Parsen des Dokuments</title>
<script>
// Der Titel ist an dieser Stelle bereits verfügbar:
window.alert( document.title );
// Der Dokumentkörper allerdings noch nicht (ergibt null):
window.alert( document.body );
// Die Überschrift ebensowenig (ergibt null):
window.alert( document.getElementById("überschrift") );
</script>
</head>
<<strong>body</strong>>
<script>
window.alert( document.title ); // OK
// Der Dokumentkörper ist erst an dieser Stelle verfügbar:
window.alert( document.body );
// Die Überschrift allerdings noch nicht (ergibt null):
window.alert( document.getElementById("überschrift") );
</script>
<<strong>h1 id="überschrift"</strong>>Beispielüberschrift</h1>
<script>
window.alert( document.title ); // OK
window.alert( document.body ); // OK
// Die Überschrift ist erst an dieser Stelle verfügbar:
window.alert( document.getElementById("überschrift") );
</script>
</body>
</html>
</pre>
<p>Das Beispiel enthält drei Scripte, die jeweils versuchen, auf den Dokument-Titel (<code>title</code>-Element), den Dokument-Körper (<code>body</code>-Element) und eine Überschrift (<code>h1</code>-Element) zuzugreifen. Je nachdem, an welcher Stelle sich das Script und das angesprochene Element befinden, ist der Zugriff auf das Element möglich oder nicht.</p>
<p>Der Zugriff funktioniert erst dann, wenn das gesuchte Element dem jeweiligen Script vorangeht und bereits eingelesen wurde. Das Element muss dazu noch nicht abgeschlossen sein. Im Beispiel kann ein Script im <code>body</code>-Element bereits auf das geöffnete, aber noch nicht geschlossene <code>body</code>-Element zugreifen. Das Script hat zudem Zugriff auf die vorherigen Geschwisterelemente (im Beispiel das <code>h1</code>-Element), nicht jedoch auf die folgenden.</p>
<p>Vielleicht verstehen Sie nun, warum wir externe Scripte ans Dokument-Ende setzen haben: Sie haben dadurch Zugriff auf das gesamte Dokument.</p>
</div>
</div>
<div class="section" id="hintergrund">
<h2>Scripte im Hintergrund laden</h2>
<p>Wie beschrieben werden Scripte beim Einlesen des Dokuments ausgeführt. Damit ist die Reihenfolge der Ausführung dieselbe wie die Reihenfolge der Scripte im Dokument. Der große Nachteil ist, dass das Herunterladen und Ausführen der Scripte den Aufbau der Seite verlangsamt.</p>
<p>Um die Ladegeschwindigkeit zu verbessern, haben wir einen Trick kennengelernt: Scripte werden ausgelagert und die <code>script</code>-Elemente ans Dokument-Ende verschoben. Dadurch verlangsamen sie die Verarbeitung des restlichen Dokumentinhalts nicht.<p>
<p>Dieser Trick hat allerdings den Nachteil, dass der Browser die Scripte erst bemerkt, wenn das HTML-Dokument fast komplett heruntergeladen und eingelesen ist. Erst spät startet der Browser das Herunterladen und Ausführen der Scripte. Diese Verzögerung kann zu unerwünschten Effekten führen.</p>
<p>Beim Unobtrusive JavaScript ist es üblich, dass Scripte das Dokument verändern und Funktionen hinzufügen. Passiert das einige Sekunden nach dem erstmaligen Anzeigen der Seite, so verändert sich die Seite plötzlich, während der Benutzer die Seite bereits liest.</p>
<p>HTML ermöglicht es daher, ein Script dem Browser so früh wie möglich bekannt zu machen, es aber erst später auszuführen. Dadurch kann der Browser das Script bereits im Hintergrund herunterladen. Das Einlesen des Dokuments wird aber nicht verzögert.</p>
<p>Das Herunterladen des Scripts und das Einlesen des Dokuments laufen somit gleichzeitig nebeneinander. Das Script blockiert die Verarbeitung des Dokuments nicht. Der Browser wartet nicht auf das Herunterladen und Ausführen des Scripts.</p>
<p>Dazu gibt es zwei zusätzliche HTML-Attribute, die Sie dem <code>script</code>-Element geben können: <code>defer</code> und <code>async</code>.</p>
<div class="section" id="defer">
<h3><code>defer</code>: Script ausführen, sobald das Dokument geladen ist</h3>
<p><code>defer</code> ist ein Attribut ohne Wert. Sie notieren einfach <code>defer</code> in der Attributliste im Start-Tag:</p>
<pre><script src="script.js" <strong>defer</strong>></script></pre>
<p>Wenn das <code>defer</code>-Attribute gesetzt ist, so lädt der Browser das Script sobald möglich herunter. Das Einlesen und der Aufbau des Dokuments läuft derweil weiter. Der Browser führt das Script nämlich erst aus, sobald das Dokument fertig geladen ist.
<p>Das englische Wort <em>defer</em> bedeutet »verzögern«. Der Browser verzögert die Script-Ausführung bis zum erfolgreichen Übertragen und Einlesen des HTML-Codes.</p>
<p>Damit hat das Script garantierten Zugriff auf den gesamten DOM-Elementbaum. Es verhält sich insofern wie ein Script, das am Ende des Dokuments eingebunden ist. Mit dem Unterschied, dass der Browser früh mit dem Herunterladen beginnen kann. Dies kann den Seitenaufbau enorm beschleunigen.</p>
<p>Die Position eines solchen Scripts im Dokument hat keinen Einfluss auf den Zeitpunkt seiner Ausführung. Der Zeitpunkt ist garantiert, nämlich nach dem Einlesen des Dokuments.</p>
<p>Damit der Browser das Script möglichst früh im Hintergrund herunterlädt, sollten Sie das zugehörige Script-Element im <code>head</code> notieren:</p>
<pre>
<!DOCTYPE html>
<html lang="de">
<head>
<meta charset="utf-8">
<title>Dokument mit defer-Script</title>
<strong><script src="script.js" defer></script></strong>
</head>
<body>
<h1>Dokument mit defer-Script</h1>
</body>
</html></pre>
</pre>
<p>Das <code>defer</code>-Attribut funktioniert nur bei externen, ausgelagerten Scripten. Wenn Sie es angeben, müssen Sie auch ein <code>src</code>-Attribut angeben. <code>defer</code> funktioniert nicht bei direkt ins Dokument integriertem JavaScript-Code.</p>
<p>Wenn es mehrere Scripte mit <code>defer</code> im Dokument gibt, so werden sie garantiert in der Reihenfolge ausgeführt, in der sie im Dokument notiert sind:</p>
<pre>
<script src="script1.js" defer></script>
<script src="script2.js" defer></script>
</pre>
<p>Im obigen Beispiel lädt der Browser Script 1 und 2 parallel herunter. Beide werden ausgeführt, wenn das Dokument fertig eingelesen, und zwar erst Script 1 und dann Script 2.</p>
<p>Ein Script, das Sie mit <code>defer</code> laden, darf nicht <a href="#script-document-write"><code>document.write</code></a> verwenden. Wenn Sie das Dokument ergänzen möchten, so müssen Sie stattdessen die DOM-Schnittstelle verwenden.</p>
</div>
<div class="section" id="defer">
<h3><code>async</code>: Script ausführen, sobald sie heruntergeladen sind</h3>
<p>Das zweite Attribut, <code>async</code>, ist auch ein Attribut ohne Wert:</p>
<pre><script src="script.js" <strong>async</strong>></script></pre>
<p><code>async</code> bewirkt ebenfalls, dass der Browser das Script sobald möglich herunterlädt. Das Einlesen des Dokuments wird nicht unterbrochen.</p>
<p>Der Unterschied zu <code>defer</code> ist nun folgender: Das Script mit <code>async</code> wird ausgeführt, sobald es fertig heruntergeladen ist. Der Browser wartet mit der Ausführung nicht, bis das Dokument vollständig eingelesen ist.</p>
<p><code>async</code> steht für das englische <em>asynchronous</em>, was hier asynchron, zeitlich losgelöst und entkoppelt bedeutet. Die Script-Ausführung ist nämlich losgelöst vom Dokumentaufbau.</p>
<p>Das Script wird schnellstmöglich ausgeführt. Es hat auf die Elemente Zugriff, die zu diesem Zeitpunkt bereits eingelesen wurden. Welche das sind, ist willkürlich und kann sich von Mal zu Mal unterscheiden.</p>
<p>Sie sollten in einem solchen Script nicht davon ausgehen, dass bestimmte Elemente bereits eingelesen sind und ein DOM-Zugriff möglich ist. <code>async</code> eignet sich daher nur für besondere Scripte, die nicht zielgenau über die DOM-Schnittstelle auf das Dokument zugreifen.</p>
<p>Ein Beispiel sind Scripte zur Besucherzählung. Diese erheben Daten und schicken sie gegebenenfalls an den Server, aber benötigen keinen Zugriff auf die Inhalte im Dokument-Körper (<code>body</code>-Element).</p>
<p>In den meisten Fällen sollten Sie Ihre <code>script</code>-Elemente ans Dokumentende stellen – ohne <code>defer</code> und <code>async</code> – oder im Dokument-Kopf mit <code>defer</code> laden.</p>
</div>
</div>
<div class="section" id="noscript">
<h2>Das <code>noscript</code>-Element</h2>
<p>Das <code>noscript</code>-Element ist als Gegenstück zu <code>script</code> gedacht: Damit lassen sich Alternativinhalte für Programme ins Dokument einfügen, die keine Scripte unterstützen. Browser, in denen JavaScripte deaktiviert oder nicht verfügbar ist, zeigen den Alternativinhalt an. Der Inhalt richtet sich auch an Programme wie Suchmaschinen-Robots, die das Dokument automatisiert verarbeiten, ohne die Scripte dabei zu beachten.</p>
<pre><noscript>
<p>Dieser Absatz ist gehört zum Inhalt des Dokuments, ist aber
im Browser nur zu sehen, wenn JavaScript deaktiviert oder nicht
zur Verfügung steht.</p>
</noscript></pre>
<p>Der Sinn von <code>noscript</code> ist, die Informationen zugänglich zu machen, die sonst nur mithilfe des Scriptes zugänglich wären oder sogar durch das Script eingefügt werden. Diese Abwärtskompatibilität einer Website und die Zugänglichkeit aller Inhalte ohne JavaScript ist zwar erstrebenswert. Allerdings zäumt diese Vorgehensweise das Pferd von hinten auf.</p>
<p><a href="einsatz.html#unobtrusive-javascript">Unobtrusive JavaScript</a> empfiehlt eine andere Vorgehensweise: Alle Informationen liegen bereits im Dokument. Es ist daher ohne JavaScript gut bedienbar. Mittels JavaScript werden Zusatzfunktionen eingebaut, die die Bedienung und das Lesen der Inhalte vereinfachen und verbessern.</p>
<p>Im Unobtrusive JavaScript kommt dem <code>noscript</code>-Element daher keine Bedeutung zu. Von seiner Verwendung wird sogar abgeraten. Denn es verleitet dazu, JavaScript-Logik mit dem HTML-Code fest zu verschweißen, anstatt diese sauber zu trennen. Gestalten Sie Ihre Website so, dass ohne JavaScript möglichst alle Inhalte zugänglich sind und alle Funktionen zur Verfügung stehen. Ihre JavaScripte schalten sich dann hinzu und modifizieren das Dokument entsprechend.</p>
<p>Anstatt also mittels <code>noscript</code> Inhalte einzufügen, die nur ohne JavaScript relevant ist, sollten Sie diese ganz normal ohne <code>noscript</code> im Dokument notieren. Falls der Inhalt bei aktiviertem JavaScript nicht benötigt wird, dann können Sie es mittels JavaScript verändern oder ganz ausblenden.</p>
<p>In den meisten Fällen werden Sie <code>noscript</code> also nicht brauchen. Es gibt einige Sonderfälle, in denen <code>noscript</code> angemessen ist: Etwa wenn es sich bei der Website um eine reine JavaScript-Webanwendung handelt, die (noch) keine Alternativversion anbietet. Dann können Sie mit <code>noscript</code> einen Hinweis darauf hinterlegen, dass die Website einen JavaScript-fähigen Browser zwingend voraussetzt.</p>
</div>
<div class="sequence-navigation">
<p class="next"><a href="event-handling-grundlagen.html" rel="next">Grundlagen der Ereignis-Verarbeitung</a></p>
<p class="prev"><a href="dom.html" rel="prev">Arbeiten mit dem DOM</a></p>
</div>
<div id="footer">
<p><strong>JavaScript-Dokumentation</strong> · <a href="./">Zum Inhaltsverzeichnis</a></p>
<p>Autor: <a href="https://molily.de/">molily</a> · Kontakt: <a href="mailto:molily@mailbox.org">molily@mailbox.org</a></p>
<p>Lizenz: <a rel="license" href="https://creativecommons.org/licenses/by-sa/3.0/de/">Creative Commons Namensnennung - Weitergabe unter gleichen Bedingungen 3.0</a></p>
<p><a href="https://github.com/molily/javascript-einfuehrung">JavaScript-Einführung auf Github</a></p>
<p>Kostenloses Online-Buch und E-Book:<br><a href="https://testing-angular.com" lang="en" hreflang="en">Testing Angular – A Guide to Robust Angular Applications</a> (englisch)</p>
</div>
<script src="js-doku.js"></script>
</body>
</html>