JavaScript
JavaScript (kurz JS) ist eine Skriptsprache, die ursprünglich 1995 von Netscape für dynamisches HTML in Webbrowsern entwickelt wurde, um Benutzerinteraktionen auszuwerten, Inhalte zu verändern, nachzuladen oder zu generieren und so die Möglichkeiten von HTML zu erweitern.[2] Heute wird JavaScript auch außerhalb von Browsern angewendet, etwa auf Servern und in Microcontrollern.[3][4] Der heutige Name der ursprünglich LiveScript genannten Sprache entstand 1996 aus einer Kooperation von Netscape mit Sun Microsystems. Deren Java-Applets, erstellt mit der gleichfalls 1995 veröffentlichten Programmiersprache Java, wurden mithilfe von LiveScript in den Netscape Navigator integriert. Um die Popularität von Java zu nutzen, wurde LiveScript in JavaScript umbenannt, obwohl die beiden Sprachen voneinander unabhängig entwickelt wurden und völlig unterschiedliche Grundkonzepte aufweisen. Der als ECMAScript (ECMA 262) standardisierte Sprachkern von JavaScript beschreibt eine dynamisch typisierte, objektorientierte, aber klassenlose Skriptsprache. Sie wird allen objektorientierten Programmierparadigmen unter anderem auf der Basis von Prototypen gerecht, deren Deklaration ab ECMAScript 6 mit einer Syntax ermöglicht wird, wie sie ähnlich auch bei klassenbasierten Programmiersprachen üblich ist. In JavaScript lässt sich je nach Bedarf objektorientiert, prozedural oder funktional programmieren.[5] EntwicklungDie Syntax von JavaScript ähnelt C-Abkömmlingen. Trotz der Namens- und syntaktischen Ähnlichkeit hat JavaScript nur geringe Gemeinsamkeiten mit Java. So wird in JavaScript Vererbung nicht durch Klassen, sondern durch Prototypen unterstützt. JavaScript wurde früher hauptsächlich clientseitig eingesetzt. JavaScript bzw. die ECMAScript-Implementierungen ermöglichen aber beispielsweise mit dem Framework Node.js[6] und als JScript bzw. JScript .NET in einer ASP- bzw. ASP.NET-Umgebung auf Microsoft Internet Information Services auch serverseitige Anwendungen. Weitere Beispiele für serverseitige JavaScript-Programmierung sind POW und Jaxer, die auf der Mozilla-JavaScript-Engine SpiderMonkey aufsetzen, V8CGI, welches auf der JavaScript-Implementierung V8 aufbaut und in den Apache HTTP Server integriert wird, sowie QML, eine erweiterte Form von JavaScript zum Zeichnen von Oberflächen und Animationen. Die Sprache wird auch als Skriptsprache für Spiele und Anwendungsprogramme eingesetzt, da der Sprachkern nur wenige Objekte enthält und dadurch der zur Ausführung von in JavaScript formulierten Skripten erforderliche Interpreter relativ klein gehalten werden kann. Außerdem wird JavaScript als Verkehrssprache in der Datenbank MongoDB sowie in Microcontrollern eingesetzt.[3][4] VerwendungTypische AnwendungsgebieteTypische Anwendungsgebiete von JavaScript im Webbrowser sind:
MissbrauchEinige Anwendungen, die mit JavaScript möglich sind, agieren teilweise gegen den Wunsch des Benutzers oder widersprechen dem Prinzip der geringsten Überraschung. Einige Browser bieten daher Funktionen an, die derartige JavaScript-Funktionen unterdrücken. Beispiele: ![]()
GeschichteAm 18. September 1995 veröffentlichte Netscape mit der Vorversion des Navigators 2.0 einen Browser mit einer eingebetteten Skriptsprache, die zu diesem Zeitpunkt LiveScript hieß und von Brendan Eich entwickelt worden war. Die Sprache konnte u. a. Formulareingaben des Benutzers vor dem Absenden überprüfen. Am 4. Dezember 1995 verkündeten Netscape und Sun Microsystems eine Kooperation, die die Interaktion von LiveScript direkt mit Java-Applets zum Ziel hatte. Sun entwickelte die nötigen Java-Klassen, Netscape die Schnittstelle LiveConnect und benannte die Sprache in JavaScript um (JavaScript 1.0).[7][8] JavaScript ist seit der Übernahme von Sun Microsystems eine Marke des Unternehmens Oracle.[9] Mit der ersten Beta-Version des Navigators 3.0 führte Netscape am 29. April 1996 JavaScript 1.1 ein. In selbiger Version gab es die Neuerungen, auf Bilder zugreifen und sogenannte Rollover-Grafiken erstellen zu können. LiveConnect war jetzt fester Bestandteil des Browsers. Mit der Beta-Version des Internet Explorers 3 stellte Microsoft im Mai 1996 seinen ersten JScript-fähigen Browser vor. Dies war der Beginn des Browserkriegs.[10][11] Mit der Ankündigung des Netscape Communicators wurde JavaScript 1.2 am 15. Oktober 1996 veröffentlicht; der Netscape Communicator 4.0 mit JavaScript 1.2 erschien jedoch erst am 4. Juni 1997. Ebenfalls im Juni 1997 veröffentlichte die European Computer Manufacturers Association ihren Standard ECMA-262 (ECMAScript), der zusammen mit Netscape entwickelt worden war und die Grundelemente einer Skriptsprache standardisieren sollte. Diese wurde im April 1998 zur ISO-Norm ISO/IEC 16262:1998 Information technology – ECMAScript language specification. Am 1. Oktober 1997 kam der Internet Explorer 4 heraus, der den Sprachumfang von JavaScript 1.1 abdeckte. Darüber hinaus wurden eigene Erweiterungen veröffentlicht, die zu Kompatibilitätsunterschieden zwischen Navigator und Internet Explorer führten und eine DOM-ähnliche Syntax zur Verfügung stellten, die es ermöglichte, auf alle Elemente der Webseite zuzugreifen und diese beliebig verändern zu können. Der in Java implementierte JavaScript-Interpreter Rhino wurde ab Version 6.0 als Teil der Java-Laufzeitumgebung standardmäßig mitgeliefert.[12] 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.[13] 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.[14][15] 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),[16] am 29. November 2005 Mozilla Firefox 1.5 mit JavaScript 1.6[17], am 12. Juli 2006 Mozilla Firefox 2.0b1 mit JavaScript 1.7[18] und am 18. Dezember 2007 Mozilla Firefox 3.0b2 mit JavaScript 1.8.[19] Versionsgeschichte von JavaScript
Versionsgeschichte von ECMAScript (ECMA-262)Die aktuelle Version ist die Version 2022, die im Juni 2022 als „ECMAScript 2022“ veröffentlicht wurde.[21] Dieser sollen jährliche Updates folgen.[22] Die Entwicklung der Standards erfolgt auf GitHub.[23]
SicherheitSandbox-PrinzipJavaScript 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 Um Sicherheitsprobleme wie das sogenannte Cross-Site-Scripting zu verhindern, wird jede Website oder Webanwendung innerhalb des Browsers isoliert ausgeführt und ein Datenaustausch unterbunden. Ohne diesen Schutz wäre es möglich, über eine Seite Schadcode auszuführen, der beispielsweise Bank- oder Logindaten in anderen parallel geöffneten Browserfenstern ausliest oder manipuliert. Auch bestimmte sicherheitsrelevante Browserfunktionen wie das Schließen des Browserfensters, das Aus- und Einblenden von Symbolleisten, das Ändern der Browserstartseite, der Zugriff auf die Zwischenablage oder das Auslesen der zuletzt besuchten Webseiten des Anwenders werden durch obligatorische Nutzereingaben geschützt. Standardmäßig wird ein Skript innerhalb eines Browsers in Form eines einzigen Threads ausgeführt. Warteschleifen oder lange Berechnungen sind daher in JavaScript-Programmen zu vermeiden. Mit Deaktivieren von JavaScriptIn vielen JavaScript-fähigen Browsern lässt sich JavaScript abschalten oder lassen sich einzelne Aktionen wie die Änderung des Textes in der Statusleiste oder die Manipulation von Browserfenstern deaktivieren. Dies kann bei einigen Browsern mittels Erweiterungen, die JavaScript anhand von White- und Blacklists gezielt auf Seiten ein- und ausschalten, auch automatisiert werden. Daher können sich Entwickler nicht darauf verlassen, dass JavaScript-Programme sich in jeder Umgebung gleich verhalten bzw. überhaupt funktionieren. SprachelementeDatentypenJavaScript ist dynamisch typisiert. Das bedeutet, dass die Zuweisung von Werten an Variablen keinen typbasierten Einschränkungen unterliegt. Allerdings gibt es diverse Erweiterungen von JavaScript, die eine statische Typisierung optional beziehungsweise zwingend erfordern, zum Beispiel TypeScript von Microsoft.[44] Aufgrund der dynamischen Typisierung ist der Datentyp keine Eigenschaft einer Variablen, sondern Laufzeit-bezogen die Eigenschaft ihres aktuellen Wertes (oder auch die Eigenschaft eines Literals). Der Datentyp eines Wertes lässt sich mit dem unären Operator Primitive DatentypenZu den primitiven Datentypen in JavaScript gehören Zahlen, Zeichenketten, boolesche Werte, Symbole, null und undefined.
Nicht primitive DatentypenFunktionen sind kein primitiver Typ ( Objekte, die durch die vordefinierten Konstruktorfunktionen 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"
Umgekehrt werden Werte der primitiven Typen Number, Boolean und String bei Bedarf automatisch in Objekte der entsprechenden Konstruktorfunktion umgewandelt: let simpleString = "Beispieltext";
alert(simpleString.length); // ergibt 12
In diesem Beispiel wird die Eigenschaft KontrollstrukturenJavaScript kennt die üblichen Kontrollstrukturen. Sollen diese mehr als eine Anweisung enthalten, so muss ein in geschweifte Klammern eingeschlossener Block eingesetzt werden. Anweisungen werden mit einem Semikolon abgeschlossen. Dies ist aber in den meisten Fällen optional; durch die automatic semicolon insertion wird es meist automatisch ergänzt. if-else (Bedingte Anweisung)if (bedingung) {
anweisungen;
} else {
anweisungen;
}
Kurzschreibweise für bedingte Wertzuweisungen: variable = bedingung ? wertWennWahr : wertWennFalsch;
switch-Kontrollstrukturswitch (variable) {
case wert1:
anweisungen;
break;
case wert2:
anweisungen;
break;
default:
anweisungen;
}
while (bedingung) {
anweisungen;
}
do {
anweisungen;
} while (bedingung);
for (startausdruck; bedingung; iterationsausdruck) {
anweisungen;
}
for … in-Schleife Mit dieser Anweisung werden alle eigenen und ererbten Eigenschaften eines Objektes durchlaufen, die das interne Attribut Enumerable aufweisen.[46] Dieses Attribut wurde in ECMA Script 5 eingeführt und ist für bestimmte eingebaute Eigenschaften (wie z. B. die Funktion toString des Prototyps Object) nicht gesetzt, es kann allerdings im Regelfall vom Benutzer gesetzt (und entfernt) werden.[47] Bei jedem Schleifendurchgang wird einer angegebenen Variable der Eigenschaftsname zugewiesen. for (let eigenschaftsname in objekt) {
anweisungen;
}
for … of-Schleife Diese Kontrollstruktur funktioniert wie eine for … in-Schleife, mit dem Unterschied, dass hier der angegebenen Variable nicht der Eigenschaftsname, sondern der Eigenschaftswert zugewiesen wird.[48] for (let wert of objekt) {
anweisungen;
}
VariablenVariablen sollten in JavaScript mit Geltungsbereich von VariablenIn JavaScript gibt es globale und lokale Variablen abhängig davon, wo sie deklariert werden und wie sie verwendet werden.
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. let explicit; // Explizite Deklaration einer globalen Variable
explicit = "explizit deklariert"; // Definition einer globalen Variable
console.log(explicit); // Ausgabe: explizit deklariert
Implizit deklarierte Variablen sind immer global. Auch wenn eine Variable innerhalb einer Funktion implizit ohne function foo() {
implicit = "implizit deklariert"; // Definition einer globalen Variable
}
foo();
console.log(implicit); // Ausgabe: implizit deklariert
Eine implizit deklarierte Variable wird automatisch zu einer Eigenschaft des console.log(globalThis.implicit); // Ausgabe: implizit deklariert
console.log(typeof globalThis.explicit); // Ausgabe: undefined
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. 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
KonstantenKonstanten sollen mit FunktionenIn 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, auch Funktionsabschluss genannt, die beispielsweise Datenkapselung ermöglicht: 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
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 ErzeugungEs gibt mehrere Möglichkeiten, in JavaScript Funktionen zu erzeugen:[51]
function f(x, y) {
return x + y;
}
let f = function(x, y) {
return x + y;
};
Anonyme Funktionen können auch direkt ausgeführt werden, ohne sie vorher einer Variable zuzuweisen. Das kann zur Kapselung des Gültigkeitsbereichs von Variablen verwendet werden. (function(x, y) {
return x + y;
})(2, 3);
Der Variablen let f = function g(x, y) {
return x + y;
};
let f = new Function('x', 'y', 'return x + y;');
Die runden Klammern sind optional, falls die Funktion genau ein Argument hat. Werden die geschweiften Klammern weggelassen, muss man genau einen Ausdruck ohne (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;
BeispielEine funktionale und rekursive Implementierung des Euklidischen Algorithmus mit zwei Argumenten sieht folgendermaßen aus: function euklid(a, b) {
if (b === 0)
return a;
return euklid(b, a % b);
}
Implementierung des Euklidischen Algorithmus mit beliebig vielen Argumenten durch Reduzierung von 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
Implementierung des Euklidischen Algorithmus mit partieller Anwendung: 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
ObjekteObjekte 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 ObjekteJavaScript kennt mehrere eingebaute Objekte und Objekttypen, die im Standard ECMAScript definiert sind. Dabei wird ein Objekttyp durch eine namensgleiche Konstruktorfunktionen repräsentiert, die zur Erzeugung von Objekten des entsprechenden Typs verwendet werden kann und zugleich einen Verweis auf den Prototyp des Objekttyps beinhaltet.
Weitere Objekte, die beim clientseitigen JavaScript verwendet werden, entstanden historisch vor allem durch die Netscape-Spezifikationen ( Zugriff auf Objekteigenschaften und -methodenEigenschaften von Objekten (auch Methoden sind Eigenschaften) können wie folgt angesprochen werden:
objekt.eigenschaft;
objekt.methode(parameter1, parameter2);
objekt["eigenschaft"];
objekt["methode"](parameter1, parameter2);
// Eigenschaftsname, der in Punktnotation illegal wäre
objekt["methode 1"]();
// So können auch alle Eigenschaften des Objekts durchlaufen werden
for (let eigenschaftsName in objekt) {
console.log(eigenschaftsName, " = ", objekt[eigenschaftsName]);
}
Zu allen Objekten können zur Laufzeit neue Eigenschaften hinzugefügt oder mit // 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"];
ObjektliteraleObjekte können in JavaScript direkt anhand ihrer Eigenschaften definiert werden: let meinObjekt = {
zahl: 42,
gibZahl: function() {
return this.zahl;
}
};
alert(meinObjekt.gibZahl()); // 42
Eine spezielle Notation gibt es für reguläre Ausdrücke: // mit Konstruktorfunktion
(new RegExp("a")).test("ab"); // true
// als Literal
/a/.test("ab"); // true
Konstruktor-FunktionenEine Funktion kann dazu genutzt werden, um ein mit function MeinObjekt(x) { // Konstruktor
this.zahl = x;
}
let objekt = new MeinObjekt(3); // Instanz erzeugen
alert(objekt.zahl); // per Meldefenster ausgeben (3)
„Private“ EigenschaftenPrivate Eigenschaften und Methoden sind nicht explizit Teil der Sprache. Mit Hilfe von Closures (siehe Funktionen) lassen sich dennoch private Eigenschaften von Objekten realisieren: let erschaffeKatze = function() {
let lebensZahl = 7;
let maunz = function() {
return (lebensZahl > 0) ? "miau" : "örks";
};
// gibt neues Objekt zurück
return {
toeten: function() {
lebensZahl -= 1;
alert(maunz());
}
};
};
let otto = erschaffeKatze();
otto.toeten(); // miau
Lediglich die Vererbung über PrototypenVererbung kann in JavaScript durch Prototypen realisiert werden. Dies erfordert, dass der prototype-Eigenschaft einer Konstruktor-Funktion ein als Prototyp dienendes Objekt zugewiesen wird. Wenn mit der Konstruktor-Funktion nun ein Objekt erzeugt wird, wird beim Zugriff auf eine nicht-existierende Eigenschaft des neuen Objekts die entsprechende Eigenschaft des Prototyps (wenn vorhanden) zurückgegeben. Beispiel: let fisch = {
augen: 2
};
let Mutantenfisch = function() {
this.augen = 3;
};
Mutantenfisch.prototype = fisch;
let blinky = new Mutantenfisch();
// eigene Eigenschaft von blinky
alert(blinky.augen); // 3
// blinkys eigene Eigenschaft wird gelöscht
delete blinky.augen;
// blinky hat die Eigenschaft selbst nicht mehr,
// es schimmert die Eigenschaft des Prototyps durch
alert(blinky.augen); // 2
Um festzustellen, ob ein Objekt eine Eigenschaft selbst besitzt oder vom Prototyp geerbt hat, hat jedes Objekt (automatisch durch Vererbung von Object) die hasOwnProperty-Methode: blinky.hasOwnProperty('augen'); // false
Fixierung von Objektstruktur und -inhaltenDie in JavaScript im Regelfall völlig dynamische Struktur eines Objekts Es ist auch möglich, nur ein einzelnes Attribut eines Objekts
das Attribut DelegationsprinzipienJavaScript ist eine Delegationssprache mit sowohl selbstausführendem als auch direktem Delegationsmechanismus.
FehlerbehandlungAb Version 3 verfügt ECMAScript über eine von Java übernommene Fehlerbehandlung. Die Anweisung try {
// Anweisungen, in denen Ausnahmen auftreten oder ausgelöst werden können
} catch (exception) {
// Anweisungsfolge, die im Ausnahmefall ausgeführt wird.
// In diesem Teil kann die Fehlerbehandlung erfolgen.
} finally {
// Anweisungsfolge, die anschließend in jedem Fall ausgeführt wird.
}
throw "sample exception"; // wenn verfügbar, besser: Error-Objekt (siehe unten)
Zu Beginn werden die Anweisungen im Im Normalfall wird der Ausnahmeblock übersprungen. Nach der Ausführung des Einige Laufzeitumgebungen wie V8 (und somit Node.js) und auch viele Webbrowser stellen gesonderte Error-Objekte zur Verfügung, die neben der Fehlermeldung auch einen Stacktrace und weitere Zusatzinformationen transportieren können.[58][59][60]
Um diese Vorteile zu nutzen, ändert man im einfachsten Anwendungsfall den Klammern um den Parameter des JavaScript-BibliothekenUm die Erstellung von Webanwendungen mit Hilfe von JavaScript zu erleichtern, gibt es diverse Bibliotheken und Frameworks. Eine Bibliothek ist eine Sammlung von Funktionen, die der Programmierer nutzen kann. Ein Framework fordert darüber hinaus durch ein besonderes Maß an Abstraktion eine bestimmte Struktur der Programmierung. Ausgelöst von neuen Konzepten wie Ajax entstand seit 2004 ein neues Interesse für JavaScript. JavaScript wird zunehmend für Rich-Client-Anwendungen benutzt, die das Aussehen und die Bedienung von herkömmlichen Desktop-Programmen auf Web-gestützte Anwendungen übertragen. JavaScript spielt dabei eine Schlüsselrolle, wenn es darum geht, Statusinformationen ohne Laden einer vollständigen Seite zwischen Browser und HTTP-Server zu übertragen. Im Zuge dieser neuen Anforderungen entstanden verschiedene Bibliotheken, die die Entwicklung solcher Anwendungen vereinfachen wollen. Neben Ajax-Funktionalitäten bieten die meisten dieser Bibliotheken eine eigene Basis für objektorientierte Programmierung, eine Abstraktionsschicht für das komfortable Arbeiten mit dem DOM sowie grafische Effekte wie Animationen. Aber auch schon vor dem breiten Einsatz von Ajax existierten Funktionssammlungen zur Unterstützung der browserübergreifenden Programmierung.[62] Zu den bekannten JavaScript-Bibliotheken und Frameworks zählen AngularJS, Dojo Toolkit, Ext JS, jQuery, MooTools, Prototype, Qooxdoo, React, Vue.js und die Yahoo User Interface Library. Speziell mit grafischen Effekten beschäftigen sich Moo.fx und Script.aculo.us. Für die serverseitige Programmierung mittels Node.js stehen eigene Bibliotheken und Frameworks bereit. Einige Bibliotheken und insbesondere Frameworks erweitern die Sprache um zusätzliche Funktionen, die häufig in spätere Versionen der Spezifikation einfließen oder rüsten bei Bedarf ältere Implementierung per Polyfill nach. JavaScript & Suchmaschinenoptimierung (SEO)Suchmaschinen gehen unterschiedlich mit der Verarbeitung von Javascript-Inhalten um, wodurch es in den letzten Jahren immer wieder zu Fällen gekommen ist, dass Websites teilweise oder gänzlich nicht in Suchmaschinen auffindbar waren. Der Suchmaschinenbetreiber Google kann laut eigenen Aussagen JavaScript-Inhalte crawlen, rendern und indexieren.[63] Neben allgemeinen Empfehlungen wie z. B. die Verwendung von aussagekräftigen Titeln, eindeutigen Statuscodes und den sorgsamen Umgang mit Noindex-Direktiven gibt es im Hinblick auf JavaScript noch spezifischere Empfehlungen, welche helfen können, dass JavaScript-Webanwendungen optimal via Suchmaschinenoptimierung aufgefunden werden können. Dazu zählen serverseitiges Pre-Rendering oder der Verzicht von Fragmenten bei Links. Für das Debugging von JavaScript & SEO gibt es eine Reihe von offiziellen Empfehlungen seitens Google, um nachprüfen zu können, wie der Googlebot Webinhalte erfasst.[64] Siehe auch
Literatur
WeblinksCommons: JavaScript – Sammlung von Bildern, Videos und Audiodateien
Wikibooks: Websiteentwicklung: JavaScript – Lern- und Lehrmaterialien
Wiktionary: JavaScript – Bedeutungserklärungen, Wortherkunft, Synonyme, Übersetzungen
Spezifikationen
Dokumentationen
Einzelnachweise
|
Portal di Ensiklopedia Dunia