Vor dem Lesen dieses Buches möchte ich dem technischen Team von Taobao für die Übersetzung dieses JavaScript -Kerns und Flanagan für das Schreiben dieses Buches danken. Vielen Dank für Ihr selbstloses Teilen, und nur diese Notiz ist Ihrer harten Arbeit gewidmet.
1: JavaScript -Sprachkern
Nach diesem Kapitel werden wir uns hauptsächlich auf die Grundlagen von JavaScript konzentrieren. Kapitel 2 Wir werden die Kommentare, Semikolons und Unicode -Charakter -Sätze von JavaScript erläutern. Kapitel 3 wird interessanter sein und hauptsächlich die Variablen und Zuordnungen von JavaScript erklären
Hier sind einige Beispielcodes, um den Schlüsselinhalt der ersten beiden Kapitel zu veranschaulichen.
Die Codekopie lautet wie folgt:
<script type = "text/javaScript">
// Der Inhalt nach dem doppelten Schrägstrich gehört zum Kommentar
// Lesen Sie die Kommentare hier sorgfältig durch, es erklärt den JavaScript -Code
// Variable ist ein symbolischer Name, der den Wert darstellt
// Variablen werden über das Schlüsselwort var deklariert
var x; // eine Variable x deklarieren x
// Der Wert kann der Variablen durch Symbole zugewiesen werden
x = 0; // Der Wert der Variablen x beträgt jetzt 0
x // seinen Wert nach variabler Name erhalten.
// JavaScript unterstützt mehrere Datentypen
x = 1; //Nummer
x = 0,01; // Ganzzahlen und reelle Zahlen teilen einen Datentyp
x = "Hallo Welt"; // Konstruieren Sie eine Textzeichenfolge in doppelten Zitaten
x = 'Hallo Welt'; // einzelne Zitate bilden auch Zeichenfolgen.
x = wahr; // boolean
x = falsch; // ein anderer boolescher Wert
x = null; // null ist ein besonderer Wert. Bedeutet leer
x = undefiniert; // undefined und null sind sehr ähnlich
</script>
In JavaScript sind die wichtigsten Typen Objekte und Arrays. Kapitel 6 führt Objekte ein und Kapitel 7 führt Arrays ein. Objekte und Arrays sind in JavaScript so wichtig. So sehr, dass sie überall in diesem Buch gesehen werden können.
Die Codekopie lautet wie folgt:
<script type = "text/javaScript">
// Der wichtigste Typ in JavaScript ist das Objekt
// Objekt ist eine Sammlung von Namen/Wertpaaren oder eine Sammlung von Stringwerten zu kartierten Werten.
var book = {// Objekte sind in lockigen Klammern eingeschlossen
Thema: "JavaScript", // Der Wert des Attributs "Thema" ist JavaScript
Fett: Richtig // Der Wert des Eigenschaft Fett ist wahr
}; // Die lockigen Zahnspangen am rechten Ende.
// Zugriff auf Objekteigenschaften über "." oder "[]".
book.topic // => "JavaScript"
buchen ["fat"] // => true eine andere Möglichkeit, Attribute zu erhalten,
book.author = "ahthw"; // Erstellen Sie ein neues Attribut nach Zuweisung
book.content = {}; // {} ist ein leeres Objekt. Es hat keine Attribute
// JavaScript unterstützt auch Arrays (Listen, die von Arrays indiziert sind)
var primes = [2, 3, 5, 7]; // hat eine Kombination von 4 Werten, die Grenze wird von "[" ""] "" "
Primzahlen [0] // => 2: Das erste Objekt des Arrays, der Index ist 0
Primes.Length // => 4, die Anzahl der Elemente im Array
Primes [Primes.Length-1] // => 7: Das letzte Element im Array
Primzahlen [4] = 9; // Neue Elemente nach Zuordnung hinzufügen
Primzahlen [4] = 11; // Die vorhandenen Elemente durch Zuweisung ändern
var leer = []; // leeres Array mit 0 Elementen
leer.length // =>: 0
// Arrays und Objekte können ein anderes Array oder Objekt enthalten.
var point = [// Array mit zwei Elementen
{x: 0, y: 0}, // Jedes Element ist ein Objekt
{x: 1, y: 1}
];
var data = {// ein Objekt, das zwei Attribute enthält
triverse1: [[1,2], [3,4]], // Jedes Objekt ist ein Array
Versuch2: [[2,3], [4,5]] // Die Elemente des Arrays sind ebenfalls Arrays
};
</script>
Die Syntax des obigen Code, der Array -Elemente über quadratische Klammern definiert und die Zuordnungsbeziehung zwischen Objektattributnamen und Attributwerten über lockige Klammern definiert. Kapitel 4 wird speziell eingeführt. Ausdrücke sind eine Phrase in JavaScript. Dieser Ausdruck kann berechnet werden, um einen Wert zu erhalten und den Wert von Objektattributen oder Array -Elementen durch "und" [] "zu verweisen, um einen Ausdruck zu bilden.
Die häufigste Ausdrucksschreibmethode in JavaScript sind Operatoren wie der folgende Code (Oprator)
Die Codekopie lautet wie folgt:
// Bediener als Bediener generiert einen neuen Wert
// der häufigste arithmetische Operator
3+2 // => 5 Zugabe
3-2 // => Subtraktion
3*2 // => multiple
3/2 // => Abteilung
Punkt [1] .x -point [0] .x // => Komplexe Operationen können auch wie gewohnt funktionieren
"3"+"2" // => 32. Sie können Additionsvorgänge oder String -Spleißen ausführen.
// JavaScript definiert einige arithmetische Operatoren als Abkürzung
var count = 0; // eine Variable definieren
zählen ++; // Erhöhung um 1
zählen--; // Dekrement um 1
zählen += 2; // Die automatische Inkrement 2 entspricht "count = count = count + 2";
count *= 3 // multiplizieren 3. gleich. genauso wie "count = count *3;" ist geschrieben
Graf // => 6: Der variable Name selbst ist auch ein Ausdruck
// Der Betreiber von Gleichstellungsbeziehungen wird verwendet, um festzustellen, ob die beiden Werte gleich sind oder nicht
// ungleich, größer als das Ergebnis des Bedienungsbetriebs ist wahr oder falsch
var x = 2, y = 3; // Das gleiche Zeichen hier bedeutet Zuordnung, nicht relativ gleich
x == y; // => falsch gleich
X! = y; // => true
x <y; // => true: weniger als
x <= y; // true ist kleiner als oder gleich zu
x> y; // falsch größer als
x> = y; // falsch größer als oder gleich zu
"zwei" == "drei"; // falsche zwei Saiten sind nicht gleich
"zwei"> "drei"; // true der Index von "tw" im Alphabet ist größer als "Th"
false == (x> y); // ture false = false;
// logische Operatoren werden zusammengeführt oder umgekehrt von Booleschen Werten umgekehrt
(x == 2) && (y == 3); // => true beide Vergleiche sind wahr. && ist "und"
(x> 3) || (y <3); // => Falsch keiner der Vergleiche ist wahr. || bedeutet "oder"
! (x == y); // => wahr! Zeigt inverse Suche an
Wenn die "Phrase" in JavaScript ein Ausdruck ist, wird der gesamte Satz als Anweisung bezeichnet, der in Kapitel 5 ausführlich erklärt wird.
Im obigen Code sind die Zeilen, die mit einem Semikolon enden, alle Aussagen. Auf raue Weise berechnet der Ausdruck nur einen Wert (oder der Wert, mit dem er enthält), aber sie ändern den laufenden Status des Programms. Im obigen Bereich wurden Variable -Deklarations -Anweisungen und Zuweisungsanweisungen festgestellt. Eine andere Art von Aussage ist die "Kontrollstruktur", wie z. B. bedingte Beurteilung und Schleife. Nach der Einführung der Funktion geben wir einen relevanten Beispielcode an.
Funktionen sind JavaScript -Code -Snippets mit Namen und Parametern, die mehrmals definiert und verwendet werden können. Kapitel 8 erläutert die Funktionen formell im Detail. Wie Objekte und Arrays werden Funktionen an vielen Stellen in diesem Buch erwähnt. Hier finden Sie einen einfachen Beispielcode.
Die Codekopie lautet wie folgt:
// Die Funktion ist ein JavaScript -Code -Segment mit Behandlungsparametern, das mehrmals übertragen werden kann
Funktion plus1 (x) {// Definieren Sie eine Funktion namens Plus1 mit dem Parameter x
Rückgabe x + 1; // geben einen Wert zurück, der 1 größer ist als der übergebene.
} // Der Codeblock der Funktion ist der Teil, der in lockige Klammern eingewickelt ist
plus1 (y) //
var square = Funktion (x) {// Funktion ist ein Wert, der einer Variablen zugewiesen werden kann
return x*x; // Berechnen Sie den Wert der Funktion
}; // Das Semikolon gibt das Ende der Zuweisungsanweisung an
Quadrat (plus1 (y)); // ein zwei Funktionen in einem Ausdruck
Wenn die Funktion und das Objekt zusammen geschrieben sind, ist die Funktion mit einer "Methode" (Methode) programmiert.
Die Codekopie lautet wie folgt:
// Wenn dem Attribut eines Objekts eine Funktion zugewiesen wird, nennen wir es
// "Methode", alle JavaScript -Objekte enthalten Methoden
var a = []; // Erstellen Sie ein leeres Array
A.push (1,2,3); // Objekte zum Array zur PUSP () -Methode hinzufügen
A.Reverse (); // Datenumkehr
// document.write (a)
// Wir können die Methode von Sub- definieren Das Schlüsselwort "This" ist die Definitionsmethode
Verweis auf das Objekt von //, das Beispiel hier ist das Array, das zwei oben genannte Punktinformationen enthält.
points.dist = function () {// Definieren Sie eine Methode, um den Abstand zwischen zwei Punkten zu berechnen
var p1 = this [0]; // Erhalten Sie den Verweis auf das aktuelle Array über dieses Schlüsselwort
var p2 = this [1]; // und holen Sie sich die ersten beiden Elemente des angerufenen Arrays
var a = p2.xp1.y; // Entfernung auf der X -Koordinatenachse
var b = p2.y - p1.y; // Entfernung auf der y-koordinierten Achse
return math.sqrt (a * a + "wir nennen es" + b * b); // Pythagoreische Theorem
}; //Math.sqrt () berechnet die Quadratwurzel
points.dist () // => Finden Sie den Abstand zwischen zwei Punkten
Geben Sie nun einige Beispiele für Kontrollanweisungen an. Hier enthält die Beispielfunktion die häufigsten JavaScript -Kontrollanweisungen im Körper.
Die Codekopie lautet wie folgt:
// Hier verwendet die JavaScript -Anweisung diese Syntax, um bedingte Beurteilung und Schleife zu enthalten
// Die Syntax ähnelt Java C ++ und anderen Sprachen
Funktion ABS (x) {// Finden Sie die Absolutwertfunktion
if (x> = 0) {// if
Rückkehr x; // Wenn wahr, führen Sie diesen Code aus
} else {// false ausführen
return -x;
}
}
Funktion FaktenPrial (n) {// Berechnung des Faktororials
var product = 1; // Zuwenden Sie dem Produkt einen Wert von 1
While (n> 1) {// Schleife, um {} Inhalt auszuführen, wenn der Wertexpression () wahr ist
Produkt *= n; // product = product * Abkürzung
N--; // n = n-1 Schreibmethode
} // Die Schleife endet
Rückgabeprodukt; // Produkt zurückgeben
}
FACTPRIAL (4) // => 24 1*4*3*2 Dokument.Write (factPrial (4))
Funktion factorial2 (n) {// Eine andere Möglichkeit, eine Schleife zu schreiben
var i, produkt = 1; //
für (i = 2; i <= n; i ++) // erhöhen Sie i von 2 nach n
Produkt *= i; // Schleifenkörper, wenn es nur einen Code -Satz im Schleifenkörper gibt, lassen Sie {} weg, {}
Rückgabeprodukt; // Berechnen und geben Sie die gute Fakultät zurück;
}
factorial2 (5) //document
JavaScript ist eine objektorientierte Programmiersprache, unterscheidet sich jedoch sehr von herkömmlichen Seitenobjekten. Kapitel 9 erklärt das objektorientierte JavaScript im Detail. In diesem Kapitel wird viel Beispielcode enthalten, das das längste Kapitel in diesem Buch ist.
Hier ist ein einfaches Beispiel: Dieser Code zeigt, wie eine Klasse in JavaScript definiert wird, um Punkte in der Geometrie von 2D -Gesichtern darzustellen. Das in dieser Klasse instanziierte Objekt verfügt über eine Methode namens R (), um den Abstand von wechselnden Punkten in den Ursprung zu berechnen.
Die Codekopie lautet wie folgt:
// einen Konstruktor definieren, um ein neues Punktobjekt zu initialisieren
Funktionspunkt (x, y) {// Konstruktoren beginnen im Allgemeinen mit Großbuchstaben
this.x = x; // Das Schlüsselwort, das dies auf die initialisierte Instanz bezieht
this.y = y; // Speicherfunktionsparameter als Attribute eines Objekts
}
// Erstellen Sie eine Instanz mit dem neuen Schlüsselwort und dem neuen Konstruktor
var p = neuer Punkt (1, 1); // Punkte 1, 1 in der Ebene Geometrie,
// Wert durch das Konstruktorprototypobjekt zuweisen
// Methoden für Punktobjekte definieren
Point.prototype.r = function () {
Return Math.sqrt (// RECHTE DIE Square -Wurzel des X Square + Y Square zurück
this.x * this.x + // Dies bezieht sich auf das Objekt, das diese Methode transportiert
this.y * this.y);
};
// Point's Instance -Objekt P (und alle Punktinstanzobjekte) erbt die Methode r ()
PR () // => 1.4142135623730951 /document.write (pr ())
Kapitel 9 ist die Essenz des ersten Teils . Die nachfolgenden Kapitel wurden sporadisch erweitert, was uns zum Ende unserer Erforschung von JavaScript führen wird.
Kapitel 10 spricht hauptsächlich über Textanpassungsmuster, die von regulären Ausdrücken durchgeführt werden.
Kapitel 11 DIE KOKE -SUBSETTIERUNG UND SUPERSET VON GIFFEN JAVASRICT .
Bevor Sie den Inhalt von JavaScript im Client eingeben, stellen Kapitel 12 nur zwei JavaScript -Ausführungen außerhalb des Webs vor.
2. Client JavaScript
Es gibt viele Querverweise auf die Inhaltskenntnisse im Kernteil der JavaScript-Sprache, und das Wissensgefühl ist nicht klar. Die Inhaltsorchestrierung von JavaScript auf der Clientseite hat sich stark verändert. Nach diesem Kapitel können Sie JavaScript in einem Webbrowser verwenden. (Wenn Sie jedoch JavaScript durch das Lesen dieses Buches lernen möchten, können Sie sich nicht einfach auf den zweiten Teil konzentrieren.) Kapitel 13 ist der erste Teil des zweiten Teils, in dem JavaScript in einem Webbrowser ausgeführt wird. Kapitel 14 erklärt die Webbrowser -Skripttechnologie und deckt eine wichtige globale Funktion des Client Javascipt ab.
Zum Beispiel:
Die Codekopie lautet wie folgt:
Funktion moveon () {
// Stellen Sie eine Frage über das Dialogfeld
var antwort = bestätigen ("Sind Sie bereit?");
// Klicken Sie auf OK und der Browser lädt eine neue Seite
if (Antwort) window.location = "http://www.baidu.com";
}
// Führen Sie diese Funktion nach 1 Minute aus (60000 Millisekunden)
setTimeout (Moveon, 300);
In Kapitel 15 erfahren Sie, wie JavaScript den HTML -Stil manipulieren kann, um die Anzeigemethode des Inhalts zu definieren . Der Inhalt von Kapitel 15 wird pragmatischer sein. Mit Skripten wird angezeigt, wie Sie bestimmte Webseitenelemente auswählen, die Attribute für HTML -Elemente festlegen, wenn der Inhalt des Elements geändert wird und wie Sie dem Dokument neue Knoten hinzufügen können
Die folgende Beispielfunktion zeigt, ob Sie den grundlegenden Artikelinhalt finden und ändern
Die Codekopie lautet wie folgt:
// Eine angegebene Information im Dokument und im Gebietsbaum befindet sich über Debugging -Informationen
// Wenn dieses Element im Dokument nicht vorhanden ist, erstellen Sie a
Funktionsdebug (MSG) {
// Finden Sie den Debugging -Teil des Dokuments, indem Sie das ID -Attribut des HTML -Elements anzeigen
var log = document.getElementById ("Debuglog");
// Wenn das Element nicht existiert, erstellen Sie a
if (! log) {
log = document.createelement ("div"); // Erstellen Sie ein neues DIV -Element
log.id = "debuglog"; // Wert der ID jedes Elements Wert zuweisen
log.innerhtml = "<h1> Debugug -log </h1>"; // Passen Sie den anfänglichen Inhalt an
document.body.Appendchild (log); // Fügen Sie es zum Ende des Dokuments hinzu
}
// Die Nachricht in <pre> eingeben und dem Protokoll hinzufügen
var pre = document.createelement ("pre"); // Pre -Element erstellen
var text = document.createelement (msg); // MSG in einen Textknoten einschließen
pre.AppendChild (Text); // Text zu PREE hinzufügen
log.AppendChild (pre); // Pre Add to Log
}
In Kapitel 16 wird darüber gesprochen, wie JavaScript verwendet wird, um Elemente zu bedienen , die normalerweise die Stil- und Klassenattribute des Elements verwendet.
Die Codekopie lautet wie folgt:
Funktion ausblenden (e, Reflow) {// Elemente manipulieren und Elemente E durch JVascript verstecken
if (reflow) {// Wenn der zweite Parameter wahr ist
E.Style.display = "Keine" // Verstecke dieses Element, und der Platz, den er einnimmt, wird ebenfalls verkauft
} anders {
E.Style.visibility = "Hidden"; // E ausblenden und den Raum behalten, den es benötigt
}
}
Funktion Highlight (e) {// Highlight E durch Einstellen von CSS
if (! e.className) e.className = "Highcss";
anders
E. ClassName += "Highcss";
}
Der Inhalts- und CSS -Elementstil können über JavaScript gesteuert werden, und das Dokumentverhalten kann auch durch Ereignishandler definiert werden. Die Ereignisbehandlung ist eine JavaScript -Funktion, die im Browser Center registriert ist. Wenn ein bestimmtes Ereignis auftritt, kann der Browser diese Funktion aufrufen.
Normalerweise sind die Arten von Ereignissen, auf die wir uns konzentrieren, Mausklicks und Tastaturschlüsselereignisse (Smartphones sind verschiedene Touch -Events). Wenn der Browser das Dokumentladen abschließt, wird ein Personenereignis ausgelöst, wenn der Benutzer die Größe des Fensters ändert oder wenn der Benutzer Daten in das Formular eingibt.
In Kapitel 17 wird ausführlich beschrieben, wie man Zeithandler definiert, registriert und wie der Browser sie beim Auftreten von Ereignissen nennt.
Der einfachste Weg, Ereignishandler anzupassen, besteht darin, einen Rückruf an das von HTML vorangestellte Attribut zu binden. Beim Schreiben einiger einfacher Programmtests besteht der praktischste Weg darin, einen Rückruf an den "Onclick" -Handler zu binden. Unter der Annahme, dass die obigen Debug () und hide () -Funktionen in den oben genannten Debug.js- und Hide.js -Dateien gespeichert werden, können Sie einfach einen Ereignishandler für das Onclick -Attribut angeben. wie folgt
Die Codekopie lautet wie folgt:
<script type = "text/javaScript">
// Eine angegebene Information im Dokument und im Gebietsbaum befindet sich über Debugging -Informationen
// Wenn dieses Element im Dokument nicht vorhanden ist, erstellen Sie a
Funktionsdebug (MSG) {
// Finden Sie den Debugging -Teil des Dokuments, indem Sie das ID -Attribut des HTML -Elements anzeigen
var log = document.getElementById ("Debuglog");
// Wenn das Element nicht existiert, erstellen Sie a
if (! log) {
log = document.createelement ("div"); // Erstellen Sie ein neues DIV -Element
log.id = "debuglog"; // Wert der ID jedes Elements Wert zuweisen
log.innerhtml = "<h1> Debugug -log </h1>"; // Passen Sie den anfänglichen Inhalt an
document.body.Appendchild (log); // Fügen Sie es zum Ende des Dokuments hinzu
}
// Die Nachricht in <pre> eingeben und dem Protokoll hinzufügen
var pre = document.createelement ("pre"); // Pre -Element erstellen
var text = document.createelement (msg); // MSG in einen Textknoten einschließen
pre.AppendChild (Text); // Text zu PREE hinzufügen
log.AppendChild (pre); // Pre Add to Log
}
Funktion ausblenden (e, Reflow) {// Elemente manipulieren und Elemente E durch JVascript verstecken
if (reflow) {// Wenn der zweite Parameter wahr ist
E.Style.display = "Keine" // Verstecke dieses Element, und der Platz, den er einnimmt, wird ebenfalls verkauft
} anders {
E.Style.visibility = "Hidden"; // E ausblenden und den Raum behalten, den es benötigt
}
}
Funktion Highlight (e) {// Highlight E durch Einstellen von CSS
if (! e.className) e.className = "Highcss";
anders
E. ClassName += "Highcss";
}
</script>
Hallo
<button onclick = "Hide (this, true); Debuggen ('Button 1');"> Hide1 </button>
<button onclick = "Hide (this); Debug ('Button 2');"> Hide2 </Butotn>
Der folgende Client JavaScript verwendet Ereignisse, die ein sehr wichtiges Ereignis verleihen: Das "Load" -Event registriert ein Ereignis, um Chenxing zu verarbeiten. Kollegen zeigen auch eine fortgeschrittenere Möglichkeit zum Registrieren von "Klicken" Ereignishandler
Die Codekopie lautet wie folgt:
<script type = "text/javaScript">
// Das "Ladeereignis" kann erst nach dem Laden des Dokuments abgefeuert werden
// Wenn Sie normalerweise auf das Lastereignis warten müssen, bevor Sie den JavaScript -Code ausführen können
window.onload = function () {
// Finden Sie alle IMG -Tags im Dokument
var images = document.getElementsByTagName ("img");
// Übertragen Sie die Bilder und fügen Sie dem Klickereignis eines jeden Knotens einen Handler hinzu
// Verstecke das Bild beim Klicken darauf
für (var i = 0; i <images.length; i ++) {
var imge = Bilder [i];
if (iMge.addeventListener) // Eine andere Möglichkeit, Zeithandler zu registrieren
IMge.AdDeVentListener ("Click", ausblenden, false);
sonst // kompatibel mit früheren Operationen von IE8
IMge.attacheAvent ("Onclick", Hide);
}
// Dies ist die oben genannte Funktionsverarbeitungsfunktion
Funktion Hide (evnet) {
event.target.style.visibility = "Hidden";
}
};
</script>
In Kapitel 15-17 wird angegeben, wie Sie JavaScript verwenden, um den Inhalt, den Stil und das Verhalten von Webseiten (Ereignisverarbeitung) zu steuern . In diesem Kapitel wird die API ein wenig kompliziert erörtert und hat bisher eine schlechte Browserkompatibilität. Aus diesem Grund verwenden viele JavaScript -Programmierer "Bibliothek" oder "Framework", um ihre Codierungsarbeiten zu vereinfachen. Das beliebteste ist JQuery. Kapitel 19 führt die JQuery -Bibliothek vor
Die Codekopie lautet wie folgt:
Funktionsdebug (MSG) {
var log = $ ("#debuglog");
if (log.length == 0) {
log = $ ("<div id = 'debuglog'> <h1> debuglog </h1> </div>");
log.Appendto (document.body);
}
document.write (Protokoll)
log.Append ($ ("<pre/>"). text (msg));
};
Die vier Kapitel des von uns erwähnten zweiten Teils werden auf Webseiten besprochen. Die folgenden vier Kapitel konzentrieren sich auf den Laden und wenden sich an Webanwendungen. Diese Inhalte werden nicht diskutiert, wie man Inhalte schreibt und manipuliert. Stile und blühende Skripte verwenden Webbrowser, um Dokumente zu rendern. Erklären Sie stattdessen, wie Sie Webbrowser als Anwendungsplattform verwenden. Und beschreibt APIs für die Unterstützung komplexerer und raffinierterer Client -Webanwendungen und moderner Browser.
In Kapitel 18 wird erläutert, wie Sie JavaScript verwenden, um HTTP -Anforderungen zu initiieren.
Kapitel 20 beschreibt den Datenspeichermechanismus und den Sitzungsstatuswartung von Client -Anwendungen . Kapitel 21 deckt die neue Generation von Application APIs/Netzwerkspeichergrafiken ab, die von HTML5 gesteuert werden. Diese basieren auf der Browserentwicklung, die neue APIs unterstützt. Zhejiang ist Ihr aufregendster Moment als JavaScript -Programmierer. In den letzten 4 Kapiteln gibt es nicht viel Beispielcode. Das folgende Beispiel verwendet diese neuen APIs.