JavaScript
{{Infobox Programmiersprache
|Name = JavaScript
|Beschreibung = Skriptsprache
|Paradigma = multiparadigmatisch
|Erscheinungsjahr = 1995
|Entwickler = Brendan Eich
|AktuelleVersion = 1.8
|AktuelleVersionFreigabeDatum = 2008
|Typisierung = schwach, dynamisch, duck
|Implementierung = SpiderMonkey, Rhino, SquirrelFish, V8
|Beeinflusst_von = Self, C, Scheme, Perl, Python, Java
}}
JavaScript ist eine Skriptsprache, die hauptsächlich für das DOM-Scripting in Web-Browsern eingesetzt wird.
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. In JavaScript lässt sich objektorientiert und sowohl prozedural als auch funktional programmieren.
Während HTML/CSS nur rudimentäre Möglichkeiten zur Nutzerinteraktion bietet, können mit JavaScript Inhalte generiert und nachgeladen werden.
Entwicklung
Die Syntax von JavaScript ähnelt jener der C-Abkömmlinge, wozu auch Java gehört. Trotz der Namens- und syntaktischen Ähnlichkeit hat JavaScript nur geringe Gemeinsamkeiten mit Java, beispielsweise wird Objektorientierung in JavaScript anders als in Java nicht durch Klassen, sondern durch Prototypen unterstützt.
JavaScript wird hauptsächlich clientseitig eingesetzt, im Unterschied zu anderen im Web verwendeten Sprachen, wie Perl oder PHP, die ausschließlich serverseitig eingesetzt werden. JavaScript bzw. die ECMAScript-Implementierungen finden jedoch beispielsweise auf Netscape Enterprise Servern (NES), und als JScript bzw. JScript.NET in einer ASP- bzw. ASP.NET-Umgebung auf Microsoft Internet Information Services auch serverseitig Anwendung (Stichwort Server-Side JavaScript). Weitere Beispiele für serverseitige Javascript-Programmierung sind POW und Jaxer, die auf der Mozilla-Javascript-Engine Spidermonkey aufsetzen, sowie V8CGI, welches auf der V8-Engine aufbaut und in den Apache HTTP Server integriert wird.
Inzwischen hat sich die Sprache auch neue Anwendungsgebiete erschlossen. Zum Beispiel wird sie gerne 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.
Typische Anwendungsgebiete
Typische Anwendungsgebiete von JavaScript sind:
* Dynamische Manipulation von Webseiten über das Document Object Model
* Plausibilitätsprüfung (Validierung) von Formulareingaben beim Absender
* Senden und Empfangen von Daten, ohne dass der Browser die Seite neu laden muss (Ajax)
* sofortiges Vorschlagen von Suchbegriffen (suggesting search)
* Banner oder Laufschriften
* Verschleierung von E-Mail-Adressen zur Bekämpfung von Spam.
* Mehrere Frames auf einmal wechseln oder die Seite aus dem Frameset „befreien“
Missbrauch
Einige Anwendungen, die mit JavaScript möglich sind, verärgern meistens den Benutzer und werden als „schlechter Stil“ angesehen. Viele davon können deshalb inzwischen auch vom Browser blockiert werden.
Beispiele:miniatur|Hinweis im Firefox bei zuvielen Dialogfenstern
* Quelltext „verschleiern“, um diesen vor dem Besucher zu verstecken
* 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
* Ungewolltes Öffnen von Fenstern, teilweise auch Öffnen beliebig vieler Fenster
* Ungewolltes Schließen des Browserfensters
* Ungewollte Größenänderung des Browserfensters
* Blockieren der Anwender mit zahllosen aufeinanderfolgenden Dialogfenstern
* Bei anfälligen Webanwendungen kann JavaScript auch von Dritten missbraucht werden, etwa per XSS (Codeeinschleusung).
* JavaScript-Navigation: Barrierearme Webseiten zeichnen sich dadurch aus, dass sie auch bei abgeschaltetem JavaScript möglichst uneingeschränkt navigierbar bleiben. Oft schränkt das nicht aktivierte JavaScript die Benutzbarkeit einer Webseite ein.
Geschichte
Am 18. September 1995 veröffentlicht Netscape mit der Vorversion des Navigator 2.0 einen Browser mit einer eingebetteten Skriptsprache, die zu diesem Zeitpunkt LiveScript heißt und von Brendan Eich entwickelt wurde. Die Sprache kann u. a. Formulareingaben des Benutzers vor dem Absenden überprüfen.
Am 4. Dezember 1995 verkünden Netscape und Sun Microsystems eine Kooperation, die die Interaktion von LiveScript direkt mit Java-Applets zum Ziel hat. Sun entwickelt die nötigen Java-Klassen, Netscape die Schnittstelle LiveConnect und benennt die Sprache in JavaScript um (JavaScript 1.0).Brendan Eich: [http://web.archive.org/web/20070528020012/http://www.mozilla.org/js/language/ICFP-Keynote.ppt JavaScript at Ten Years], 2005, im Internet Archive. JavaScript ist eine Marke des Unternehmens Sun Microsystems, heute zu Oracle gehörend.[http://www.oracle.com/us/corporate/press/018363 Oracle Press Release: Oracle Buys Sun], 20. April 2009, abgerufen am 30. September 2011.[http://www.sun.com/suntrademarks/ {{Toter Link}} Sun Trademarks]
Mit der ersten Beta-Version des Navigator 3.0 führt am 29. April 1996 Netscape JavaScript 1.1 ein. Neu ist die Möglichkeit, auf Bilder zuzugreifen und so genannte Rollover-Grafiken zu erstellen. LiveConnect ist jetzt Bestandteil des Browsers.Mit der Beta-Version des Internet Explorer 3 stellt im Mai 1996 Microsoft seinen ersten JScript-fähigen Browser vor. Beginn des Browserkriegs.
Mit der Ankündigung des Netscape Communicators wird JavaScript 1.2 am 15. Oktober 1996 veröffentlicht, der Netscape Communicator 4.0 mit JavaScript 1.2 erscheint jedoch erst am 4. Juni 1997.
Ebenfalls im Juni 1997 veröffentlicht die European Computer Manufacturers Association ihren Standard ECMA-262 (ECMAScript), der zusammen mit Netscape entwickelt wurde und die Grundelemente einer Skriptsprache standardisieren soll. Diese wird im April 1998 zur ISO-Norm ISO/IEC 16262:1998 Information technology – ECMAScript language specification.
Am 1. Oktober 1997 kommt der Internet Explorer 4 heraus, der den Sprachumfang von JavaScript 1.1 abdeckt. Darüber hinaus werden eigene Erweiterungen veröffentlicht, die zu Kompatibilitätsunterschieden zwischen Navigator und Internet Explorer führen und eine DOM-ähnliche Syntax zur Verfügung stellen, die es ermöglicht, auf alle Elemente der Webseite zuzugreifen und diese beliebig zu verändern.
Der in Java implementierte JavaScript-Interpreter Rhino wird ab Version 6.0 als Teil der Java-Laufzeitumgebung standardmäßig mitgeliefert.[http://de.sun.com/company/press-releases/2006/pm_20061211.html {{Toter Link}} Pressemitteilung von Sun zum Erscheinen der JRE 6.0], 11. Dezember 2006.
Im Juli 1998 kommt mit der Beta-Version des Netscape Communicators 4.5 JavaScript 1.3. Erstmals zu finden war diese JavaScript-Version schon in der Version 4.06 des Netscape Communicators.
Im Oktober 1998 stellt Netscape JavaScript 1.4 vor. Diese Version ist vollständig kompatibel mit ECMA-262. Ein Browser mit der Unterstützung dieser Version erscheint jedoch nicht.
Im April 2000 kommt mit der Preview Release 1 des Navigator 6 JavaScript 1.5 und DOM Level 1.Am 5. Juni 2002 erscheint 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
{| class="wikitable"
|+Versionsgeschichte von JavaScript{{cite web|author=John Resig |url=http://ejohn.org/blog/versions-of-javascript |title=Versions of JavaScript |publisher=Ejohn.org |date= |accessdate=2009-05-19}}
|-
! Version !! Release !! 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}} || || 1.8 + geringfügige Updates || || 3.5 || || || ||
|-
| {{Version |c |1.8.5}} || || 1.8.1 + ECMAScript 5 Compliance || || 4 || 9.0 (JScript 9.0) || || ||
|}
Sicherheit
Das Sandbox-Prinzip
JavaScript wird im Browser in einer so genannten Sandbox ausgeführt. Dieses bewirkt, dass man in JavaScript im Allgemeinen nur Zugriff auf die Objekte des Browsers hat und somit nicht auf das Dateisystem zugreifen und dadurch keine Dateien lesen oder schreiben kann. Es ist jedoch zumindest in JScript möglich, bei entsprechenden Sicherheitseinstellungen durch die Nutzung von ActiveX diese Beschränkungen zu umgehen.
Zusätzlich wird jeder Webauftritt oder jede Webapplikation isoliert behandelt und ein Datenaustausch wird unterbunden. Das ist wichtig, um Sicherheitsprobleme zu verhindern. Ohne diese Isolierung wäre es beispielsweise möglich, dass eine böswillige Seite Bankdaten lesen könnte, wenn beide Webpräsenzen zur selben Zeit betrachtet werden.
Es bewirkt ferner, dass Aktionen wie das Schließen des Browserfensters, das Aus- und Einblenden von Symbolleisten, das Ändern der im Browser eingestellten Startseite, Zugriff auf die Zwischenablage oder das Auslesen der zuletzt besuchten Webseiten des Anwenders die explizite Erlaubnis des Benutzers erfordern.
Deaktivieren von JavaScript
In fast allen 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.
Sprachelemente
Datentypen
Der Datentyp einer Variablen v lässt sich mit typeof v ermitteln.
string, numerische Werte den Typ number und boolesche Werte den Typ boolean.Ein Sonderfall ist der Typ
undefined mit undefined als einzigem Wert.Funktionen sind Objekte, der typeof-Operator gibt als Typ aber
function zurück.Alle anderen Werte – reguläre Ausdrücke, Arrays und der Wert null inbegriffen – sind vom Typ object. Im Gegensatz zu anderen Programmiersprachen gibt es in JavaScript keine „echten“ assoziativen Arrays.http://de.selfhtml.org/javascript/objekte/array.htm#assoziative_arrays
Mit den vordefinierten Konstruktorfunktionen String(), Number() und Boolean() erstellte Variablen verhalten sich wie Werte der entsprechenden Datentypen – der typeof-Operator gibt jedoch object zurück:
var variable = "Beispieltext";
alert(typeof variable); // ergibt "string" (die Funktion "alert" gibt den ihr übergebenen Parameter in einem Fenster aus)
variable = new String("Beispieltext");alert(typeof variable); // ergibt "object"
Umgekehrt werden Variablen der primitiven Typen number, boolean und string bei Bedarf automatisch in Objekte der entsprechenden Konstruktorfunktion umgewandelt:
var variable = "Beispieltext";
alert(variable.length); // ergibt 12
JavaScript ist dynamisch typisiert, d. h. der Datentyp einer Variablen kann sich während der Ausführung eines Scripts ändern, was manchmal zu Fehlern bzw. unerwünschten Effekten führt.
Kontrollstrukturen
if-else (Bedingte Anweisung)
if (bedingung) {
anweisungen;
} else {
anweisungen;
}
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 nicht die interne Eigenschaft DontEnum aufweisen. DontEnum gilt für bestimmte eingebaute Eigenschaften und kann nicht vom Benutzer gesetzt werden.[https://developer.mozilla.org/En/ECMAScript_DontEnum_attribute MDC: ECMAScript DontEnum attribute] Bei jedem Schleifendurchgang wird einer angegebenen Variable der Eigenschaftsname zugewiesen.
for (var eigenschaftsname in objekt) {
anweisungen;
}
For Each … in-Schleife
Die For Each … in-Schleife gleicht der For … in-Schleife, mit dem Unterschied, dass die Eigenschaftswerte des Objekts durchlaufen werden und nicht deren Namen. Sie ist erst ab JavaScript 1.6 verfügbar. [https://developer.mozilla.org/en/JavaScript/Reference/Statements/for_each...in MDC: for each…in]
for each (var eigenschaftswert in objekt) {
anweisungen;
}
Geltungsbereich von Variablen
Variablen sind in JavaScript innerhalb der Funktion sichtbar, in der sie mit var deklariert wurden.
Außerhalb von Funktionen deklarierte Variablen sind Eigenschaften des globalen Objekts (window).
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:
var temp = function () {
var geheimnis = 42;
return function () {
return geheimnis;
};
} var geheimnisträger = temp(); //geheimnisträger ist die von temp() zurückgegebene Funktion
alert(typeof geheimnis ); // undefined
alert(geheimnisträger()); // 42
Nicht jedes Argument einer Funktion muss beim Aufruf angegeben werden, für fehlende Argumente wird der Wert undefined gesetzt. 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 erzeugensiehe auch: [http://kangax.github.com/nfe/ Named function expressions demystified]:
// 1: Funktionsdeklaration, a ist eine Funktion mit dem Namen a.
function a (Parameter1, Parameter2, Parameter3) {
anweisungen;
return ausdruck;
}
// 2: Funktionsausdruck ('function expression')// 2.1: Normalfall, b ist eine anonyme Funktion
var b = function (...) {...}
// 2.2: benannter Funktionsausdruck ('named function expression')// c ist hier eine Funktion mit dem Namen d. Außerhalb der
// Funktion ist sie mit c ansprechbar, innerhalb mit c und d.
var c = function d (...) {...}
// 3: Function-Konstruktorvar e = new Function('arg1', 'arg2', 'return arg1 + arg2');
// 4: 'expression closure' aus JavaScript 1.8, ähnlich dem Lambda-Kalkül// kommt ohne geschweifte Klammern und return aus, gibt das Ergebnis von Ausdruck zurück
function f (...) ausdruck;
Eine funktionale Implementierung des Euklidischen Algorithmus in der rekursiven Variante sähe so aus (JavaScript 1.8):
// einfache Version
function euklid (a, b) {
return b ? euklid(b, a%b) : a
}
// Version, die beliebig viele Argumente annimmt,// rekursiv, funktional
// Ablauf:
// (1) Erzeuge ein Array aus den Argumenten von ggT
// (2) Wenn ggT nur (noch) ein Argument hat, gib dieses zurück, wenn es keines hat, 0
// (3) sonst rufe euklid mit dem ersten Argument
// (4) und dem Ergebnis des Ergebnisses von ggT mit den Argumenten 2 bis n auf
function ggT () {
return (function (args) {
return !args[1]
? function () { return args[0] || 0 } // (2)
: function () { return euklid( // (3)
args[0],
ggT.apply(null, args.slice(1))() // (4)
)}
})(Array.prototype.slice.apply(arguments)) // (1)
}
ggT(4,6); // ergibt eine Funktion, die 2 zurückgibt// die zurückgegebene Funktion kann auch direkt ausgeführt werden:
ggT()(); // 0
ggT(4)(); // 4
ggT(4,6,8,102,244)(); // 2
Objekte
Jedes Objekt – auch durch Literale erzeugte Objekte – erbt vom Prototyp des globalen Object-Konstruktors.
Vordefinierte Objekte
JavaScript kennt mehrere eingebaute Objekte, die von ECMAScript definiert werden.
* Das namenlose globale Objekt, das alle Variablen und Objekte enthält.*
Object als allgemeiner Prototyp, von dem alle Objekte abgeleitet sind*
Function als Prototyp für Funktionen*
Array als Prototyp für Arrays*
String als Prototyp für Zeichenketten*
Boolean als Prototyp für Boolesche Variablen*
Number als Prototyp für Zahlen (64-Bit-Gleitkommazahlen gemäß IEEE 754)*
Math stellt Konstanten und Methoden für mathematische Operationen bereit. Math kann nicht als Konstruktor dienen.*
Date für Operationen mit Daten bzw. Zeitpunkten und Datumsformaten* RegExp für reguläre Ausdrücke
Die restlichen 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) werden wie folgt angesprochen:
Punkt-Notation:
objekt.eigenschaft;
objekt.methode([Parameter]);Klammer-Notation:
objekt["eigenschaft"];
objekt["methode"]();
// Eigenschaftsname, der in Punkt-Notation illegal wäre:objekt["methode 1"]();
Durch die Klammer-Notation lassen sich die Eigenschaften eines Objekts beispielsweise mit der „For … in“-Schleife durchlaufen.
Allen Objekten können zur Laufzeit neue Eigenschaften hinzugefügt werden:
objekt["eigenschaft-2"] = 1;
objekt.methodeB = function (x) {
return typeof objekt["eigenschaft-" + x];
};
Entfernen lassen sich Eigenschaften mit dem Operator delete:
delete objekt.eigenschaftA;
Objektliterale
Objekte können in JavaScript direkt anhand ihrer Eigenschaften definiert werden:
zahl: 42,
gibZahl: function () {
return meinObjekt.zahl;
}
};
alert(meinObjekt.gibZahl()); // 42
Eine spezielle Notation gibt es für reguläre Ausdrücke:
(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;
} var 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:
var neue_katze = function () {
var lebensZahl = 7;
var maunz = function () {
return (lebensZahl > 0) ? "miau" : "örks";
};
// gibt neues objekt zurückreturn {
toeten: function () {
lebensZahl -= 1;
alert(maunz());
}
};
};
var otto = neue_katze();
otto.toeten(); // miau
toeten-Methode von otto kennt die Variable lebensZahl.Der Effekt gleicht dem einer privaten Eigenschaft, wenn alle Methoden der Katze in der erzeugenden Funktion neue_katze 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 u.a. mit Hilfe Prototypen realisiert werden.Hierfür wird der prototype-Eigenschaft einer Konstruktor-Funktion ein Objekt zugewiesen wird, das z.B. durch den Aufruf einer anderen Konstruktorfunktion erzeugt werden kann. Wenn nun mit der Konstruktor-Funktion ein neues Objekt erzeugt wird, liefert dieses beim Zugriff auf eine nicht-existierende eigene Eigenschaft (wenn vorhanden) die entsprechende Eigenschaft des Prototypen zurück.
Beispiel:
var Fisch = function () {
this.augen = 2;
};
var Mutantenfisch = function () {this.augen = 3;
};
// Prototypenbasierende Vererbung
Mutantenfisch.prototype = new Fisch();
var blinky = new Mutantenfisch();
alert(blinky.augen); // 3 - eigene Eigenschaft von blinkydelete blinky.augen; // blinkys eigene Eigenschaft wird gelöscht
alert(blinky.augen); // 2 - blinky hat die Eigenschaft selbst nicht mehr, es schimmert die Eigenschaft des Prototypen durch
Um festzustellen, ob ein Objekt eine Eigenschaft selbst besitzt, oder vom Prototypen geerbt hat, hat jedes Objekt (automatisch durch Vererbung von Object) die hasOwnProperty-Methode:
blinky.hasOwnProperty('augen'); // false
Dialogmethoden / Benutzereingaben
Meistens erfolgt die Interaktion mit dem Benutzer über Änderungen an Inhalten des HTML-Dokuments, insbesondere über Formulare im Dokument, dabei greift JavaScript über das DOM (Document Object Model) auf die Elemente des HTML-Dokuments zu. Außerdem stehen drei Methoden des Window-Objektes bereit: alert(), confirm() und prompt(); mit jeder einzelnen dieser Methoden kann man den Benutzer auffällig ansprechen bzw. zu einer Eingabe auffordern. Dafür zeigt eine solche Methode ein modales Fenster an; modal bedeutet, der Benutzer muss dieses Fenster zunächst schließen, bevor er zum aufrufenden Dokument zurückkehren kann.
Zeigt einen Text in einem eigenen Meldungsfenster an. Beispiel:
window.alert("Hello World");
Zeigt einen Dialog mit den Schaltflächen „OK“ und „Abbrechen“ an. Zurückgegeben wird einer der booleschen Werte
true oder false, je nachdem welche Schaltfläche der Benutzer auswählt.var bestaetigt = window.confirm("Bitte bestätigen");
Es wird ein Dialog zur Texteingabe angezeigt. Beispiel:
var eingabe = window.prompt("Bitte geben Sie einen Text ein:", "");
In einem fertigen Script sind diese Methoden eher selten anzutreffen, während der Script-Entwicklung hingegen werden sie gerne benutzt, um Fehler auszumachen, um mit geringem Aufwand einen Variablenwert zu prüfen oder um festzustellen, ob eine bestimmte Stelle im Script überhaupt erreicht wird.
Fehlerbehandlung
Seit 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");
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.
JavaScript-Bibliotheken
Für die Erstellung von browserübergreifenden Webanwendungen mit Hilfe von JavaScript stehen JavaScript-Bibliotheken, sogenannte Toolkits bereit. Es handelt sich dabei um eine Sammlung von JavaScript-Funktionen, die den JavaScript-Programmierer in seiner Arbeit unterstützen sollen. Toolkits, die nicht nur häufig benutzte Standardfunktionen zur Verfügung stellen, sondern durch ein besonderes Maß an Abstraktion eine grundlegend andere Programmierung nach sich ziehen, werden auch Frameworks genannt.
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. 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 Dojo Toolkit, Ext JS, jQuery, MooTools, Prototype, Qooxdoo und die Yahoo! UI Library. Speziell mit grafischen Effekten beschäftigen sich Moo.fx und Script.aculo.us. Node.js ist gedacht für die Implementierung von Server-Prozessen mit Hilfe von JavaScript.
Einige JavaScript-Projekte implementieren eigeneoder bereits existente andere
Sprachen, um die Ausdrucksmöglichkeiten von Javascript zu erweitern, in anderen Sprachen geschriebene Skripte im Browser ausführen zu können, oder einfach zur Unterhaltung oder als Demonstration. Auch für JavaScript selbst existiert ein in JS geschriebener Interpreter, Narcissus.
Literatur
- Mark Lubkowitz: Webseiten programmieren und gestalten – HTML, CSS, JavaScript, PHP, Perl, MySQL, SVG. 2. Auflage, Galileo Press, Bonn 2005, ISBN 3-89842-557-6
* Ralph Steyer: JavaScript. Einstieg für Anspruchsvolle. Addison-Wesley, München 2006, ISBN 3-8273-2466-1
* David Flanagan: JavaScript – das umfassende Referenzwerk. 3. Auflage. O’Reilly, Köln 2007, ISBN 3-89721-491-1
* Michael Seeboerger-Weichselbaum: Das Einsteigerseminar JavaScript. 4. Auflage. bhv, Bonn 2007, ISBN 3-8266-7472-3
* Ralph Steyer: Das JavaScript Codebook. Addison-Wesley, München 2008, ISBN 3-8273-2717-2
* Douglas Crockford: Das Beste an JavaScript. O’Reilly, Köln 2008, ISBN 3-89721-876-3
* Christian Wenz: JavaScript und AJAX. Das umfassende Handbuch. 9. Auflage. Galileo Press, Bonn 2009, ISBN 3-89842-859-1
* Stefan Koch: JavaScript. Einführung, Programmierung, Referenz – inklusive Ajax. 5. Auflage. dpunkt-Verlag, Heidelberg 2009, ISBN 3-89864-594-0
Siehe auch
* Aktive Inhalte
* Bookmarklet – kleine JavaScript-Programme im Browser
* JavaScript Object Notation (JSON)
Weblinks
{{Wikibooks|Websiteentwicklung: JavaScript|Websiteentwicklung: JavaScript}}
* {{dmoz|World/Deutsch/Computer/Programmieren/Internet/JavaScript/}}
* {{Internetquelle
|url=http://chaosradio.ccc.de/cre146.html
|titel=JavaScript – Geschichte, Struktur, Eigenschaften und die Zukunft der wichtigsten Programmiersprache des Webs
|werk=Chaosradio Express
|datum=2010-02-13
|zugriff=2010-02-27
|format=MP3
|kommentar=97,5 MB
|zitat=
}}
Spezifikationen
* [http://standards.iso.org/ittf/PubliclyAvailableStandards/c033835_ISO_IEC_16262_2002(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) ([http://bclary.com/2004/11/07/ecma-262.html HTML-Version])
* [http://devedge-temp.mozilla.org/library/manuals/2000/javascript/1.3/reference/ Netscape JavaScript 1.3: Spezifikation von Mozilla] (Englisch)
* [https://developer.mozilla.org/en/JavaScript/Reference JavaScript: Spezifikation/Referenz von Mozilla] (Englisch)
** [https://developer.mozilla.org/en/JavaScript/New_in_JavaScript/ Übersicht über die Neuerungen in JavaScript von Mozilla] (Englisch)
Dokumentationen
* [http://de.selfhtml.org/javascript/ JavaScript-Kapitel bei SELFHTML]
* [http://openbook.galileocomputing.de/javascript_ajax/ JavaScript und AJAX] (Online-Fassung von Christian Wenz: JavaScript und AJAX. Das umfassende Handbuch. Galileo Press, Bonn 2006, ISBN 3-89842-859-1)
* [http://www.fh-wedel.de/~si/seminare/ws07/Ausarbeitung/11.javascript/ Objektorientierung in JavaScript]
* [http://eloquentjavascript.net/ Eloquent JavaScript] (Frei verfügbares E-Book, englisch)
Quellen
af:JavaScript
ar:جافا سكريبت
bat-smg:JavaScript
be:JavaScript
be-x-old:JavaScript
bg:JavaScript
bug:JavaScript
ca:JavaScript
cs:JavaScript
cv:JavaScript
da:JavaScript
el:JavaScript
JavaScript
eo:Ĝavaskripto
es:JavaScript
et:JavaScript
eu:JavaScript
fa:جاوااسکریپت
fi:JavaScript
JavaScript
gl:JavaScript
he:JavaScript
hi:जावास्क्रिप्ट
hr:JavaScript
hu:JavaScript
hy:ՋավաՍկրիպտ
ia:JavaScript
id:JavaScript
is:JavaScript
it:JavaScript
ja:JavaScript
jv:JavaScript
ka:ჯავასკრიპტი
kk:JavaScript
km:JavaScript
ko:자바스크립트
lt:JavaScript
lv:JavaScript
mk:JavaScript
ml:ജാവാസ്ക്രിപ്റ്റ്
mn:JavaScript
mr:जावास्क्रिप्ट
ms:JavaScript
mzn:جاوااسکریپت
nl:JavaScript
no:JavaScript
pl:JavaScript
pt:JavaScript
ro:JavaScript
ru:JavaScript
sah:JavaScript
si:ජාවා උපදේශාවලිය
simple:JavaScript
sk:JavaScript
sl:JavaScript
sq:JavaScript
sr:Јаваскрипт
sv:Javascript
ta:யாவாசிகிரிப்டு
tg:JavaScript
th:จาวาสคริปต์
tk:JavaScript
tr:JavaScript
uk:JavaScript
vi:JavaScript
zh:JavaScript
zh-yue:JavaScript
Text und Bilder dieses Beitrags stammen aus dem Artikel JavaScript der freien Enzyklopädie Wikipedia und stehen unter der GNU Free Documentation License. Die Liste der Autoren ist in der Wikipedia unter dieser Seite verfügbar, der Original-Artikel lässt sich hier bearbeiten.
