JavaScript (kurz JS) ist eine Skriptsprache, die ursprünglich 1995 von Netscape für dynamisches HTML in Webbrowsern entwickelt wurde, um Benutzerinteraktionen auszuwerten, Inhalte zu verändern, nachzuladen oder zu generieren und so die Möglichkeiten von HTML zu erweitern. Heute wird JavaScript auch außerhalb von Browsern angewendet, etwa auf Servern und in Microcontrollern.
| JavaScript | |
|---|---|
// Beispiel JavaScript function halloWelt() { alert('Hello World'); } window.onload = halloWelt; | |
| Basisdaten | |
| Paradigmen: | multiparadigmatisch |
| Erscheinungsjahr: | 1995 |
| Designer: | Brendan Eich |
| Entwickler: | Brendan Eich |
| Aktuelle Version: | ECMAScript 2023 (Juni 2023) |
| Typisierung: | schwach, dynamisch, duck |
| Wichtige Implementierungen: | SpiderMonkey, Rhino, JavaScriptCore, V8 |
| Beeinflusst von: | Self, C, Scheme, Perl, Python, Java, Lua |
| Beeinflusste: | ActionScript, Haxe, CoffeeScript, Dart, TypeScript |
| Lizenz: | BSD |
| www.ecma-international.org/publications-and-standards/standards/ecma-262/ |
Der heutige Name der ursprünglich LiveScript genannten Sprache entstand 1996 aus einer Kooperation von Netscape mit Sun Microsystems. Deren Java-Applets, erstellt mit der gleichfalls 1995 veröffentlichten Programmiersprache Java, wurden mithilfe von LiveScript in den Netscape Navigator integriert. Um die Popularität von Java zu nutzen, wurde LiveScript in JavaScript umbenannt, obwohl die beiden Sprachen voneinander unabhängig entwickelt wurden und völlig unterschiedliche Grundkonzepte aufweisen.
Der als ECMAScript (ECMA 262) standardisierte Sprachkern von JavaScript beschreibt eine dynamisch typisierte, objektorientierte, aber klassenlose Skriptsprache. Sie wird allen objektorientierten Programmierparadigmen unter anderem auf der Basis von Prototypen gerecht, deren Deklaration ab ECMAScript 6 mit einer Syntax ermöglicht wird, wie sie ähnlich auch bei klassenbasierten Programmiersprachen üblich ist. In JavaScript lässt sich je nach Bedarf objektorientiert, prozedural oder funktional programmieren.
Entwicklung
Die Syntax von JavaScript ähnelt C-Abkömmlingen. Trotz der Namens- und syntaktischen Ähnlichkeit hat JavaScript nur geringe Gemeinsamkeiten mit Java. So wird in JavaScript Vererbung nicht durch Klassen, sondern durch Prototypen unterstützt.
JavaScript wurde früher hauptsächlich clientseitig eingesetzt. JavaScript bzw. die ECMAScript-Implementierungen ermöglichen aber beispielsweise mit dem Framework Node.js und als JScript bzw. JScript .NET in einer ASP- bzw. ASP.NET-Umgebung auf Microsoft Internet Information Services auch serverseitige Anwendungen. Weitere Beispiele für serverseitige JavaScript-Programmierung sind POW und Jaxer, die auf der Mozilla-JavaScript-Engine SpiderMonkey aufsetzen, V8CGI, welches auf der JavaScript-Implementierung V8 aufbaut und in den Apache HTTP Server integriert wird, sowie QML, eine erweiterte Form von JavaScript zum Zeichnen von Oberflächen und Animationen.
Die Sprache wird auch als Skriptsprache für Spiele und Anwendungsprogramme eingesetzt, da der Sprachkern nur wenige Objekte enthält und dadurch der zur Ausführung von in JavaScript formulierten Skripten erforderliche Interpreter relativ klein gehalten werden kann.
Außerdem wird JavaScript als Verkehrssprache in der Datenbank MongoDB sowie in Microcontrollern eingesetzt.
Verwendung
Typische Anwendungsgebiete
Typische Anwendungsgebiete von JavaScript im Webbrowser sind:
- dynamische Manipulation von Webseiten über das Document Object Model
- Plausibilitätsprüfung (Datenvalidierung) von Formulareingaben noch vor der Übertragung zum Server
- Anzeige von Dialogfenstern
- Senden und Empfangen von Daten, ohne dass der Browser die Seite neu laden muss (Ajax)
- Vorschlagen von Suchbegriffen während der Eingabe
- Werbebanner oder Laufschriften
- Verschleierung von E-Mail-Adressen zur Bekämpfung von Spam
- mehrere Frames auf einmal wechseln oder die Seite aus dem Frameset lösen
- Schreib- und Lesezugriff auf Cookies und den Web Storage innerhalb des Browsers
Missbrauch
Einige Anwendungen, die mit JavaScript möglich sind, agieren teilweise gegen den Wunsch des Benutzers oder widersprechen dem Prinzip der geringsten Überraschung. Einige Browser bieten daher Funktionen an, die derartige JavaScript-Funktionen unterdrücken.
Beispiele:
- Verschleiern von Internetadressen, auf die ein Link verweist
- Deaktivieren des Kontextmenüs, um zu erschweren, dass Bilder oder die gesamte Seite abgespeichert werden können
- Deaktivieren der Kopierfunktion, um zu erschweren, dass Texte oder Bilder kopiert werden können
- Unaufgeforderte (Werbe-)Pop-ups oder Pop-unders oder aufeinanderfolgende Dialogfenster, die den Benutzer behindern
- Ungewolltes Schließen des Browserfensters
- Ungewollte Größenänderung des Browserfensters
- Barrierearme Webseiten zeichnen sich dadurch aus, dass sie auch bei abgeschaltetem JavaScript möglichst uneingeschränkt nutzbar bleiben. Teilweise schränkt das deaktivierte JavaScript die Benutzbarkeit einer Webseite ein.
- Maßnahmen, die an den Sicherheitseinstellungen des Browsers vorbei ein Wiedererkennen eines Benutzers bei einem späteren Besuch einer Website erlauben (siehe Anonymität im Internet)
- Bei anfälligen Webanwendungen kann JavaScript auch von Dritten missbraucht werden, etwa per XSS (Codeeinschleusung).
Geschichte
Am 18. September 1995 veröffentlichte Netscape mit der Vorversion des Navigators 2.0 einen Browser mit einer eingebetteten Skriptsprache, die zu diesem Zeitpunkt LiveScript hieß und von Brendan Eich entwickelt worden war. Die Sprache konnte u. a. Formulareingaben des Benutzers vor dem Absenden überprüfen. Am 4. Dezember 1995 verkündeten Netscape und Sun Microsystems eine Kooperation, die die Interaktion von LiveScript direkt mit Java-Applets zum Ziel hatte. Sun entwickelte die nötigen Java-Klassen, Netscape die Schnittstelle LiveConnect und benannte die Sprache in JavaScript um (JavaScript 1.0). JavaScript ist seit der Übernahme von Sun Microsystems eine Marke des Unternehmens Oracle.
Mit der ersten Beta-Version des Navigators 3.0 führte Netscape am 29. April 1996 JavaScript 1.1 ein. In selbiger Version gab es die Neuerungen, auf Bilder zugreifen und sogenannte Rollover-Grafiken erstellen zu können. LiveConnect war jetzt fester Bestandteil des Browsers. Mit der Beta-Version des Internet Explorers 3 stellte Microsoft im Mai 1996 seinen ersten JScript-fähigen Browser vor. Dies war der Beginn des Browserkriegs.
Mit der Ankündigung des Netscape Communicators wurde JavaScript 1.2 am 15. Oktober 1996 veröffentlicht; der Netscape Communicator 4.0 mit JavaScript 1.2 erschien jedoch erst am 4. Juni 1997. Ebenfalls im Juni 1997 veröffentlichte die European Computer Manufacturers Association ihren Standard ECMA-262 (ECMAScript), der zusammen mit Netscape entwickelt worden war und die Grundelemente einer Skriptsprache standardisieren sollte. Diese wurde im April 1998 zur ISO-Norm ISO/IEC 16262:1998 Information technology – ECMAScript language specification. Am 1. Oktober 1997 kam der Internet Explorer 4 heraus, der den Sprachumfang von JavaScript 1.1 abdeckte. Darüber hinaus wurden eigene Erweiterungen veröffentlicht, die zu Kompatibilitätsunterschieden zwischen Navigator und Internet Explorer führten und eine DOM-ähnliche Syntax zur Verfügung stellten, die es ermöglichte, auf alle Elemente der Webseite zuzugreifen und diese beliebig verändern zu können.
Der in Java implementierte JavaScript-Interpreter Rhino wurde ab Version 6.0 als Teil der Java-Laufzeitumgebung standardmäßig mitgeliefert. Im Juli 1998 wurde mit der Beta-Version des Netscape Communicators 4.5 JavaScript 1.3, welche schon in der Version 4.06 des Netscape Communicators vorhanden war, veröffentlicht. Im Oktober 1998 stellte Netscape JavaScript 1.4 vor. Diese Version war vollständig kompatibel mit ECMA-262. Ein Browser mit der Unterstützung dieser Version erschien jedoch nicht. Im April 2000 kam mit der Preview Release 1 des Navigators 6 JavaScript 1.5 und DOM Level 1. Am 5. Juni 2002 erschien Mozilla 1.0 mit JavaScript 1.5 (JavaScript in der Version 1.5 entspricht ECMA-262 Version 3), am 29. November 2005 Mozilla Firefox 1.5 mit JavaScript 1.6, am 12. Juli 2006 Mozilla Firefox 2.0b1 mit JavaScript 1.7 und am 18. Dezember 2007 Mozilla Firefox 3.0b2 mit JavaScript 1.8.
Versionsgeschichte von JavaScript
| Version | Veröffentlichung | Entsprechung | Netscape Navigator | Mozilla Firefox | Internet Explorer | Opera | Safari | Google Chrome |
|---|---|---|---|---|---|---|---|---|
| 1.0.0 | März 1996 | 2.0 | 3.0 | |||||
| 1.1.0 | August 1996 | 3.0 | ||||||
| 1.2.0 | Juni 1997 | 4.0–4.05 | ||||||
| 1.3.0 | Oktober 1998 | ECMA-262 1st edition / ECMA-262 2nd edition | 4.06–4.7x | 4.0 | ||||
| 1.4.0 | Netscape Server | |||||||
| 1.5.0 | November 2000 | ECMA-262 3rd edition | 6.0 | 1.0 |
|
| ||
| 1.6.0 | November 2005 | 1.5 + Array extras + Array & String generics + E4X | 1.5 |
| ||||
| 1.7.0 | Oktober 2006 | 1.6 + Pythonic generators + Iterators + let + destructuring assignments | 2.0 |
| 1.0 | |||
| 1.8.0 | Juni 2008 | 1.7 + Generator expressions + Expression closures | 3.0 | |||||
| 1.8.1 | Juni 2009 | 1.8 + geringfügige Updates | 3.5 | |||||
| 1.8.2 | Januar 2010 | 1.8.1 + geringfügige Updates | 3.6 | |||||
| 1.8.5 | Juli 2010 | 1.8.1 + ECMAScript 5 Compliance | 4 | 9.0 (JScript 9.0) |
Versionsgeschichte von ECMAScript (ECMA-262)
Die aktuelle Version ist die Version 2022, die im Juni 2022 als „ECMAScript 2022“ veröffentlicht wurde. Dieser sollen jährliche Updates folgen. Die Entwicklung der Standards erfolgt auf GitHub.
| Version | publiziert am | Unterschiede zur Vorgängerversion | Editor |
|---|---|---|---|
| 1 | Juni 1997 | erste Version | Guy L. Steele, Jr. |
| 2 | Juni 1998 | Änderungen zwecks Kompatibilität zum internationalen Standard ISO/IEC 16262 | Mike Cowlishaw |
| 3 | Dez. 1999 | Neu sind reguläre Ausdrücke, bessere Verarbeitung von Zeichenketten, Kontrollfluss, Fehlerbehandlung mit try/catch, bessere Fehlerbehandlung, bessere Formatierung bei der Ausgabe von Zahlen usw. | Mike Cowlishaw |
| 4 | abgebrochen | Wegen Uneinigkeit in Bezug auf die Zukunft der Sprache wurde die weitere Entwicklung des komplexen Entwurfes zu ECMAScript 4 eingestellt. Einige Ideen werden in ES6 wieder aufleben. | |
| 5 | Dez. 2009 | Im „strict mode“ wird eine erweiterte Fehlerprüfung eingeschaltet. Unklare Sprachkonstrukte von ECMAScript 3 werden entschärft und neue Features wie getter- und setter-Methoden, Unterstützung von JSON usw. hinzugefügt. | Pratap Lakshman, Allen Wirfs-Brock |
| 5.1 | Juni 2011 | Entspricht dem internationalen Standard ISO/IEC 16262:2011, Version 3 | Pratap Lakshman, Allen Wirfs-Brock |
| 2015 | Juni 2015 | Neue Syntax für komplexe Applikationen wie Klassen und Module, die aber mit ähnlicher Terminologie wie in ECMAScript 5 (strict mode) definiert werden können. Neue Sprachbestandteile wie for/of-Schleifen, teilweise an Python angelehnte Syntax usw. Der Codename lautet “Harmony” und wurde bis kurz vor Verabschiedung als „ECMAscript 6“ bezeichnet. | Allen Wirfs-Brock |
| 2016 | Juni 2016 | ** (Potenzfunktion), Array.prototype.includes, diverse Anpassungen an Generatoren, destruktiven Zuweisungen | Brian Terlson |
| 2017 | Juni 2017 | async/await, diverse Object-Funktionen | Brian Terlson |
| 2018 | Juni 2018 | global, import(), Rest/Spread Properties, for-await-of (Asynchronous Iterators), String-Padding, … | Brian Terlson |
| 2019 | Juni 2019 | Array#{flat,flatMap}, Object.fromEntries, String#{trimStart,trimEnd}, Symbol#description, … | Brian Terlson, Bradley Farias, Jordan Harband |
| 2020 | Juni 2020 | String.matchAll, BigInt, import(), … | Jordan Harband, Kevin Smith |
| 2021 | Juni 2021 | String.prototype.replaceAll, WeakRefs, Logical Assignment Operators, … | Jordan Harband, Shu-yu Guo, Michael Ficarra, Kevin Gibbons |
| 2022 | Juni 2022 | Private Methoden und Felder in Klassen, Statische Initialisierungs-Blöcke in Klassen, await außerhalb von async-Funktionen, … | Shu-yu Guo, Michael Ficarra, Kevin Gibbons |
| 2023 | Juni 2023 | Hashbang-Grammar, Symbole für WeakMaps, neue Array-Funktionen |
Sicherheit
Sandbox-Prinzip
JavaScript wird im Browser in einer sogenannten Sandbox ausgeführt. Dies soll bewirken, dass man in JavaScript nur Zugriff auf die Objekte des Browsers hat und nicht auf das Dateisystem zugreifen kann. Eine Ausnahme stellt der Lesezugriff auf eine Datei dar, die per Dateiauswahl-Dialog, gestartet mit dem HTML-Element <input type="file">, vom Benutzer ausgewählt wurde.
Um Sicherheitsprobleme wie das sogenannte Cross-Site-Scripting zu verhindern, wird jede Website oder Webanwendung innerhalb des Browsers isoliert ausgeführt und ein Datenaustausch unterbunden. Ohne diesen Schutz wäre es möglich, über eine Seite Schadcode auszuführen, der beispielsweise Bank- oder Logindaten in anderen parallel geöffneten Browserfenstern ausliest oder manipuliert.
Auch bestimmte sicherheitsrelevante Browserfunktionen wie das Schließen des Browserfensters, das Aus- und Einblenden von Symbolleisten, das Ändern der Browserstartseite, der Zugriff auf die Zwischenablage oder das Auslesen der zuletzt besuchten Webseiten des Anwenders werden durch obligatorische Nutzereingaben geschützt.
Standardmäßig wird ein Skript innerhalb eines Browsers in Form eines einzigen Threads ausgeführt. Warteschleifen oder lange Berechnungen sind daher in JavaScript-Programmen zu vermeiden. Mit Worker-Objekten ist es möglich, weitere Threads zu erzeugen.
Deaktivieren von JavaScript
In vielen JavaScript-fähigen Browsern lässt sich JavaScript abschalten oder lassen sich einzelne Aktionen wie die Änderung des Textes in der Statusleiste oder die Manipulation von Browserfenstern deaktivieren. Dies kann bei einigen Browsern mittels Erweiterungen, die JavaScript anhand von White- und Blacklists gezielt auf Seiten ein- und ausschalten, auch automatisiert werden. Daher können sich Entwickler nicht darauf verlassen, dass JavaScript-Programme sich in jeder Umgebung gleich verhalten bzw. überhaupt funktionieren.
Sprachelemente
Datentypen
JavaScript ist dynamisch typisiert. Das bedeutet, dass die Zuweisung von Werten an Variablen keinen typbasierten Einschränkungen unterliegt. Allerdings gibt es diverse Erweiterungen von JavaScript, die eine statische Typisierung optional beziehungsweise zwingend erfordern, zum Beispiel TypeScript von Microsoft.
Aufgrund der dynamischen Typisierung ist der Datentyp keine Eigenschaft einer Variablen, sondern Laufzeit-bezogen die Eigenschaft ihres aktuellen Wertes (oder auch die Eigenschaft eines Literals). Der Datentyp eines Wertes lässt sich mit dem unären Operator typeof ermitteln.
Primitive Datentypen
Zu den primitiven Datentypen gehören Werte für Zahlen, Zeichenketten, boolesche Werte und Symbole. Zeichenketten haben den Typ String (typeof liefert "string"), numerische Werte den Typ Number (typeof liefert "number"), boolesche Werte den Typ Boolean (typeof liefert "boolean"). Ein weiterer, allerdings seltener gebrauchter primitiver Datentyp ist Symbol, der als Identifier (siehe auch Stichwort Symbol) fungiert (typeof liefert "symbol").
Ein Sonderfall ist der Typ Undefined mit undefined als einzigem Wert (typeof liefert "undefined").
Nicht primitive Datentypen
Funktionen sind kein primitiver Typ; typeof liefert "function". Für alle anderen Werte – reguläre Ausdrücke, Arrays und den Wert null inbegriffen – liefert typeof den Zeichenketten-Wert "object" zurück. Im Gegensatz zu anderen Programmiersprachen gibt es in JavaScript keine echten assoziativen Arrays.
Mit den vordefinierten Konstruktorfunktionen String(), Number() und Boolean() erzeugte Objekte verhalten sich wie Werte der entsprechenden Datentypen – der typeof-Operator gibt jedoch "object" zurück. Solche Objekte werden als Wrapper-Objekte bezeichnet. Zum Datentyp Symbol existiert keine gleichnamige Konstruktorfunktion. Nachfolgend ein Beispiel für eine Variable und das entsprechende Wrapper-Objekt:
let variable = "Beispieltext"; // Die Funktion "alert" gibt das Ergebnis "string" in einem Fenster aus. alert(typeof variable); variable = new String("Beispieltext"); alert(typeof variable); // ergibt "object" Umgekehrt werden Werte der primitiven Typen Number, Boolean und String bei Bedarf automatisch in Objekte der entsprechenden Konstruktorfunktion umgewandelt:
let variable = "Beispieltext"; alert(variable.length); // ergibt 12 Kontrollstrukturen
JavaScript kennt die üblichen Kontrollstrukturen. Sollen diese mehr als eine Anweisung enthalten, so muss ein in geschweifte Klammern eingeschlossener Block eingesetzt werden. Anweisungen werden mit einem Semikolon abgeschlossen. Dies ist aber in den meisten Fällen optional; durch die automatic semicolon insertion wird es meist automatisch ergänzt.
if-else (Bedingte Anweisung)
if (bedingung) { anweisungen; } else { anweisungen; } Kurzschreibweise für bedingte Wertzuweisungen:
variable = bedingung ? wertWennWahr : wertWennFalsch; switch-Kontrollstruktur
switch (variable) { case wert1: anweisungen; break; case wert2: anweisungen; break; default: anweisungen; } while-Schleife
while (bedingung) { anweisungen; } do-while-Schleife
do { anweisungen; } while (bedingung); for-Schleife
for (startausdruck; bedingung; iterationsausdruck) { anweisungen; } for … in-Schleife
Mit dieser Anweisung werden alle eigenen und ererbten Eigenschaften eines Objektes durchlaufen, die das interne Attribut Enumerable aufweisen. Dieses Attribut wurde in ECMA Script 5 eingeführt und ist für bestimmte eingebaute Eigenschaften (wie z. B. die Funktion toString des Prototyps Object) nicht gesetzt, es kann allerdings im Regelfall vom Benutzer gesetzt (und entfernt) werden. Bei jedem Schleifendurchgang wird einer angegebenen Variable der Eigenschaftsname zugewiesen.
for (let eigenschaftsname in objekt) { anweisungen; } for … of-Schleife
Diese Kontrollstruktur funktioniert wie eine for … in-Schleife, mit dem Unterschied, dass hier der angegebenen Variable nicht der Eigenschaftsname, sondern der Eigenschaftswert zugewiesen wird.
for (let wert of objekt) { anweisungen; } Variablen
Variablen sollten in JavaScript mit let oder var deklariert werden und sind dann innerhalb des Scopes gültig, in dem sie deklariert wurden, wobei let den Scope weiter eingrenzt als var. Verwendet man Variablen ohne sie vorher explizit zu deklarieren, werden diese implizit als Eigenschaften des globalen Objekts (im Browser window) deklariert; dieses Verhalten kann man durch die Anweisung "use strict"; unterbinden. Eine Besonderheit von JavaScript ist das Hoisting von Variablen, das dafür sorgt, dass sämtliche in einem Codeabschnitt deklarierten Variablen und Funktionen bei der Abarbeitung automatisch direkt an den Anfang vorgezogen werden (nur die Deklaration, nicht aber deren Wertzuweisung).
Geltungsbereich von Variablen
Innerhalb von Funktionen oder als Funktionsparameter deklarierte Variablen haben eine lokale Gültigkeit; außerhalb von Funktionen deklarierte Variablen sind global gültig. Global bedeutet bei JavaScript in Browsern, dass derart deklarierte Variablen auf der ganzen Webseite und bei allen aktiven JavaScripts gültig sind. Da dies zu ungewollten Nebeneffekten mit anderen in der Seite eingebunden Scripts (wie Drittanbieter-Plugins, Web Analytics oder Werbebannern) führen kann, sollten globale Variablen so weit wie möglich vermieden werden.
let a, b; // explizite Deklaration einer globalen Variable a = 1; // Definition einer Variable console.log(a); // ergibt 1 c = 2; // implizite Deklaration ohne let - es entsteht keine Variable, sondern ... console.log(c); // ergibt 2 console.log(window.c); // ... dem globalen Objekt (Window) wurde eine Eigenschaft zugewiesen console.log(window.a); // Fehler function foo(e) { // saubere Deklaration eines Funktionsparameters let f, g = 5; // saubere Deklaration und Definition einer lokalen Variablen console.log(a); // globale Variablen sind überall gültig console.log(c); // Eigenschaften des globalen Objektes auch console.log(e); // Funktionsparameter haben denselben Gültigkeitsbereich wie lokale Variablen h = 7; // das implizit deklarierte h ist eine globale Variable } foo(a); console.log(e); // Fehler, da der Funktionsparameter e nur innerhalb der Funktion gültig ist console.log(f); // Fehler, da die Variable f nur innerhalb der Funktion gültig ist console.log(h); // ergibt 7 - (s.o.) console.log(window.h); // ergibt 7 - die globale Variable ist eine Eigenschaft von window Konstanten
Konstanten sollen mit const deklariert werden, bei der Initialisierung muss ihnen ein Wert zugewiesen werden. Für den Gültigkeitsbereich gelten dieselben Bedingungen wie bei Variablendeklarationen mit let. Konstanten können nicht durch erneute Zuweisung verändert werden, allerdings können – wenn es sich bei der Konstanten um Objekte handelt – einzelne Eigenschaften der Konstanten geändert werden.
Funktionen
Funktionen sind in JavaScript vollwertige Objekte. Sie haben Methoden und Eigenschaften, können erstellt und überschrieben, als Argumente an Funktionen übergeben und von ihnen erzeugt und zurückgegeben werden.
Im letzteren Fall entsteht eine Closure, auch Funktionsabschluss genannt, mit der beispielsweise Datenkapselung umgesetzt werden kann:
let nachricht = function() { let geheim = 42; return function() { return geheim; }; }; // botschaft ist eine von nachricht zurückgegebene Funktion let botschaft = nachricht(); alert(typeof geheim); // undefined alert(botschaft()); // 42 Nicht jedes Argument einer Funktion muss beim Aufruf angegeben werden. Für fehlende Argumente wird der Wert undefined gesetzt; seit ECMAScript 2015 können Parameter auch mit default-Wert definiert werden. Außerdem kann innerhalb der Funktion auch über das arguments-Objekt auf die Argumente zugegriffen werden.
Erzeugung
Es gibt mehrere Möglichkeiten, in JavaScript Funktionen zu erzeugen:
- Funktionsdeklarationen („Function Declarations“):
function f(x, y) { return x + y; } - Funktionsausdrücke („Function Expressions“):
let f = function(x, y) { return x + y; }; - Sofort ausgeführte Funktionsausdrücke („Immediately-Invoked Function Expressions“):
Anonyme Funktionen können auch direkt ausgeführt werden, ohne sie vorher einer Variable zuzuweisen. Das kann zur Kapselung des Gültigkeitsbereichs von Variablen verwendet werden.
(function(x, y) { return x + y; })(2, 3); - Benannte Funktionsausdrücke („Named Function Expressions“):
Der Variablen f wird eine Funktion mit Bezeichner g zugewiesen. Außerhalb der Funktion ist sie mit f ansprechbar, innerhalb mit f und g.
let f = function g(x, y) { return x + y; }; - Funktionskonstruktor („Function Constructors“):
let f = new Function('x', 'y', 'return x + y;'); - Pfeilfunktionen („Arrow Functions“):
Die runden Klammern sind optional, falls die Funktion genau ein Argument hat. Werden die geschweiften Klammern weggelassen, muss man genau einen Ausdruck ohne return als Rückgabewert angeben. Mit geschweiften Klammern kann man beliebigen Code angeben, muss aber für Rückgabewerte return verwenden.
(x, y) => x + y; (x, y) => { return x + y; }; x => x + 1; x => { return x + 1; }; // Eine so erzeugte Funktion kann man natürlich auch einer Variablen zuweisen let f = (x, y) => x + y; Beispiel
Eine funktionale und rekursive Implementierung des Euklidischen Algorithmus mit zwei Argumenten sieht folgendermaßen aus:
function euklid(a, b) { if (b === 0) return a; return euklid(b, a % b); } Implementierung des Euklidischen Algorithmus mit beliebig vielen Argumenten:
function ggT(...numbers) { if (numbers.length === 0) // (1.) return 0; if (numbers.length === 1) // (2.) return numbers[0]; return numbers.reduce(euklid); // (3.) } console.log(ggT()); // 0 console.log(ggT(4)); // 4 console.log(ggT(24, 36, 84)); // 12 - Falls
ggTohne Argument aufgerufen wird, dann wird Null zurückgegeben. - Falls
ggTmit genau einem Argument aufgerufen wird, dann wird das Argument selbst zurückgegeben. Dies wird auch als Identität bezeichnet. - Reduziert
numbersauf einen einzigen Wert, indem jeweils zwei Elemente von links nach rechts mitreduceundeuklidreduziert werden.
Implementierung des Euklidischen Algorithmus mit partieller Anwendung:
function ggT(first) { if (first === undefined) return 0; return function(second) { if (second === undefined) return first; return ggT(euklid(first, second)); }; } console.log(ggT()); // 0 console.log(ggT(4)()); // 4 console.log(ggT(24)(36)(84)()); // 12 Objekte
Objekte in JavaScript bestehen aus Eigenschaften, die als Name/Wert-Paar realisiert werden. Dabei wird nicht zwischen Attributen und Methoden des Objektes unterschieden (eine Eigenschaft, deren Wert den Typ Function besitzt, fungiert als Methode). Jedes Objekt – auch durch Literale erzeugte Objekte – erbt vom Prototyp des globalen Objekt-Konstruktors.
Vordefinierte Objekte
JavaScript kennt mehrere eingebaute Objekte und Objekttypen, die im Standard ECMAScript definiert sind. Dabei wird ein Objekttyp durch eine namensgleiche Konstruktorfunktionen repräsentiert, die zur Erzeugung von Objekten des entsprechenden Typs verwendet werden kann und zugleich einen Verweis auf den Prototyp des Objekttyps beinhaltet.
- Das namenlose globale Objekt, das alle Variablen und Objekte enthält.
- Der Objekttyp
Object, von dem alle Objekte abgeleitet sind. - Der Objekttyp
Functionvon Funktionen. - Der Objekttyp
Arrayvon Arrays. - Der Objekttyp
Stringvon Zeichenketten. - Der Objekttyp
Booleanvon boolesche Variablen. - Der Objekttyp
Numbervon Zahlen (64-Bit-Gleitkommazahlen gemäß IEEE 754). - Der Objekttyp
Datefür Datumsformate (Daten bzw. Zeitpunkte). - Der Objekttyp
RegExpfür reguläre Ausdrücke. - Der Objekttyp
Errorzur Charakterisierung (und ggf. nachfolgenden Auslösung mittelsthrow) von Laufzeitfehlern. - Das Objekt
Mathstellt Konstanten und Methoden für mathematische Operationen bereit. - Das Objekt
JSONstellt zwei Methoden für die Serialisierung von Objekten ins JSON-Format und umgekehrt bereit. - Das Objekt
Reflectstellt Methoden für die Ermittlung und Änderung der Metadaten eines Objekts bereit.
Weitere Objekte, die beim clientseitigen JavaScript verwendet werden, entstanden historisch vor allem durch die Netscape-Spezifikationen (window, document usw.). Das window-Objekt selbst ist dabei de facto das globale Objekt, indem einfach einer Variablen window das globale Objekt zugewiesen wurde. Zahlreiche Unterobjekte von document wurden mittlerweile durch DOM HTML standardisiert (title, images, links, forms usw.). Aktuelle Browser unterstützen zudem DOM Core und andere W3C-DOM-Standards sowie Erweiterungen von Microsoft JScript.
Zugriff auf Objekteigenschaften und -methoden
Eigenschaften von Objekten (auch Methoden sind Eigenschaften) können wie folgt angesprochen werden:
objekt.eigenschaft; objekt.methode(parameter1, parameter2); objekt["eigenschaft"]; objekt["methode"](parameter1, parameter2); // Eigenschaftsname, der in Punktnotation illegal wäre objekt["methode 1"](); // So können auch alle Eigenschaften des Objekts durchlaufen werden for (let eigenschaftsName in objekt) { console.log(eigenschaftsName, " = ", objekt[eigenschaftsName]); } Zu allen Objekten können zur Laufzeit neue Eigenschaften hinzugefügt oder mit delete bestehende entfernt werden:
// Statisch bzw. dynamisch benannte Eigenschaften hinzufügen: objekt.eigenschaftA = "ein Wert"; objekt["eigenschaftB"] = "ein anderer Wert"; // Statisch bzw. dynamisch benannte Eigenschaften entfernen: delete objekt.eigenschaftA; delete objekt["eigenschaftB"]; Objektliterale
Objekte können in JavaScript direkt anhand ihrer Eigenschaften definiert werden:
let meinObjekt = { zahl: 42, gibZahl: function() { return this.zahl; } }; alert(meinObjekt.gibZahl()); // 42 Eine spezielle Notation gibt es für reguläre Ausdrücke:
// mit Konstruktorfunktion (new RegExp("a")).test("ab"); // true // als Literal /a/.test("ab"); // true Konstruktor-Funktionen
Eine Funktion kann dazu genutzt werden, um ein mit new erstelltes Objekt zu initialisieren. In diesem Fall spricht man von einem Konstruktor oder einer Konstruktor-Funktion. Innerhalb dieser Funktion kann das neue Objekt über die Variable this angesprochen werden.
function MeinObjekt(x) { // Konstruktor this.zahl = x; } let objekt = new MeinObjekt(3); // Instanz erzeugen alert(objekt.zahl); // per Meldefenster ausgeben (3) „Private“ Eigenschaften
Private Eigenschaften und Methoden sind nicht explizit Teil der Sprache.
Mit Hilfe von Closures (siehe Funktionen) lassen sich dennoch private Eigenschaften von Objekten realisieren:
let erschaffeKatze = function() { let lebensZahl = 7; let maunz = function() { return (lebensZahl > 0) ? "miau" : "örks"; }; // gibt neues Objekt zurück return { toeten: function() { lebensZahl -= 1; alert(maunz()); } }; }; let otto = erschaffeKatze(); otto.toeten(); // miau Lediglich die toeten-Methode von otto kennt die Variable lebensZahl. Der Effekt gleicht dem einer privaten Eigenschaft, wenn alle Methoden der Katze in der erzeugenden Funktion erschaffeKatze definiert werden. lebensZahl ist dann für alle Methoden (privilegierte Methoden, im Beispiel toeten) und inneren Funktionen der erzeugenden Funktion (private Methoden, im Beispiel maunz) sichtbar, nicht jedoch von außen oder von nachträglich an das Objekt gehängten Methoden.
Vererbung über Prototypen
Vererbung kann in JavaScript durch Prototypen realisiert werden. Dies erfordert, dass der prototype-Eigenschaft einer Konstruktor-Funktion ein als Prototyp dienendes Objekt zugewiesen wird. Wenn mit der Konstruktor-Funktion nun ein Objekt erzeugt wird, wird beim Zugriff auf eine nicht-existierende Eigenschaft des neuen Objekts die entsprechende Eigenschaft des Prototyps (wenn vorhanden) zurückgegeben. Beispiel:
let fisch = { augen: 2 }; let Mutantenfisch = function() { this.augen = 3; }; Mutantenfisch.prototype = fisch; let blinky = new Mutantenfisch(); // eigene Eigenschaft von blinky alert(blinky.augen); // 3 // blinkys eigene Eigenschaft wird gelöscht delete blinky.augen; // blinky hat die Eigenschaft selbst nicht mehr, // es schimmert die Eigenschaft des Prototyps durch alert(blinky.augen); // 2 Um festzustellen, ob ein Objekt eine Eigenschaft selbst besitzt oder vom Prototyp geerbt hat, hat jedes Objekt (automatisch durch Vererbung von Object) die hasOwnProperty-Methode:
blinky.hasOwnProperty('augen'); // false Fixierung von Objektstruktur und -inhalten
Die in JavaScript im Regelfall völlig dynamische Struktur eines Objekts obj kann in verschiedener Hinsicht fixiert werden: Nach dem Methodenaufruf Object.preventExtensions(obj) können keine weiteren Attribute und Methoden mehr ergänzt werden. Object.seal(obj) verhindert sowohl die Erweiterung wie die Streichung von Attributen und Methoden. Der Aufruf Object.freeze(obj) fixiert sowohl die Objektstruktur wie auch die Attributwerte inklusive der Methoden gegen nachfolgende Veränderungen. Die betreffenden Status eines Objekts obj können mit Object.isExtensible(obj), Object.isSealed(obj) und Object.isFrozen(obj) ermittelt werden.
Es ist auch möglich, nur ein einzelnes Attribut eines Objekts obj zu fixieren. Beispielsweise wird mit dem Aufruf
Object.defineProperty(obj, "vorname", {writable:false});
das Attribut obj.vorname schreibgeschützt.
Delegationsprinzipien
JavaScript ist eine Delegationssprache mit sowohl selbstausführendem als auch direktem Delegationsmechanismus.
Fehlerbehandlung
Ab Version 3 verfügt ECMAScript über eine von Java übernommene Fehlerbehandlung. Die Anweisung try … catch … finally fängt Ausnahmen (exceptions) ab, die aufgrund eines Fehlers oder einer throw-Anweisung auftreten. Die Syntax lautet:
try { // Anweisungen, in denen Ausnahmen auftreten oder ausgelöst werden können } catch (exception) { // Anweisungsfolge, die im Ausnahmefall ausgeführt wird. // In diesem Teil kann die Fehlerbehandlung erfolgen. } finally { // Anweisungsfolge, die anschließend in jedem Fall ausgeführt wird. } throw "sample exception"; // wenn verfügbar, besser: Error-Objekt (siehe unten) Zu Beginn werden die Anweisungen im try-Block ausgeführt. Falls eine Ausnahme auftritt, wird der Kontrollfluss sofort zum catch-Block mit dem Ausnahmeobjekt als Parameter umgeleitet.
Im Normalfall wird der Ausnahmeblock übersprungen. Nach der Ausführung des try-Blocks (auch teilweise) und gegebenenfalls des catch-Blocks werden in jedem Fall die Anweisungen im finally-Block ausgeführt. Der finally-Teil kann weggelassen werden, alternativ der catch-Teil.
Einige Laufzeitumgebungen wie V8 (und somit Node.js) und auch viele Webbrowser stellen gesonderte Error-Objekte zur Verfügung, die neben der Fehlermeldung auch einen Stacktrace und weitere Zusatzinformationen transportieren können. Um diese Vorteile zu nutzen, ändert man im einfachsten Anwendungsfall den throw-Befehl von throw "Meldungstext"; zu throw new Error("Meldungstext");.
Klammern um den Parameter des throw-Befehls sind im Allgemeinen nicht notwendig. Sollten sie in Ausnahmefällen benötigt werden, um beispielsweise einen auf mehrere Zeilen verteilten Parameter zusammenzufassen, kann die mögliche Verwechslung mit einem Funktionsaufruf dennoch vermieden werden, indem man ein Leerzeichen zwischen throw und die öffnende Klammer einfügt.
JavaScript-Bibliotheken
Um die Erstellung von Webanwendungen mit Hilfe von JavaScript zu erleichtern, gibt es diverse Bibliotheken und Frameworks. Eine Bibliothek ist eine Sammlung von Funktionen, die der Programmierer nutzen kann. Ein Framework fordert darüber hinaus durch ein besonderes Maß an Abstraktion eine bestimmte Struktur der Programmierung.
Ausgelöst von neuen Konzepten wie Ajax entstand seit 2004 ein neues Interesse für JavaScript. JavaScript wird zunehmend für Rich-Client-Anwendungen benutzt, die das Aussehen und die Bedienung von herkömmlichen Desktop-Programmen auf Web-gestützte Anwendungen übertragen. JavaScript spielt dabei eine Schlüsselrolle, wenn es darum geht, Statusinformationen ohne Laden einer vollständigen Seite zwischen Browser und HTTP-Server zu übertragen. Im Zuge dieser neuen Anforderungen entstanden verschiedene Bibliotheken, die die Entwicklung solcher Anwendungen vereinfachen wollen. Neben Ajax-Funktionalitäten bieten die meisten dieser Bibliotheken eine eigene Basis für objektorientierte Programmierung, eine Abstraktionsschicht für das komfortable Arbeiten mit dem DOM sowie grafische Effekte wie Animationen. Aber auch schon vor dem breiten Einsatz von Ajax existierten Funktionssammlungen zur Unterstützung der browserübergreifenden Programmierung.
Zu den bekannten JavaScript-Bibliotheken und Frameworks zählen AngularJS, Dojo Toolkit, Ext JS, jQuery, MooTools, Prototype, Qooxdoo, React, Vue.js und die Yahoo User Interface Library. Speziell mit grafischen Effekten beschäftigen sich Moo.fx und Script.aculo.us. Für die serverseitige Programmierung mittels Node.js stehen eigene Bibliotheken und Frameworks bereit.
Einige Bibliotheken und insbesondere Frameworks erweitern die Sprache um zusätzliche Funktionen, die häufig in spätere Versionen der Spezifikation einfließen oder rüsten bei Bedarf ältere Implementierung per Polyfill nach.
JavaScript & Suchmaschinenoptimierung (SEO)
Suchmaschinen gehen unterschiedlich mit der Verarbeitung von Javascript-Inhalten um, wodurch es in den letzten Jahren immer wieder zu Fällen gekommen ist, dass Website teilweise oder gänzlich nicht in Suchmaschinen auffindbar waren. Der Suchmaschinenbetreiber Google kann laut eigenen Aussagen JavaScript-Inhalte crawlen, rendern und indexieren. Neben allgemeinen Empfehlungen wie z. B. die Verwendung von aussagekräftigen Titeln, eindeutigen Statuscodes und den sorgsamen Umgang mit Noindex-Direktiven gibt es im Hinblick auf JavaScript noch spezifischere Empfehlungen, welche helfen können, dass JavaScript-Webanwendungen optimal via Suchmaschinenoptimierung aufgefunden werden können. Dazu zählen serverseitiges Pre-Rendering oder der Verzicht von Fragmenten bei Links. Für das Debugging von JavaScript & SEO gibt es eine Reihe von offiziellen Empfehlungen seitens Google, um nachprüfen zu können, wie der Googlebot Webinhalte erfasst.
Siehe auch
- ActionScript – Bezeichnung für eine JavaScript-ähnliche Skriptsprache in Flash und Macromedia Director, wo es alternativ zu Lingo verwendet werden kann
- Aktive Inhalte
- Bookmarklet – kleine JavaScript-Programme im Browser
- Dart (Programmiersprache)
- TypeScript – Weiterentwicklung von Microsoft
Literatur
- David Flanagan: JavaScript – Das Handbuch für die Praxis. 7. Auflage. O’Reilly, Heidelberg 2021, ISBN 978-3-96009-157-8.
- Paul Fuchs: JavaScript Programmieren für Einsteiger: Der leichte Weg zum JavaScript-Experten. BMU Verlag, Landshut 2019, ISBN 978-3-96645-016-4
- Jörg Bewersdorff: Objektorientierte Programmierung mit JavaScript: Direktstart für Einsteiger. 2. Auflage. Wiesbaden 2018, ISBN 978-3-658-21076-2, doi:10.1007/978-3-658-21077-9.
- Philip Ackermann: JavaScript. Das umfassende Handbuch. 1. Auflage. Galileo Press, Bonn 2016, ISBN 978-3-8362-3838-0.
- Nicholas Zakas: JavaScript objektorientiert: Verständlicher, flexibler, effizienter programmieren. Heidelberg 2014, ISBN 978-3-86490-202-4.
- Peter Kröner: ECMAScript 5 – Entwickeln mit dem aktuellen JavaScript-Standard. 1. Auflage. Open Source Press, München 2013, ISBN 978-3-95539-063-1.
- Christian Wenz: JavaScript und AJAX. Das umfassende Handbuch. 9. Auflage. Galileo Press, Bonn 2009, ISBN 978-3-89842-859-0 (openbook.galileocomputing.de).
- Stefan Koch: JavaScript. Einführung, Programmierung, Referenz – inklusive Ajax. 5. Auflage. dpunkt-Verlag, Heidelberg 2009, ISBN 978-3-89864-594-2.
- Douglas Crockford: Das Beste an JavaScript. O’Reilly, Köln 2008, ISBN 978-3-89721-876-5.
Weblinks
- Linkkatalog zum Thema JavaScript bei curlie.org (ehemals DMOZ)
- JavaScript – Geschichte, Struktur, Eigenschaften und die Zukunft der wichtigsten Programmiersprache des Webs. (MP3 97,5 MB) In: Chaosradio Express CRE146. 27. Februar 2010, abgerufen am 27. Februar 2010.
- Addy Osmani: Learning JavaScript Design Patterns. Abgerufen am 24. Mai 2013 (englisch, Entwurfsmuster in JavaScript).
- Lizenz
Spezifikationen
- ISO-genormte ECMAScript-Spezifikation (ISO/IEC 16262:2002) (englisch/französisch)
- ECMAScript-Spezifikation (englisch, PDF; 3,1 MiB) (HTML-Version)
- Referenz von Mozilla (deutsch)
- Übersicht über die Neuerungen in JavaScript (englisch)
Dokumentationen
- JavaScript-Kapitel bei SELFHTML-Wiki
- Objektorientierung in JavaScript
- Eloquent JavaScript (Frei verfügbares E-Book, englisch)
Einzelnachweise
- ECMAScript® 2023 Language Specification. In: www.ecma-international.org. Ecma International, Juni 2023, abgerufen am 27. Juli 2023 (englisch).
- Stefan Koch: JavaScript. Einführung, Programmierung und Referenz – inklusive Ajax. 5. Auflage. dpunkt.verlag, Heidelberg 2009, ISBN 978-3-89864-594-2, Überblick, S. 5–17 (457 S.).
- ↑ Olaf Göllner: JavaScript für Mikrocontroller. In: heise online. Verlag Heinz Heise, 13. August 2013, abgerufen am 27. Juli 2016.
- ↑ Olaf Göllner: Tessel: JavaScript-Entwicklerboard fürs „Internet der Dinge“. In: heise online. Verlag Heinz Heise, 15. August 2013, abgerufen am 27. Juli 2016.
- Stefan Koch: JavaScript. Einführung, Programmierung und Referenz – inklusive Ajax. 5. Auflage. dpunkt.verlag, Heidelberg 2009, ISBN 978-3-89864-594-2, JavaScript im Browser, S. 137–156 (457 S.).
- Jens Ihlenfeld: Node – strikt ereignisorientierter Javascript-Server. In: Golem.de. 24. November 2009, abgerufen am 27. Juli 2016.
- Steve Champeon: (Nicht mehr online verfügbar.) In: Web DevCenter. O’Reilly, 6. April 2001, archiviert vom am 19. Juli 2016; abgerufen am 27. Juli 2016 (englisch).
- Chris Mills: A Short History of JavaScript. In: Web Education Community Group Wiki. W3C, 27. Juli 2012, abgerufen am 27. Juli 2016 (englisch).
- Auskunft zur Marke JAVASCRIPT im Register des Deutschen Patent- und Markenamtes (DPMA)
- Ingo Pakalski: 15 Jahre WWW: Die Browserkriege. Der erste Browserkrieg zwingt Netscape in die Knie. In: Golem.de. 1. Mai 2008, abgerufen am 27. Juli 2016.
- Klaus-Peter Kerbusk: Mißbrauch des Monopols. In: Der Spiegel. Nr. 44, 1997 (online).
- Scripting for the Java Platform. In: Java SE Documentation. Oracle, abgerufen am 24. Oktober 2012 (englisch).
- Florian Scholz, Eric Shepherd: In: Mozilla Developer Network. Mozilla Foundation, 20. Januar 2016, archiviert vom am 28. Juli 2016; abgerufen am 27. Juli 2016 (englisch).
- Florian Scholz, Eric Shepherd: New in JavaScript 1.4. In: Mozilla Developer Network. Mozilla Foundation, 20. Januar 2016, abgerufen am 27. Juli 2016 (englisch).
- (Nicht mehr online verfügbar.) In: DevEdge Online Documentation. Netscape Communications Corporation, 29. Oktober 1998, archiviert vom am 2. August 2004; abgerufen am 27. Juli 2016 (englisch).
- Florian Scholz, Eric Shepherd: New in JavaScript 1.5. In: Mozilla Developer Network. Mozilla Foundation, abgerufen am 20. Januar 2016 (englisch).
- Wladimir Palant, SylvainPasche, Nickolay Ponomarev, Florian Scholz, Eric Shepherd: New in JavaScript 1.6. In: Mozilla Developer Network. Mozilla Foundation, 4. April 2016, abgerufen am 27. Juli 2016 (englisch).
- Florian Scholz, James Herdman, Eric Shepherd, Robert Sedovšek, David Bruant, Leo Balter, Jonathan Watt, Eli Grey, Nickolay Ponomarev, Martin Honnen, Evan Prodromou: New in JavaScript 1.7. In: Mozilla Developer Network. Mozilla Foundation, 21. Oktober 2015, abgerufen am 27. Juli 2016 (englisch).
- Florian Scholz, Eli Grey, Leandro Mercês Xavier, Nickolay Ponomarev: New in JavaScript 1.8. In: Mozilla Developer Network. Mozilla Foundation, 20. Januar 2016, abgerufen am 27. Juli 2016 (englisch).
- John Resig: Versions of JavaScript. In: johnresig.com/. 22. April 2008, abgerufen am 8. Juni 2020 (englisch).
- ECMAScript 2022 Language Specification. Juni 2022, abgerufen am 22. Juli 2022 (englisch).
- Julia Schmidt: Standard für ECMAScript soll jährlich Updates erhalten. In: heise Developer. 23. Januar 2015, abgerufen am 22. Oktober 2015.
- tc39/ecma262. In: GitHub. Abgerufen am 2. Januar 2017.
- Changes to JavaScript, Part 1: EcmaScript 5
- ECMAScript 2015 Language Specification. Abgerufen am 2. Januar 2017 (englisch).
- ECMAScript 2016 Language Specification. 7. Auflage. Emca International, Genf (englisch, 586 S., ecma-international.org [PDF]). (Memento vom 12. April 2015 im Internet Archive)
- ECMAScript 6 compatibility table. In: kangax.github.io. Abgerufen am 2. Januar 2017 (englisch).
- Nicholas C. Zakas: Professional JavaScript for Web Developers. John Wiley & Sons., 2011, ISBN 978-1-118-02669-4 (englisch, 960 S.).
- ECMAScript 2017 Language Specification. Juni 2017, abgerufen am 5. Dezember 2017 (englisch).
- JavaScript-Standard ECMAScript 2016 offiziell verabschiedet. In: heise online. heise Developer, 17. Juni 2016, abgerufen am 3. Januar 2017.
- ↑ ECMAScript Next compatibility table. In: kangax.github.io. Abgerufen am 2. Januar 2017.
- ECMAScript 2017 Language Specification. Ecma International, Juni 2017, abgerufen am 4. August 2017 (englisch).
- Christian Liebel: Evolution im Web: ECMAScript 2017. heise Developer, 1. August 2017, abgerufen am 4. August 2017.
- ECMAScript 2017. In: Exploring ES2016 and ES2017. 22. März 2017, abgerufen am 4. August 2017 (englisch).
- JavaScript-Standard ECMAScript 2018 offiziell verabschiedet heise.de, am 28. Juni 2018
- Tracking ECMAScript Proposals. In: TC39. Ecma, abgerufen am 4. August 2017 (englisch).
- ECMAScript 2019: Neun Neuerungen für den JavaScript-Sprachstandard. In: heise online. heise online, 4. Februar 2019, abgerufen am 17. April 2020.
- JavaScript: Die Features für ECMAScript 2020 stehen fest. In: heise online. heise online, 6. April 2020, abgerufen am 19. Juni 2020.
- JavaScript 2021: Schwache Referenzen, beliebige Versprechen und neue Zuweisungen. In: heise online. heise online, 24. Juli 2020, abgerufen am 27. September 2021.
- ECMAScript® 2022 Language Specification
- Proposals included in the incoming ECMAScript 2022 standard for JavaScript. In: geek culture. geek culture, 2. September 2021, abgerufen am 27. September 2021.
- W3C Working Draft 24 September 2015. In: w3.org. Abgerufen am 28. Juli 2016.
- Ilja Zaglov: TypeScript: Microsoft’s neue JavaScript Erweiterung. In: t3n Magazin. 10. Oktober 2012, abgerufen am 10. Oktober 2012.
- JavaScript/Objekte/Array. In: SELFHTML. 15. Juli 2016, abgerufen am 27. Juli 2016.
- for…in MDN
- Object.defineProperty() MDN
- for…of MDN
- JavaScript/Variable/let im SELFHTML-Wiki
- JavaScript/Variable/const im SELFHTML-Wiki
- Juriy Kangax Zaytsev: Named function expressions demystified. In: kangax.github.io. 17. Juni 2009, abgerufen am 28. Juli 2016 (englisch).
- ↑ ECMAScript Language Specification – ECMA-262 Edition 5.1. In: ecma-international.org. Abgerufen am 28. Juli 2016. (ecma-international.org (PDF) PDF).
- Englische Wikipedia: Role-oriented programming
- Traits for Javascript, 2010.
- CocktailJS – Annotations. Traits. Talents. April 2013.
- Angus Croll, A fresh look at JavaScript Mixins vom 31. Mai 2011.
- Die vielen Talente von JavaScript Rollen-orientierte Programmieransätze wie Traits und Mixins verallgemeinern zu können. peterseliger.blogspot.de; 5. Juni 2014.
- JavaScript Stack Trace API in Google V8 Wiki, Stand 28. Juni 2010, abgerufen am 23. Februar 2013
- (Memento vom 4. November 2014 im Internet Archive) in Aptana HTML Reference, Stand 2. Juli 2012, abgerufen am 23. Februar 2013
- Tom DuPont: Report Unhandled Errors from JavaScript. 13. April 2013, abgerufen am 16. April 2013 (englisch, Fehlerprotokollierung mit Stacktrace in JavaScript).
- Nico Reed: (Memento vom 31. März 2013 im Internet Archive) In: Nodejitsu Documentation, Stand 26. August 2011, abgerufen am 23. Februar 2013.
- Stefan Koch: JavaScript. Einführung, Programmierung und Referenz – inklusive Ajax. 5. Auflage. dpunkt.verlag, Heidelberg 2009, ISBN 978-3-89864-594-2, Ajax, S. 333–355 (457 S.).
- Grundlagen von JavaScript-SEO | Google Search Central. Abgerufen am 7. Dezember 2020.
- Web developer tools for debugging JavaScript issues in Google Search. Abgerufen am 7. Dezember 2020 (englisch).