„JavaScript“ – Bearbeiten

{{Infobox Programmiersprache
| Logo                         = <syntaxhighlight lang="javascript" style="display:inline-block; text-align:left;">
// Beispiel JavaScript
function halloWelt() {
	alert('Hello World');
}
window.addEventListener('load', halloWelt);
</syntaxhighlight>
| Beschreibung                 = Beispiel JavaScriptcode
| Paradigma                    = multiparadigmatisch
| Erscheinungsjahr             = 1995
| Designer                     = 
| Entwickler                   = [[Brendan Eich]]
| AktuelleVersion              = ECMAScript 2023<ref>{{cite web |url=https://www.ecma-international.org/publications-and-standards/standards/ecma-262/ |title=ECMAScript® 2023 Language Specification|publisher=Ecma International|date=2023-06 |website=www.ecma-international.org |access-date=2023-07-27| language=en}}</ref>
| AktuelleVersionFreigabeDatum = Juni 2023
| AktuelleVorabVersion         = 
| AktuelleVorabVersionFreigabeDatum = 
| Typisierung                  = [[Schwache Typisierung|schwach]], [[Dynamische Typisierung|dynamisch]], [[Duck-Typing|duck]]
| Implementierung              = [[SpiderMonkey]], [[Rhino (Programmierung)|Rhino]], [[WebKit#JavaScriptCore|JavaScriptCore]], [[V8 (JavaScript-Engine)|V8]]
| Dialekte                     = 
| Standardisierungen           = 
| Beeinflusst_von              = [[Self (Programmiersprache)|Self]], [[C (Programmiersprache)|C]], [[Scheme]], [[Perl (Programmiersprache)|Perl]], [[Python (Programmiersprache)|Python]], [[Java (Programmiersprache)|Java]], [[Lua]]
| Beeinflusste                 = [[ActionScript]], [[Haxe (Programmiersprache)|Haxe]], [[CoffeeScript]], [[Dart (Programmiersprache)|Dart]], [[TypeScript]]
| Betriebssystem               = 
| Lizenz                       = [[BSD-Lizenz|BSD]]
| Website                      = 
}}

'''JavaScript''' (kurz '''JS''') ist eine [[Skriptsprache]], die ursprünglich 1995 von [[Netscape Communications|Netscape]] für [[dynamisches HTML]] in [[Webbrowser]]n entwickelt wurde, um Benutzerinteraktionen auszuwerten, Inhalte zu verändern, nachzuladen oder zu generieren und so die Möglichkeiten von [[Hypertext Markup Language|HTML]] zu erweitern.<ref>{{Literatur |Autor=Stefan Koch |Titel=JavaScript |TitelErg=Einführung, Programmierung und Referenz – inklusive Ajax |Auflage=5 |Verlag=dpunkt.verlag |Ort=Heidelberg |Datum=2009 |ISBN=978-3-89864-594-2 |Kapitel=Überblick |Seiten=5–17 |Umfang=457}}</ref> Heute wird JavaScript auch außerhalb von Browsern angewendet, etwa auf Servern und in Microcontrollern.<ref name="Mikrocontroller">{{Internetquelle |autor=Olaf Göllner |url=https://www.heise.de/newsticker/meldung/JavaScript-fuer-Mikrocontroller-1934018.html |titel=JavaScript für Mikrocontroller |werk=heise online |hrsg=Verlag Heinz Heise |datum=2013-08-13 |abruf=2016-07-27}}</ref><ref name="Dinge">{{Internetquelle |autor=Olaf Göllner |url=https://www.heise.de/newsticker/meldung/Tessel-JavaScript-Entwicklerboard-fuers-Internet-der-Dinge-1936379.html |titel=Tessel: JavaScript-Entwicklerboard fürs „Internet der Dinge“ |werk=heise online |hrsg=Verlag Heinz Heise |datum=2013-08-15 |abruf=2016-07-27}}</ref>

Der heutige Name der ursprünglich '''LiveScript''' genannten Sprache entstand 1996 aus einer Kooperation von Netscape mit [[Sun Microsystems]]. Deren [[Java-Applet]]s, erstellt mit der gleichfalls 1995 veröffentlichten Programmiersprache [[Java (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 International|ECMA]] 262) standardisierte Sprachkern von JavaScript beschreibt eine [[Dynamische Typisierung|dynamisch typisierte]], [[Objektorientierte Programmierung|objektorientierte]], aber [[Klasse (Objektorientierung)|klassen]]<nowiki></nowiki>lose Skriptsprache. Sie wird allen objektorientierten [[Programmierparadigma|Programmierparadigmen]] unter anderem auf der Basis von [[Prototypenbasierte Programmierung|Prototypen]] gerecht, deren [[Deklaration (Programmierung)|Deklaration]] ab ECMAScript&nbsp;6 mit einer Syntax ermöglicht wird, wie sie ähnlich auch bei klassenbasierten Programmiersprachen üblich ist. In JavaScript lässt sich je nach Bedarf [[Objektorientierte Programmierung|objektorientiert]], [[Prozedurale Programmierung|prozedural]] oder [[Funktionale Programmierung|funktional]] programmieren.<ref>{{Literatur |Autor=Stefan Koch |Titel=JavaScript |TitelErg=Einführung, Programmierung und Referenz – inklusive Ajax |Auflage=5 |Verlag=dpunkt.verlag |Ort=Heidelberg |Datum=2009 |ISBN=978-3-89864-594-2 |Kapitel=JavaScript im Browser |Seiten=137–156 |Umfang=457}}</ref>

== Entwicklung ==
Die [[Syntax]] von JavaScript ähnelt [[C (Programmiersprache)|C]]-Abkömmlingen. Trotz der Namens- und syntaktischen Ähnlichkeit hat JavaScript nur geringe Gemeinsamkeiten mit [[Java (Programmiersprache)|Java]]. So wird in JavaScript Vererbung nicht durch [[Klasse (Objektorientierung)|Klassen]], sondern durch [[Prototypenbasierte Programmierung|Prototypen]] unterstützt.

JavaScript wurde früher hauptsächlich [[client]]seitig eingesetzt. JavaScript bzw. die ECMAScript-Implementierungen ermöglichen aber beispielsweise mit dem [[Framework]] [[Node.js]]<ref>{{Internetquelle |autor=Jens Ihlenfeld |url=https://www.golem.de/0911/71418.html |titel=Node – strikt ereignisorientierter Javascript-Server |werk=Golem.de |datum=2009-11-24 |abruf=2016-07-27}}</ref> und als [[JScript]] bzw. [[JScript .NET]] in einer [[Active Server Pages|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 (JavaScript-Engine)|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 [[Anwendungsprogramm]]e 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.<ref name="Mikrocontroller" /><ref name="Dinge" />

== 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 (Programmierung)|Ajax]])
* Vorschlagen von Suchbegriffen während der Eingabe
* [[Werbebanner]] oder Laufschriften
* Verschleierung von [[E-Mail-Adresse]]n zur Bekämpfung von [[Spam#Verschleierung der E-Mail-Adresse|Spam]]
* mehrere [[Frame (HTML)|Frames]] auf einmal wechseln oder die Seite aus dem Frameset lösen
* Schreib- und Lesezugriff auf [[Cookie]]s 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 [[Principle of Least Surprise|Prinzip der geringsten Überraschung]]. Einige Browser bieten daher Funktionen an, die derartige JavaScript-Funktionen unterdrücken.

Beispiele:
[[Datei:Js-alert-warnung.png|mini|Hinweis im Firefox-Browser bei vielen Dialogfenstern]]

* Verschleiern der Internetadresse, auf die ein gegebener [[Hyperlink|Link]] verweist
* Deaktivieren des [[Kontextmenü]]s, um zu erschweren, dass Bilder oder die gesamte Seite abgespeichert werden können
* Deaktivieren der [[Zwischenablage|Kopierfunktion]], um zu erschweren, dass Texte oder Bilder kopiert werden können
* Unaufgeforderte (Werbe-)[[Pop-up]]s oder [[Pop-under]]s 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#Browser-Profil|Anonymität im Internet]])
* Bei anfälligen Webanwendungen kann JavaScript auch von Dritten missbraucht werden, etwa per [[Cross-Site-Scripting|XSS]] (Codeeinschleusung).

== Geschichte ==
Am 18. September 1995 veröffentlichte [[Netscape Communications|Netscape]] mit der Vorversion des [[Netscape Navigator|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.&nbsp;a. Formulareingaben des Benutzers vor dem Absenden überprüfen. Am 4.&nbsp;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).<ref>{{Internetquelle |autor=Steve Champeon |url=http://archive.oreilly.com/pub/a/javascript/2001/04/06/js_history.html |titel=JavaScript: How Did We Get Here? |werk=Web DevCenter |hrsg=O’Reilly |datum=2001-04-06 |sprache=en |offline=1 |archiv-url=https://web.archive.org/web/20160719020828/http://archive.oreilly.com/pub/a/javascript/2001/04/06/js_history.html |archiv-datum=2016-07-19 |abruf=2016-07-27}}</ref><ref>{{Internetquelle |autor=Chris Mills |url=https://www.w3.org/community/webed/wiki/A_Short_History_of_JavaScript |titel=A Short History of JavaScript |werk=Web Education Community Group Wiki |hrsg=W3C |datum=2012-07-27 |sprache=en |abruf=2016-07-27}}</ref> ''JavaScript'' ist seit der Übernahme von Sun Microsystems eine [[Marke (Recht)|Marke]] des Unternehmens [[Oracle]].<ref>{{DtPatentMarkenA |Nummer=395492653 |Name=JAVASCRIPT}}</ref>

Mit der ersten [[Beta-Version]] des Navigators 3.0 führte Netscape am 29.&nbsp;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 Explorer]]s&nbsp;3 stellte Microsoft im Mai 1996 seinen ersten JScript-fähigen Browser vor. Dies war der Beginn des [[Browserkrieg]]s.<ref>{{Internetquelle |autor=Ingo Pakalski |url=https://www.golem.de/0805/59377.html |titel=15 Jahre WWW: Die Browserkriege |titelerg=Der erste Browserkrieg zwingt Netscape in die Knie |werk=Golem.de |datum=2008-05-01 |abruf=2016-07-27}}</ref><ref>{{Der Spiegel |ID=8810060 |Autor=Klaus-Peter Kerbusk |Titel=Mißbrauch des Monopols |Jahr=1997 |Nr=44}}</ref>

Mit der Ankündigung des [[Netscape Communicator]]s 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 [[Ecma International|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&nbsp;– ECMAScript language specification''. Am 1.&nbsp;Oktober 1997 kam der Internet Explorer&nbsp;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 (Programmierung)|Rhino]] wurde ab Version 6.0 als Teil der [[Java-Laufzeitumgebung]] standardmäßig mitgeliefert.<ref>{{Internetquelle |url=https://docs.oracle.com/javase/6/docs/technotes/guides/scripting/index.html |titel=Scripting for the Java Platform |werk=Java SE Documentation |hrsg=[[Oracle]] |sprache=en |abruf=2012-10-24}}</ref> 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.<ref>{{Internetquelle |autor=Florian Scholz, Eric Shepherd |url=https://developer.mozilla.org/en-US/docs/Web/JavaScript/New_in_JavaScript/1.3 |archiv-url=https://web.archive.org/web/20160728221239/https://developer.mozilla.org/en-US/docs/Web/JavaScript/New_in_JavaScript/1.3 |archiv-datum=2016-07-28 |titel=New in JavaScript 1.3 |werk=Mozilla Developer Network |hrsg=Mozilla Foundation |datum=2016-01-20 |sprache=en |abruf=2016-07-27}}</ref> 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.<ref>{{Internetquelle |autor=Florian Scholz, Eric Shepherd |url=https://developer.mozilla.org/en-US/docs/Web/JavaScript/New_in_JavaScript/1.4 |titel=New in JavaScript 1.4 |werk=Mozilla Developer Network |hrsg=Mozilla Foundation |datum=2016-01-20 |sprache=en |abruf=2016-07-27}}</ref><ref>{{Internetquelle |url=http://developer.netscape.com/docs/manuals/js/core/jsref/index.htm |titel=New Features in this Release |werk=DevEdge Online Documentation |hrsg=Netscape Communications Corporation |datum=1998-10-29 |sprache=en |offline=1 |archiv-url=https://web.archive.org/web/20040802225238/http://developer.netscape.com/docs/manuals/js/core/jsref/index.htm |archiv-datum=2004-08-02 |abruf=2016-07-27}}</ref> 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),<ref>{{Internetquelle |autor=Florian Scholz, Eric Shepherd |url=https://developer.mozilla.org/en-US/profiles/Sheppy |titel=New in JavaScript 1.5 |werk=Mozilla Developer Network |hrsg=Mozilla Foundation |sprache=en |abruf=2016-01-20}}</ref> am 29. November 2005 [[Mozilla Firefox]] 1.5 mit JavaScript 1.6<ref>{{Internetquelle |autor=Wladimir Palant, SylvainPasche, Nickolay Ponomarev, Florian Scholz, Eric Shepherd |url=https://developer.mozilla.org/en-US/docs/Web/JavaScript/New_in_JavaScript/1.6 |titel=New in JavaScript 1.6 |werk=Mozilla Developer Network |hrsg=Mozilla Foundation |datum=2016-04-04 |sprache=en |abruf=2016-07-27}}</ref>, am 12. Juli 2006 Mozilla Firefox 2.0b1 mit JavaScript 1.7<ref>{{Internetquelle |autor=Florian Scholz, James Herdman, Eric Shepherd, Robert Sedovšek, David Bruant, Leo Balter, Jonathan Watt, Eli Grey, Nickolay Ponomarev, Martin Honnen, Evan Prodromou |url=https://developer.mozilla.org/en-US/docs/Web/JavaScript/New_in_JavaScript/1.7 |titel=New in JavaScript 1.7 |werk=Mozilla Developer Network |hrsg=Mozilla Foundation |datum=2015-10-21 |sprache=en |abruf=2016-07-27}}</ref> und am 18. Dezember 2007 Mozilla Firefox 3.0b2 mit JavaScript 1.8.<ref>{{Internetquelle |autor=Florian Scholz, Eli Grey, Leandro Mercês Xavier, Nickolay Ponomarev |url=https://developer.mozilla.org/en-US/docs/Web/JavaScript/New_in_JavaScript/1.8 |titel=New in JavaScript 1.8 |werk=Mozilla Developer Network |hrsg=Mozilla Foundation |datum=2016-01-20 |sprache=en |abruf=2016-07-27}}</ref>

=== Versionsgeschichte von JavaScript ===
{| class="wikitable"
|+Versionsgeschichte<ref>{{Internetquelle |autor=John Resig |url=https://johnresig.com/blog/versions-of-javascript/ |titel=Versions of JavaScript |werk=johnresig.com/ |datum=2008-04-22 |sprache=en |abruf=2020-06-08}}</ref>
|-
! Version !! Veröffentlichung !! Entsprechung !! Netscape Navigator !! Mozilla Firefox !! Internet Explorer !! Opera !! Safari !! Google Chrome
|-
| {{Version |o |1.0.0}} || März 1996 || || 2.0 || || 3.0 || || ||
|-
| {{Version |o |1.1.0}} || August 1996 || || 3.0 || || || || ||
|-
| {{Version |o |1.2.0}} || Juni 1997 || || 4.0–4.05 || || || || ||
|-
| {{Version |o |1.3.0}} || Oktober 1998 || ECMA-262 1st edition / ECMA-262 2nd edition || 4.06–4.7x || || 4.0 || || ||
|-
| {{Version |o |1.4.0}} || || || Netscape Server || || || || ||
|-
| {{Version |o |1.5.0}} || November 2000 || ECMA-262 3rd edition || 6.0 || 1.0
|
* 5.5 (JScript 5.5)
* 6 (JScript 5.6)
* 7 (JScript 5.7)
* 8 (JScript 6)
|
* 6.0
* 7.0
* 8.0
* 9.0
| ||
|-
| {{Version |o |1.6.0}} || November 2005 || 1.5 + Array extras + Array & String generics + E4X || || 1.5 || ||
|
* 3.0
* 3.1
|
|-
| {{Version |o |1.7.0}} || Oktober 2006 || 1.6 + Pythonic generators + Iterators + let + destructuring assignments || || 2.0 || ||
|
* 3.2
* 4.0
| 1.0
|-
| {{Version |o |1.8.0}} || Juni 2008 || 1.7 + Generator expressions + Expression closures || || 3.0 || || || ||
|-
| {{Version |o |1.8.1}} || Juni 2009 || 1.8 + geringfügige Updates || || 3.5 || || || ||
|-
| {{Version |c |1.8.2}} || Januar 2010 || 1.8.1 + geringfügige Updates || || 3.6 || || || ||
|-
| {{Version |c |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.<ref>{{Internetquelle |url=https://www.ecma-international.org/publications-and-standards/standards/ecma-262/ |titel=ECMAScript 2022 Language Specification |datum=2022-06 |sprache=en |abruf=2022-07-22}}</ref> Dieser sollen jährliche Updates folgen.<ref>{{Internetquelle |autor=Julia Schmidt |url=https://www.heise.de/developer/meldung/Standard-fuer-ECMAScript-soll-jaehrlich-Updates-erhalten-2526864.html |titel=Standard für ECMAScript soll jährlich Updates erhalten |werk=[[Heise online|heise]] Developer |datum=2015-01-23 |abruf=2015-10-22}}</ref> Die Entwicklung der Standards erfolgt auf [[GitHub]].<ref>{{Internetquelle |url=https://github.com/tc39/ecma262/ |titel=tc39/ecma262 |werk=GitHub |abruf=2017-01-02}}</ref>

{| class="wikitable"
|- style="background:#CCCCFF;"
! Version
! publiziert am
! Unterschiede zur Vorgängerversion
! Editor
|-
| align="center" {{Version|o|1}}
| Juni 1997
| erste Version
| [[Guy L. Steele, Jr.]]
|-
| align="center" {{Version|o|2}}
| Juni 1998
| Änderungen zwecks Kompatibilität zum internationalen Standard ISO/IEC 16262
| [[Mike Cowlishaw]]
|-
| align="center" {{Version|o|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
|-
| align="center" {{Version|o|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.
|
|-
| align="center" {{Version|o|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.<ref>[https://www.youtube.com/watch?v=Kq4FpMe6cRs Changes to JavaScript, Part 1: EcmaScript 5]</ref>
| [[Pratap Lakshman]], [[Allen Wirfs-Brock]]
|-
| align="center"  {{Version|co|5.1}}
| Juni 2011
| Entspricht dem internationalen Standard ISO/IEC 16262:2011, Version 3
| Pratap Lakshman, Allen Wirfs-Brock
|-
| {{Version|co|2015}}<ref>{{Internetquelle |url=https://www.ecma-international.org/ecma-262/6.0/index.html |titel=ECMAScript 2015 Language Specification |sprache=en |abruf=2017-01-02}}</ref><ref>{{Literatur |Titel=ECMAScript 2016 Language Specification |Auflage=7 |Verlag=Emca International |Ort=Genf |Sprache=en |Online=https://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf |Format=PDF |KBytes= |Umfang=586}} {{Webarchiv |url=https://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf |text=ECMAScript 2016 Language Specification |wayback=20150412040502}}</ref>
| 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.<ref>{{Internetquelle |url=https://kangax.github.io/compat-table/es6/ |titel=ECMAScript 6 compatibility table |werk=kangax.github.io |sprache=en |abruf=2017-01-02}}</ref> Neue Sprachbestandteile wie <code>for</code>/<code>of</code>-Schleifen, teilweise an [[Python (Programmiersprache)|Python]] angelehnte Syntax usw. Der Codename lautet “Harmony” und wurde bis kurz vor Verabschiedung als „ECMAScript&nbsp;6“ bezeichnet,<ref>{{Literatur |Autor=Nicholas C. Zakas |Titel=Professional JavaScript for Web Developers |Verlag=John Wiley & Sons. |Datum=2011 |ISBN=978-1-118-02669-4 |Sprache=en |Umfang=960}}</ref> also „ES6“<ref>siehe englische WP</ref>.
| Allen Wirfs-Brock
|-
| {{Version|co|2016}}<ref>{{Internetquelle |url=https://www.ecma-international.org/ecma-262/8.0/index.html |titel=ECMAScript 2017 Language Specification |datum=2017-06 |sprache=en |abruf=2017-12-05}}</ref><ref>{{Internetquelle |url=https://www.heise.de/developer/meldung/JavaScript-Standard-ECMAScript-2016-offiziell-verabschiedet-3240246.html |titel=JavaScript-Standard ECMAScript 2016 offiziell verabschiedet |werk=heise online |hrsg=heise Developer |datum=2016-06-17 |abruf=2017-01-03}}</ref>
|Juni 2016
| <code>**</code> ([[Potenzfunktion]]), <code>Array.prototype.includes</code>, diverse Anpassungen an Generatoren, destruktiven Zuweisungen<ref name="kangax">{{Internetquelle |url=https://kangax.github.io/compat-table/es2016plus/ |titel=ECMAScript Next compatibility table |werk=kangax.github.io |abruf=2017-01-02}}</ref>
|[[Brian Terlson]]
|-
|{{Version|co|2017}}<ref>{{Internetquelle |url=https://www.ecma-international.org/ecma-262/8.0/index.html |titel=ECMAScript 2017 Language Specification |hrsg=Ecma International |datum=2017-06 |sprache=en |abruf=2017-08-04}}</ref>
|Juni 2017
|<code>async</code>/<code>await</code>, diverse <code>Object</code>-Funktionen<ref name="kangax" /><ref>{{Internetquelle |autor=Christian Liebel |url=https://www.heise.de/developer/artikel/Evolution-im-Web-ECMAScript-2017-3786219.html |titel=Evolution im Web: ECMAScript 2017 |hrsg=heise Developer |datum=2017-08-01 |abruf=2017-08-04}}</ref><ref>{{Internetquelle |url=https://exploringjs.com/es2016-es2017/pt_es2017.html |titel=ECMAScript 2017 |werk=Exploring ES2016 and ES2017 |datum=2017-03-22 |sprache=en |abruf=2017-08-04}}</ref>
|Brian Terlson
|-
|{{Version|co|2018}}
|Juni 2018<ref>[https://www.heise.de/developer/meldung/JavaScript-Standard-ECMAScript-2018-offiziell-verabschiedet-4094119.html JavaScript-Standard ECMAScript 2018 offiziell verabschiedet] heise.de, am 28. Juni 2018</ref>
|<code>global</code>, <code>import()</code>, Rest/Spread Properties, <code>for</code>-<code>await</code>-<code>of</code> (Asynchronous Iterators), [[Padding (Informatik)|String-Padding]], …<ref>{{Internetquelle |url=https://github.com/tc39/proposals |titel=Tracking ECMAScript Proposals |werk=TC39 |hrsg=Ecma |sprache=en |abruf=2017-08-04}}</ref>
|Brian Terlson
|-
|{{Version|co|2019}}
|Juni 2019
|<code>Array#{flat,flatMap}</code>, <code>Object.fromEntries</code>, <code>String#{trimStart,trimEnd}</code>, <code>Symbol#description</code>, …<ref>{{Internetquelle |url=https://www.heise.de/developer/meldung/ECMAScript-2019-Neun-Neuerungen-fuer-den-JavaScript-Sprachstandard-4296951.html |titel=ECMAScript 2019: Neun Neuerungen für den JavaScript-Sprachstandard |werk=heise online |hrsg=heise online |datum=2019-02-04 |abruf=2020-04-17}}</ref>
|Brian Terlson, Bradley Farias, Jordan Harband
|-
|{{Version|co|2020}}
|Juni 2020
|<code>String.matchAll</code>, <code>BigInt</code>, <code>import()</code>, …<ref>{{Internetquelle |url=https://www.heise.de/developer/meldung/JavaScript-Die-Features-fuer-ECMAScript-2020-stehen-fest-4697505.html |titel=JavaScript: Die Features für ECMAScript 2020 stehen fest |werk=heise online |hrsg=heise online |datum=2020-04-06 |abruf=2020-06-19}}</ref>
|Jordan Harband, Kevin Smith
|-
|{{Version|co|2021}}
|Juni 2021
|<code>String.prototype.replaceAll</code>, <code>WeakRef</code>s, Logical Assignment Operators, …<ref>{{Internetquelle |url=https://www.heise.de/news/JavaScript-2021-Schwache-Referenzen-beliebige-Versprechen-und-neue-Zuweisungen-4851658.html |titel=JavaScript 2021: Schwache Referenzen, beliebige Versprechen und neue Zuweisungen |werk=heise online |hrsg=heise online |datum=2020-07-24 |abruf=2021-09-27}}</ref>
|Jordan Harband, Shu-yu Guo, Michael Ficarra, Kevin Gibbons
|-
|{{Version|co|2022}}<ref>[https://tc39.es/ecma262/ ECMAScript® 2022 Language Specification]</ref>
|Juni 2022
|Private Methoden und Felder in Klassen, Statische Initialisierungs-Blöcke in Klassen, <code>await</code> außerhalb von <code>async</code>-Funktionen, …<ref>{{Internetquelle |url=https://medium.com/geekculture/proposals-included-in-the-incoming-ecmascript-2022-standard-for-javascript-6119a4518904 |titel=Proposals included in the incoming ECMAScript 2022 standard for JavaScript |werk=geek culture |hrsg=geek culture |datum=2021-09-02 |abruf=2021-09-27}}</ref>
|Shu-yu Guo, Michael Ficarra, Kevin Gibbons
|-
|{{Version|c|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 <code><input type="file"></code>, 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 [[Symbolleiste]]n, 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 [[Thread (Informatik)|Threads]] ausgeführt. Warteschleifen oder lange Berechnungen sind daher in JavaScript-Programmen zu vermeiden. Mit [[Web Worker|<code>Worker</code>-Objekten]] ist es möglich, weitere Threads zu erzeugen.<ref>{{Internetquelle |url=https://www.w3.org/TR/workers/ |titel=W3C Working Draft 24 September 2015 |werk=w3.org |abruf=2016-07-28}}</ref>

=== 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 [[Weiße Liste|White-]] und [[Schwarze Liste|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.
{{Siehe auch|Unobtrusive JavaScript}}

== Sprachelemente ==
=== Datentypen ===
JavaScript ist [[Dynamische Typisierung|dynamisch typisiert]]. Das bedeutet, dass die Zuweisung von Werten an Variablen keinen [[Datentyp|typbasierten]] Einschränkungen unterliegt. Allerdings gibt es diverse Erweiterungen von JavaScript, die eine [[statische Typisierung]] optional beziehungsweise zwingend erfordern, zum Beispiel [[TypeScript]] von [[Microsoft]].<ref>{{Internetquelle |autor=Ilja Zaglov |url=https://t3n.de/news/typescript-microsofts-neue-418900/ |titel=TypeScript: Microsoft’s neue JavaScript Erweiterung |werk=[[t3n Magazin]] |datum=2012-10-10 |abruf=2012-10-10}}</ref>

Aufgrund der dynamischen Typisierung ist der [[Datentyp]] keine Eigenschaft einer Variablen, sondern Laufzeit-bezogen die Eigenschaft ihres aktuellen Wertes (oder auch die Eigenschaft eines [[Literal]]s). Der Datentyp eines Wertes lässt sich mit dem [[Einstellige Verknüpfung|unären]] Operator <code>typeof</code> ermitteln.

==== Primitive Datentypen ====
Zu den [[Datentyp#Elementare_Datentypen|primitiven Datentypen]] in JavaScript gehören Zahlen, Zeichenketten, boolesche Werte, Symbole, null und undefined.

* Numerische Werte können entweder den Typ ''Number'' (angezeigt durch <code>typeof</code> als <code>"number"</code>) oder ''BigInt'' haben (angezeigt durch <code>typeof</code> als <code>"bigint"</code>). Während der Datentyp ''Number'' für Gleitkommazahlen verwendet wird, ermöglicht der Datentyp ''BigInt'' die Darstellung ganzer Zahlen beliebiger Größe, die den Bereich überschreiten, den ''Number'' abdecken kann.
* [[Zeichenkette|Zeichenketten]] haben den Typ ''String'' (angezeigt durch <code>typeof</code> als <code>"string"</code>).
* [[Boolean|Boolesche Werte]] haben den Typ ''Boolean'' (angezeigt durch <code>typeof</code> als <code>"boolean"</code>)
* [[Symbol (Informatik)|Symbole]] haben den Typ ''Symbol'' (angezeigt durch <code>typeof</code> als <code>"symbol"</code>) und fungieren als eindeutige [[Identifikator|Identifikatoren]], werden jedoch seltener verwendet.
* Der Typ ''Null'' hat nur den Wert <code>null</code> (<code>typeof</code> liefert <code>"object"</code>, was historisch bedingt ist).
* Der Typ ''Undefined'' hat nur den Wert <code>undefined</code> (<code>typeof</code> liefert <code>"undefined"</code>).

==== Nicht primitive Datentypen ====
Funktionen sind kein primitiver Typ (<code>typeof</code> liefert <code>"function"</code>). Für alle anderen Werte – reguläre Ausdrücke, Arrays und den Wert <code>null</code> inbegriffen – liefert <code>typeof</code> den Zeichenketten-Wert <code>"object"</code> zurück. Es ist zu beachten, dass null ein primitiver Datentyp ist, auch wenn <code>typeof</code> für <code>null</code> aus historischen Gründen den Wert "object" liefert. Im Gegensatz zu anderen Programmiersprachen gibt es in JavaScript keine echten [[Assoziatives Datenfeld|assoziativen Arrays]].<ref>{{Internetquelle |url=https://wiki.selfhtml.org/wiki/JavaScript/Objekte/Array#assoziative_arrays |titel=JavaScript/Objekte/Array |werk=SELFHTML |datum=2016-07-15 |abruf=2016-07-27}}</ref>

Objekte, die durch die vordefinierten [[Konstruktor]]funktionen <code>String()</code>, <code>Number()</code> und <code>Boolean()</code> erzeugt werden, verhalten sich ähnlich wie Werte der entsprechenden primitiven Datentypen. Allerdings gibt der <code>typeof</code>-Operator für solche Objekte den Wert <code>"object"</code> zurück. Diese Art von Objekten wird als [[Wrapper-Klasse|Wrapper-Objekte]] bezeichnet. Für den Datentyp ''Symbol'' existiert keine gleichnamige Konstruktorfunktion. Im Folgenden finden wir ein Beispiel einer Variablen und dem entsprechenden Wrapper-Objekt:

<syntaxhighlight lang="javascript">
let simpleString = "Beispieltext";
// Die Funktion "alert" gibt das Ergebnis "string" in einem Fenster aus.
alert(typeof simpleString);

let stringObject = new String("Beispieltext");
alert(typeof stringObject); // ergibt "object"
</syntaxhighlight>

Umgekehrt werden Werte der primitiven Typen ''Number'', ''Boolean'' und ''String'' bei Bedarf automatisch in Objekte der entsprechenden Konstruktorfunktion umgewandelt:

<syntaxhighlight lang="javascript">
let simpleString = "Beispieltext";
alert(simpleString.length); // ergibt 12
</syntaxhighlight>

In diesem Beispiel wird die Eigenschaft <code>length</code> aufgerufen, obwohl <code>simpleString</code> ein primitiver String ist. JavaScript wandelt automatisch den primitiven String in ein temporäres String-Objekt um, um die Eigenschaft <code>length</code> abzurufen.

=== Kontrollstrukturen ===
JavaScript kennt die üblichen [[Kontrollstruktur]]en. Sollen diese mehr als eine [[Anweisung (Programmierung)|Anweisung]] enthalten, so muss ein in [[geschweifte Klammer]]n eingeschlossener [[Blockstruktur|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) ====
<syntaxhighlight lang="javascript">
if (bedingung) {
    anweisungen;
} else {
    anweisungen;
}
</syntaxhighlight>
Kurzschreibweise für bedingte Wertzuweisungen:
<syntaxhighlight lang="javascript">
variable = bedingung ? wertWennWahr : wertWennFalsch;
</syntaxhighlight>

==== switch-Kontrollstruktur ====
<syntaxhighlight lang="javascript">
switch (variable) {
    case wert1:
        anweisungen;
        break;
    case wert2:
        anweisungen;
        break;
    default:
        anweisungen;
}
</syntaxhighlight>

'''[[while-Schleife]]'''
<syntaxhighlight lang="javascript">
while (bedingung) {
    anweisungen;
}
</syntaxhighlight>

'''[[do-while-Schleife]]'''
<syntaxhighlight lang="javascript">
do {
    anweisungen;
} while (bedingung);
</syntaxhighlight>

'''[[for-Schleife]]'''
<syntaxhighlight lang="javascript">
for (startausdruck; bedingung; iterationsausdruck) {
    anweisungen;
}
</syntaxhighlight>

'''for … in-Schleife'''

Mit dieser Anweisung werden alle eigenen und ererbten Eigenschaften eines Objektes durchlaufen, die das interne Attribut Enumerable aufweisen.<ref>[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for...in for…in] MDN</ref> Dieses Attribut wurde in ECMA Script&nbsp;5 eingeführt und ist für bestimmte eingebaute Eigenschaften (wie z.&nbsp;B. die Funktion toString des Prototyps Object) nicht gesetzt, es kann allerdings im Regelfall vom Benutzer gesetzt (und entfernt) werden.<ref>[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty#Enumerable_attribute Object.defineProperty()] MDN</ref> Bei jedem Schleifendurchgang wird einer angegebenen Variable der Eigenschaftsname zugewiesen.

<syntaxhighlight lang="javascript">
for (let eigenschaftsname in objekt) {
    anweisungen;
}
</syntaxhighlight>

'''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.<ref>[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for...of for…of] MDN</ref>

<syntaxhighlight lang="javascript">
for (let wert of objekt) {
    anweisungen;
}
</syntaxhighlight>

=== Variablen ===
Variablen sollten in JavaScript mit <code>let</code> oder <code>var</code> deklariert werden und sind dann innerhalb des [[Variable (Programmierung)#Sichtbarkeitsbereich von Variablen (Scope)|Scopes]] gültig, in dem sie deklariert wurden, wobei <code>let</code> den Scope weiter eingrenzt als <code>var</code>.<ref>[https://wiki.selfhtml.org/wiki/JavaScript/Variable/let JavaScript/Variable/let] im SELFHTML-Wiki</ref> Verwendet man Variablen ohne sie vorher explizit zu deklarieren, werden diese implizit als Eigenschaften des globalen Objekts (im Browser <code>window</code>) deklariert; dieses Verhalten kann man durch die Anweisung <code>"use strict";</code> 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 ====
In JavaScript gibt es globale und lokale Variablen abhängig davon, wo sie deklariert werden und wie sie verwendet werden.

* Globale Variablen:

Variablen, die außerhalb von Funktionen deklariert werden, sind global gültig. Im Browser bedeutet ''global'', dass solche Variablen auf der gesamten Webseite und in allen aktiven JavaScript-Dateien zugänglich sind. Dies kann zu unerwünschten Nebeneffekten führen, insbesondere wenn andere Skripte wie Drittanbieter-Plugins, [[Web Analytics]] oder Werbebannern eingebunden sind. Daher sollten globale Variablen nach Möglichkeit vermieden werden.

<syntaxhighlight lang="javascript">
let explicit; // Explizite Deklaration einer globalen Variable
explicit = "explizit deklariert"; // Definition einer globalen Variable
console.log(explicit); // Ausgabe: explizit deklariert
</syntaxhighlight>

Implizit deklarierte Variablen sind immer global. Auch wenn eine Variable innerhalb einer Funktion implizit ohne <code>let</code> oder <code>var</code> deklariert wurde, wird sie automatisch zu einer globalen Variable.

<syntaxhighlight lang="javascript">
function foo() {
    implicit = "implizit deklariert"; // Definition einer globalen Variable
}

foo();
console.log(implicit); // Ausgabe: implizit deklariert
</syntaxhighlight>

Eine implizit deklarierte Variable wird automatisch zu einer Eigenschaft des <code>globalThis</code>-Objekts. Das trifft bei explizit deklarierten globalen Variablen nicht zu.

<syntaxhighlight lang="javascript">
console.log(globalThis.implicit); // Ausgabe: implizit deklariert
console.log(typeof globalThis.explicit); // Ausgabe: undefined
</syntaxhighlight>

* Lokaler Geltungsbereich:
Variablen, die innerhalb von Funktionen deklariert oder als Funktionsparameter verwendet werden, haben einen lokalen Geltungsbereich. Das bedeutet, dass sie nur innerhalb der Funktion sichtbar und zugänglich sind.

<syntaxhighlight lang="javascript">
function bar(parameter) { // Deklaration eines Funktionsparameters
    let variable = "lokale Variable" // Deklaration einer lokalen Variablen

    console.log(parameter);
    console.log(variable); // Ausgabe: lokale Variable
}

bar("lokaler Parameter");
console.log(typeof parameter); // Ausgabe: undefined
console.log(typeof variable); // Ausgabe: undefined
</syntaxhighlight>

=== Konstanten ===
Konstanten sollen mit <code>const</code> deklariert werden, bei der Initialisierung muss ihnen ein Wert zugewiesen werden. Für den Gültigkeitsbereich gelten dieselben Bedingungen wie bei Variablendeklarationen mit <code>let</code>. 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.<ref>[https://wiki.selfhtml.org/wiki/JavaScript/Variable/const JavaScript/Variable/const] im SELFHTML-Wiki</ref>

=== Funktionen ===
In JavaScript sind Funktionen vollwertige Objekte mit eigenen Methoden und Eigenschaften. Sie können erstellt, überschrieben, als Argumente an andere Funktionen übergeben und von diesen erzeugt und zurückgegeben werden.

Im letzteren Fall entsteht eine [[Closure (Funktion)|Closure]], auch Funktionsabschluss genannt, die beispielsweise [[Datenkapselung (Programmierung)|Datenkapselung]] ermöglicht:

<syntaxhighlight lang="javascript">
function createGreeting(name) {
    let message = "Hallo, " + name + "!";

    return function() {
        return message;
    };
}

// 'greetAda' ist eine Funktion, die von 'createGreeting' zurückgegeben wird
let greetAda = createGreeting("Ada Lovelace");
console.log(greetAda()); // Ausgabe: Hallo, Ada Lovelace!

// 'greetAlan' ist eine Funktion, die von 'createGreeting' zurückgegeben wird
let greetAlan = createGreeting("Alan Turing");
console.log(greetAlan()); // Ausgabe: Hallo, Alan Turing!

// Der Zugriff auf den Wert 'message' ist von außen nicht möglich
console.log(typeof message); // Ausgabe: undefined
</syntaxhighlight>

Nicht jedes Argument einer Funktion muss beim Aufruf angegeben werden. Fehlende Argumente erhalten den Wert ''undefined''. Seit ECMAScript 2015 können Parameter auch mit Standardwerten definiert werden. Außerdem ermöglicht das <!-- Array-ähnliche, arguments ist kein Array! --> <code>arguments</code>-Objekt den Zugriff auf die Argumente innerhalb der Funktion.

==== Erzeugung ====
Es gibt mehrere Möglichkeiten, in JavaScript Funktionen zu erzeugen:<ref>{{Internetquelle |autor=Juriy Kangax Zaytsev |url=https://kangax.github.io/nfe/ |titel=Named function expressions demystified |werk=kangax.github.io |datum=2009-06-17 |sprache=en |abruf=2016-07-28}}</ref>
* Funktionsdeklarationen („Function Declarations“):
<syntaxhighlight lang="javascript">
function f(x, y) {
    return x + y;
}
</syntaxhighlight>

* Funktionsausdrücke („Function Expressions“):
<syntaxhighlight lang="javascript">
let f = function(x, y) {
    return x + y;
};
</syntaxhighlight>

* 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.
<syntaxhighlight lang="javascript">
(function(x, y) {
    return x + y;
})(2, 3);
</syntaxhighlight>

* Benannte Funktionsausdrücke („Named Function Expressions“):
Der Variablen <code>f</code> wird eine Funktion mit Bezeichner <code>g</code> zugewiesen. Außerhalb der Funktion ist sie mit <code>f</code> ansprechbar, innerhalb mit <code>f</code> und <code>g</code>.
<syntaxhighlight lang="javascript">
let f = function g(x, y) {
    return x + y;
};
</syntaxhighlight>

* Funktionskonstruktor („Function Constructors“):
<syntaxhighlight lang="javascript">
let f = new Function('x', 'y', 'return x + y;');
</syntaxhighlight>

* 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 <code>return</code> als Rückgabewert angeben. Mit geschweiften Klammern kann man beliebigen Code angeben, muss aber für Rückgabewerte <code>return</code> verwenden.
<syntaxhighlight lang="javascript">
(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;
</syntaxhighlight>

==== Beispiel ====
Eine [[Funktionale Programmierung|funktionale]] und [[Rekursion|rekursive]] Implementierung des [[Euklidischer Algorithmus#Rekursive Variante|Euklidischen Algorithmus]] mit zwei Argumenten sieht folgendermaßen aus:
<syntaxhighlight lang="javascript">
function euklid(a, b) {
    if (b === 0)
        return a;

    return euklid(b, a % b);
}
</syntaxhighlight>
Implementierung des Euklidischen Algorithmus mit beliebig vielen Argumenten durch Reduzierung von <code>numbers</code> auf einen einzigen Wert, indem jeweils zwei Elemente von links nach rechts mit <code>euklid</code> ausgewertet werden:

<syntaxhighlight lang="javascript">
function ggT(...numbers) {
    let reduce = 0;

    for (element of numbers)
        reduce = euklid(element, reduce);

    return reduce;
}

console.log(ggT());           // 0
console.log(ggT(4));          // 4
console.log(ggT(24, 36, 84)); // 12
</syntaxhighlight>

Implementierung des Euklidischen Algorithmus mit partieller Anwendung:
<syntaxhighlight lang="javascript">
function ggT(reduce) {
    if (reduce === undefined)
        return 0;

    return function(element) {
        if (element === undefined)
            return reduce;

        return ggT(euklid(element, reduce));
    };
}

console.log(ggT());             // 0
console.log(ggT(4)());          // 4
console.log(ggT(24)(36)(84)()); // 12
</syntaxhighlight>

=== 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 [[Objekttyp]]en, die im Standard ECMAScript definiert sind. Dabei wird ein Objekttyp durch eine namensgleiche [[Konstruktor]]<nowiki />funktionen 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 <code>Object</code>, von dem alle Objekte abgeleitet sind.
* Der Objekttyp <code>Function</code> von [[Funktion (Programmierung)|Funktionen]].
* Der Objekttyp <code>Array</code> von [[Array (Datentyp)|Arrays]].
* Der Objekttyp <code>String</code> von [[Zeichenkette]]n.
* Der Objekttyp <code>Boolean</code> von [[boolesche Variable]]n.
* Der Objekttyp <code>Number</code> von [[Zahl]]en (64-Bit-[[Gleitkommazahl]]en gemäß [[IEEE 754]]).
* Der Objekttyp <code>Date</code> für [[Datumsformat]]e ([[Kalender|Daten]] bzw. Zeitpunkte).
* Der Objekttyp <code>RegExp</code> für [[Regulärer Ausdruck|reguläre Ausdrücke]].
* Der Objekttyp <code>Error</code> zur Charakterisierung (und ggf. nachfolgenden Auslösung mittels <code>throw</code>) von [[Laufzeitfehler]]n.
* Das Objekt <code>Math</code> stellt Konstanten und Methoden für [[Mathematik|mathematische]] Operationen bereit.
* Das Objekt <code>JSON</code> stellt zwei Methoden für die [[Serialisierung]] von Objekten ins [[JSON]]-Format und umgekehrt bereit.
* Das Objekt <code>Reflect</code> stellt 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 Communications|Netscape]]-Spezifikationen (<code>window</code>, <code>document</code> usw.). Das <code>window</code>-Objekt selbst ist dabei de facto das globale Objekt, indem einfach einer Variablen <code>window</code> das globale Objekt zugewiesen wurde. Zahlreiche Unterobjekte von <code>document</code> wurden mittlerweile durch [[Document Object Model|DOM]] HTML standardisiert (<code>title</code>, <code>images</code>, <code>links</code>, <code>forms</code> usw.). Aktuelle Browser unterstützen zudem DOM Core und andere [[World Wide Web Consortium|W3C]]-DOM-Standards sowie Erweiterungen von Microsoft [[JScript]].

==== Zugriff auf Objekteigenschaften und -methoden ====
[[Eigenschaft]]en von Objekten (auch [[Methode (Programmierung)|Methoden]] sind Eigenschaften) können wie folgt angesprochen werden:

; Punkt-Notation (mit statischen [[Bezeichner]]n)

<syntaxhighlight lang="javascript">
objekt.eigenschaft;

objekt.methode(parameter1, parameter2);
</syntaxhighlight>

; Klammer-Notation (mit dynamischen [[Bezeichner]]n)

<syntaxhighlight lang="javascript">
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]);
}
</syntaxhighlight>

Zu allen Objekten können zur [[Laufzeit (Informatik)|Laufzeit]] neue Eigenschaften hinzugefügt oder mit <code>delete</code> bestehende entfernt werden:

<syntaxhighlight lang="javascript">
// 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"];
</syntaxhighlight>

==== Objektliterale ====
Objekte können in JavaScript direkt anhand ihrer Eigenschaften definiert werden:

<syntaxhighlight lang="javascript">
let meinObjekt = {
    zahl: 42,
    gibZahl: function() {
        return this.zahl;
    }
};

alert(meinObjekt.gibZahl()); // 42
</syntaxhighlight>

Eine spezielle Notation gibt es für reguläre Ausdrücke:

<syntaxhighlight lang="javascript">

// mit Konstruktorfunktion
(new RegExp("a")).test("ab"); // true

// als Literal
/a/.test("ab"); // true
</syntaxhighlight>

==== Konstruktor-Funktionen ====
Eine Funktion kann dazu genutzt werden, um ein mit <code>new</code> 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 <code>this</code> angesprochen werden.

<syntaxhighlight lang="javascript">
function MeinObjekt(x) { // Konstruktor
    this.zahl = x;
}

let objekt = new MeinObjekt(3); // Instanz erzeugen
alert(objekt.zahl); // per Meldefenster ausgeben (3)
</syntaxhighlight>

==== „Private“ Eigenschaften ====
Private Eigenschaften und Methoden sind nicht explizit Teil der Sprache.

Mit Hilfe von Closures (siehe [[#Funktionen|Funktionen]]) lassen sich dennoch private Eigenschaften von Objekten realisieren:

<syntaxhighlight lang="javascript">
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
</syntaxhighlight>

Lediglich die <code>toeten</code>-Methode von <code>otto</code> kennt die Variable <code>lebensZahl</code>.
Der Effekt gleicht dem einer privaten Eigenschaft, wenn alle Methoden der Katze in der erzeugenden Funktion <code>erschaffeKatze</code> definiert werden. <code>lebensZahl</code> ist dann für alle Methoden (privilegierte Methoden, im Beispiel <code>toeten</code>) und inneren Funktionen der erzeugenden Funktion (private Methoden, im Beispiel <code>maunz</code>) sichtbar, nicht jedoch von außen oder von nachträglich an das Objekt gehängten Methoden.

==== Vererbung über Prototypen ====
[[Vererbung (Programmierung)|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:

<syntaxhighlight lang="javascript">
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
</syntaxhighlight>

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:

<syntaxhighlight lang="javascript">
blinky.hasOwnProperty('augen'); // false
</syntaxhighlight>

==== Fixierung von Objektstruktur und -inhalten ====
Die in JavaScript im Regelfall völlig dynamische Struktur eines Objekts <code>obj</code> kann in verschiedener Hinsicht fixiert werden: Nach dem Methodenaufruf <code>Object.preventExtensions(obj)</code> können keine weiteren Attribute und Methoden mehr ergänzt werden. <code>Object.seal(obj)</code> verhindert sowohl die Erweiterung wie die Streichung von Attributen und Methoden. Der Aufruf <code>Object.freeze(obj)</code> fixiert sowohl die Objektstruktur wie auch die Attributwerte inklusive der Methoden gegen nachfolgende Veränderungen. Die betreffenden Status eines Objekts <code>obj</code> können mit <code>Object.isExtensible(obj)</code>, <code>Object.isSealed(obj)</code> und <code>Object.isFrozen(obj)</code> ermittelt werden.

Es ist auch möglich, nur ein einzelnes Attribut eines Objekts <code>obj</code> zu fixieren. Beispielsweise wird mit dem Aufruf

<code>Object.defineProperty(obj, "vorname", {writable:false});</code>

das Attribut <code>obj.vorname</code> schreibgeschützt.<ref name="ECMAScript">{{Internetquelle |url=https://www.ecma-international.org/ecma-262/5.1/#sec-15.2.3 |titel=ECMAScript Language Specification – ECMA-262 Edition 5.1 |werk=ecma-international.org |abruf=2016-07-28}} ([http://www.ecma-international.org/ecma-262/5.1/Ecma-262.pdf ecma-international.org] (PDF) PDF).</ref>

=== Delegationsprinzipien ===
JavaScript ist eine [[Delegation (Softwareentwicklung)|Delegationssprache]] mit sowohl selbstausführendem als auch direktem Delegationsmechanismus.

; Funktionsobjekte als Rollen (Traits und Mixins)
: JavaScript unterstützt schon auf der Ebene des Sprachkerns verschiedene auf Funktionsobjekten aufbauende Implementierungen des Rollen-Musters<ref>Englische Wikipedia: [[:en:Role-oriented programming|Role-oriented programming]]</ref> wie z.&nbsp;B. [[Trait (Programmierung)|Traits]]<ref>[http://soft.vub.ac.be/~tvcutsem/traitsjs/ Traits for Javascript], 2010.</ref><ref>[https://cocktailjs.github.io/ CocktailJS – Annotations. Traits. Talents.] April 2013.</ref> und [[Mixin]]s.<ref>Angus Croll, [https://javascriptweblog.wordpress.com/2011/05/31/a-fresh-look-at-javascript-mixins/ A fresh look at JavaScript Mixins] vom 31. Mai 2011.</ref><ref>[https://peterseliger.blogspot.de/2014/06/die-vielen-talente-von-javascript.html#die-vielen-talente-von-javascript-rollen-orientierte-programmieransätze-wie-traits-und-mixins-verallgemeinern-zu-können Die vielen Talente von JavaScript Rollen-orientierte Programmieransätze wie Traits und Mixins verallgemeinern zu können.] peterseliger.blogspot.de; 5. Juni 2014.</ref> Zusätzliches Verhalten wird bereitgestellt, indem mindestens eine Methode über das Schlüsselwort <code>this</code> im Rumpf eines <code>function</code>-Objekts gebunden wird. Benötigt ein Objekt zusätzliches Verhalten, welches ihm nicht über die Prototypenkette zur Verfügung gestellt werden kann, lässt sich eine Rolle direkt über <code>call</code> bzw. <code>apply</code> an dieses Objekt delegieren.
; Objektkomposition und Vererbung durch Delegation
: Während [[Komposition (Informatik)|Komposition]] in JavaScript über diese direkte Delegation abgedeckt werden kann, kommt automatische Delegation immer dann zur Anwendung, wenn der Interpreter die Prototypenkette eines Objekts nach oben hin abwandern muss, um z.&nbsp;B. eine mit diesem Objekt assoziierte Methode zu finden, die diesem nicht unmittelbar gehört. Sobald die Methode gefunden ist, wird sie im Kontext dieses Objekts aufgerufen. Demzufolge wird [[Vererbung (Programmierung)|Vererbung]] in JavaScript über einen selbstausführenden Delegationsmechanismus abgebildet, der an die <code>prototype</code>-Eigenschaft von Konstruktorfunktionen gebunden ist.

=== Fehlerbehandlung ===
Ab Version 3 verfügt ECMAScript über eine von Java übernommene [[Ausnahmebehandlung|Fehlerbehandlung]]. Die Anweisung <code>try … catch … finally</code> fängt [[Ausnahmebehandlung|Ausnahmen]] (''exceptions'') ab, die aufgrund eines [[Fehler]]s oder einer <code>throw</code>-Anweisung auftreten. Die Syntax lautet:

<syntaxhighlight lang="javascript">
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)
</syntaxhighlight>

Zu Beginn werden die Anweisungen im <code>try</code>-Block ausgeführt. Falls eine Ausnahme auftritt, wird der [[Kontrollfluss]] sofort zum <code>catch</code>-Block mit dem Ausnahmeobjekt als Parameter umgeleitet.

Im Normalfall wird der Ausnahmeblock übersprungen. Nach der Ausführung des <code>try</code>-Blocks (auch teilweise) und gegebenenfalls des <code>catch</code>-Blocks werden in jedem Fall die Anweisungen im <code>finally</code>-Block ausgeführt. Der <code>finally</code>-Teil kann weggelassen werden, alternativ der <code>catch</code>-Teil.

Einige Laufzeitumgebungen wie [[V8 (JavaScript-Engine)|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.<ref>[http://code.google.com/p/v8/wiki/JavaScriptStackTraceApi JavaScript Stack Trace API] in ''Google V8 Wiki'', Stand 28. Juni 2010, abgerufen am 23. Februar 2013</ref><ref>{{Webarchiv |url=http://www.aptana.com/reference/html/api/Error.html |text=JavaScript Core Reference: Error |wayback=20141104204221}} in ''Aptana HTML Reference'', Stand 2. Juli 2012, abgerufen am 23. Februar 2013</ref><ref>{{Internetquelle |autor=Tom DuPont |url=http://www.tomdupont.net/2013/04/report-unhandled-errors-from-javascript.html |titel=Report Unhandled Errors from JavaScript |datum=2013-04-13 |sprache=en |abruf=2013-04-16 |kommentar=Fehlerprotokollierung mit Stacktrace in JavaScript}}</ref>
Um diese Vorteile zu nutzen, ändert man im einfachsten Anwendungsfall den <code>throw</code>-Befehl von <syntaxhighlight lang="javascript" inline>throw "Meldungstext";</syntaxhighlight> zu <syntaxhighlight lang="javascript" inline>throw new Error("Meldungstext");</syntaxhighlight>.<ref>Nico Reed: {{Webarchiv |url=http://docs.nodejitsu.com/articles/errors/what-is-the-error-object |text=''What is the error object?'' |wayback=20130331135150}} In: ''Nodejitsu Documentation'', Stand 26. August 2011, abgerufen am 23. Februar 2013.</ref>

Klammern um den Parameter des <code>throw</code>-Befehls sind im Allgemeinen nicht notwendig.<ref name="ECMAScript" /> 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 <code>throw</code> und die öffnende Klammer einfügt.

== JavaScript-Bibliotheken ==
Um die Erstellung von [[Webanwendung]]en mit Hilfe von JavaScript zu erleichtern, gibt es diverse [[Programmbibliothek|Bibliotheken]] und [[Framework]]s. Eine Bibliothek ist eine Sammlung von [[Funktion (Programmierung)|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 (Programmierung)|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 (grafische Benutzeroberfläche)|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 [[Document Object Model|DOM]] sowie grafische Effekte wie [[Animation]]en. Aber auch schon vor dem breiten Einsatz von Ajax existierten Funktionssammlungen zur Unterstützung der browserübergreifenden Programmierung.<ref>{{Literatur |Autor=Stefan Koch |Titel=JavaScript. Einführung, Programmierung und Referenz – inklusive Ajax |Auflage=5 |Verlag=dpunkt.verlag |Ort=Heidelberg |Datum=2009 |ISBN=978-3-89864-594-2 |Kapitel=Ajax |Seiten=333–355 |Umfang=457}}</ref>

Zu den bekannten JavaScript-Bibliotheken und Frameworks zählen <!-- alphabetische Reihenfolge -->[[AngularJS]], [[Dojo Toolkit]], [[Ext JS]], [[jQuery]], [[MooTools]], [[Prototype (Klassenbibliothek)|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.

{{Siehe auch|:Kategorie:JavaScript-Bibliothek}}

== 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 Websites teilweise oder gänzlich nicht in Suchmaschinen auffindbar waren. Der Suchmaschinenbetreiber [[Google LLC|Google]] kann laut eigenen Aussagen JavaScript-Inhalte crawlen, rendern und indexieren.<ref>{{Internetquelle |url=https://developers.google.com/search/docs/guides/javascript-seo-basics?hl=de |titel=Grundlagen von JavaScript-SEO {{!}} Google Search Central |sprache=de |abruf=2020-12-07}}</ref> Neben allgemeinen Empfehlungen wie z.&nbsp;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.<ref>{{Internetquelle |url=https://web.dev/google-search-tools/ |titel=Web developer tools for debugging JavaScript issues in Google Search |sprache=en |abruf=2020-12-07}}</ref>

== Siehe auch ==
* [[ActionScript]] – Bezeichnung für eine JavaScript-ähnliche Skriptsprache in Flash und [[Macromedia]] Director, wo es alternativ zu [[Lingo (Programmiersprache)|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
* {{Literatur |Autor=[[Jörg Bewersdorff]] |Titel=Objektorientierte Programmierung mit JavaScript: Direktstart für Einsteiger |Auflage=2. |Ort=Wiesbaden |Datum=2018 |ISBN=978-3-658-21076-2 |DOI=10.1007/978-3-658-21077-9}}
* Philip Ackermann: ''JavaScript. Das umfassende Handbuch.'' 3. Auflage. Rheinwerk Computing, Bonn 2021, ISBN 978-3-8362-8629-9.
* {{Literatur
   |Autor=Nicholas Zakas
   |Titel=JavaScript objektorientiert: Verständlicher, flexibler, effizienter programmieren
   |Ort=Heidelberg
   |Datum=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 ([http://openbook.galileocomputing.de/javascript_ajax/ openbook.galileocomputing.de]).
* Stefan Koch: ''JavaScript. Einführung, Programmierung und Referenz.'' 6. Auflage. dpunkt-Verlag, Heidelberg 2011, ISBN 978-3-89864-731-1.
* [[Douglas Crockford]]: ''Das Beste an JavaScript.'' O’Reilly, Köln 2008, ISBN 978-3-89721-876-5.

== Weblinks ==
{{Commonscat}}
{{Wikibooks|Websiteentwicklung: JavaScript|Websiteentwicklung: JavaScript}}
{{Wiktionary}}
* {{dmoz|World/Deutsch/Computer/Programmieren/Internet/JavaScript/}}
* {{Internetquelle
   |url=https://cre.fm/cre146-javascript
   |titel=JavaScript – Geschichte, Struktur, Eigenschaften und die Zukunft der wichtigsten Programmiersprache des Webs
   |werk=Chaosradio Express CRE146
   |datum=2010-02-27
   |format=MP3 97,5&nbsp;MB
   |abruf=2010-02-27}}
* {{Internetquelle
   |autor=Addy Osmani
   |url=https://addyosmani.com/resources/essentialjsdesignpatterns/book/
   |titel=Learning JavaScript Design Patterns
   |sprache=en
   |abruf=2013-05-24
   |kommentar=[[Entwurfsmuster]] in JavaScript}}
* [https://www.ecma-international.org/ecma-262/#sec-copyright-and-software-license Lizenz]

=== Spezifikationen ===
* [http://standards.iso.org/ittf/PubliclyAvailableStandards/c055755_ISO_IEC_16262_2011(E).zip ISO-genormte ECMAScript-Spezifikation (ISO/IEC 16262:2002)] (englisch/französisch)
* [http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf ECMAScript-Spezifikation] (englisch, PDF; 3,1&nbsp;MiB) ([http://ecma-international.org/ecma-262/ HTML-Version])
* [https://developer.mozilla.org/de/docs/Web/JavaScript/Reference Referenz von Mozilla] (deutsch)

=== Dokumentationen ===
* [https://wiki.selfhtml.org/wiki/JavaScript JavaScript-Kapitel bei SELFHTML-Wiki]
* [https://intern.fh-wedel.de/~si/seminare/ws07/Ausarbeitung/11.javascript/ Objektorientierung in JavaScript]
* [https://eloquentjavascript.net/ Eloquent JavaScript] (Frei verfügbares [[E-Book]], englisch)

== Einzelnachweise ==
<references responsive />

{{Normdaten|TYP=s|GND=4420180-1}}

[[Kategorie:JavaScript| ]]
[[Kategorie:Skriptsprache]]
[[Kategorie:Objektorientierte Programmiersprache]]
[[Kategorie:Funktionale Programmiersprache]]
[[Kategorie:Prozedurale Programmiersprache]]