template
Javascript besitzt zwar die C-ähnliche Syntax von Java, hat aber ansonsten mit Java wenig gemein und ist vielmehr eine eigenständige und auch ausdrucksstarke Sprache, die sich hervorragend als Entwicklungsplattform für client-seitige Webapplikationen eignet.
Javascript enthält nur wenige Datentypen. Es gibt die einfachen Typen boolean, number und string, sowie die speziellen Werte null and undefined. Alles andere sind Variationen des object-Typs.
| boolean |
hat entweder den Wert true oder false. |
| number |
ist ein 64-Bit Fließkommawert, vergleichbar mit dem double in Java.
Es gibt keinen expliziten Integer-Typ.
Die Division zwischen zwei Integern kann zu einem Ergebnis mit Nachkommastellen führen.
Eine Zahl kann auch einen der speziellen Werte NaN (not a number) oder Infinity annehmen. |
| string |
ist eine Sequenz von 0 oder mehr Unicode-Zeichen.
Es gibt keinen expliziten Character-Typ (wie etwa char in C).
Ein Zeichen wird durch einen String der Länge 1 repräsentiert.
Textliterale werden in Anführungszeichen (einfaches ' oder doppeltes " Hochkomma) gesetzt. Beide Anführungszeichen sind untereinander austauschbar, müssen aber paarweise passen.
Fluchtzeichen werden - wie in C oder Java - in Verbindung mit dem Backslash \ gebildet.
Strings haben eine length-Eigenschaft, die benutzt wird, um die Anzahl der Zeichen im String zu bestimmen. |
| null |
entspricht dem Null-Pointer in C.
Wird für nicht initialisierte Objektvariablen verwendet. |
| undefined |
Standardwert für unbekannte oder nicht initialisierte Variablen. |
Es ist möglich, einfachen Typen eigene Methoden hinzuzufügen.
Augenscheinlich werden noch andere Typen zur Verfügung gestellt, z.B. Date oder Regular Expressions, aber jene sind in Wirklichkeit nur Objekte.
Objekte sind (sowohl intern als auch in ihrer Gesamtheit) wie ein assoziatives Array als Hashtabelle organisiert. Dadurch gestaltet sich die Manipulation erfreulich einfach.
Bei näherer Betrachtung ist ein Objekt ein referenzierbarer Container von Name/Wert-Paaren. Die Namen sind Strings (oder andere Elemente wie Zahlen, die zu Strings konvertiert sind), während die Werte einen beliebigen Datentyp besitzen; d.h. auch Funktionen oder Objekte sein können.
Diese Anweisung erzeugt ein neues Objekt (letztlich eine leere Hashtabelle) und weist es einer lokalen Variablen zu (da Javascript so schwach typisiert ist, gibt man in Deklarationen keine Typenbezeichnungen an):
var myHash = new Object();
Oder in der kurzen, literalen Variante mit geschweiften Klammern:
var myHash = {};
Nun können wir Elemente hinzufügen (hier in Form der Schlüsselnotation), ersetzen oder auslesen:
myHash["name"] = "Donald Duck";
Dazu lässt sich auch die Punktnotation benutzen, was oft bequemer ist:
myHash.city = "Entenhausen";
Die Punktnotation kann verwendet werden, wenn der Elementname einen gültigen Bezeichner darstellt. Aufgrund eines Fehlers in der Sprachdefinition dürfen reservierte Wörter nicht für die Punktnotation benutzt werden; sie sind jedoch bei der Schlüsselnotation erlaubt.
Tatsächlich ist die Schlüsselnotation ungemein flexibel, weil sie auf Stringkonstanten basiert.
Folgendes Beispiel, bei dem durchweg valide Elemente erzeugt werden, verdeutlicht dies:
var o = {};
o['!$%/?'] = "Murks";
o['e=mc²'] = "Einstein";
o[' '] = "Blank";
o[''] = "Leerstring";
Natürlich können obige Elemente dann nicht mittels Punktnotation angesprochen werden, weil ihre Schlüssel keine gültige Bezeichner sind. Der Zugriff per Schlüsselnotation ist jedoch nach wie vor möglich.
Die Prinzipien der Schlüsselnotation gelten im Übrigen auch für IDs von HTML-Elementen:
<div id='!$%/?'>...</div>
<div id='e=mc²'>...</div>
<div id=' '>...</div>
Die Vergabe einer ID '' (Leerstring) ist zwar ebenfalls möglich, aber - weil dies ohnehin der Standardwert eines jeden HTML-Elements ist - nicht besonders sinnvoll.
Objekte sind oft in anderen Objekten eingebettet und werden durch entsprechende Namensverkettung angesprochen:
this.div = document.body.children[document.body.children.length - 1];
Bei der literalen Objektnotation erfolgt die Elementbeschreibung in geschweiften Klammern als kommagetrennte Liste von Name/Wert-Paaren.
Die Namen können Bezeichner oder Strings sein, gefolgt von einem Doppelpunkt. Aufgrund eines Fehlers in der Sprachdefinition dürfen reservierte Wörter hier nicht als Bezeichner benutzt werden; sie sind jedoch als Strings erlaubt.
Die Werte können Literale oder beliebige Ausdrücke sein.
var myObject = { name: "Kater Karlo", 'goto': 'Jail', grade: 'A', level: 3 };
Mittels literaler Objektnotation lassen sich auch anonyme Objekte (mit einer unbenannten Struktur vergleichbar) herstellen:
return {
event: event,
op: event.type,
to: event.srcElement,
x: event.clientX + document.body.scrollLeft,
y: event.clientY + document.body.scrollTop };
In der for-Anweisung ist ein Enumerationsmechanismus (Durchzählung) eingebaut:
for (var e in myHash) {
document.writeln("<p>"+ e +": "+ myHash[e] +"</p>");
}
Das Resultat der Schleife wäre in unserem Fall folgende Ausgabe:
<p>name: Donald Duck</p>
<p>city: Entenhausen</p>
Arrays in Javascript sind Hashtabellen-Objekte mit einer Reihe von vorgefertigten Eigenschaften und Methoden, was sie für die Verwaltung von Listen und Aufzählungen prädestiniert.
Wenn man ein Array konstruiert, muss man keine Größe angeben. Arrays wachsen automatisch, vergleichbar mit Collections oder Java-vectors. Die Werte werden durch einen Schlüssel (Stringkonstante) lokalisiert, nicht durch einen Offset (eine angegebene Zahl wird implizit in einen String gewandelt).
Der Hauptunterschied zwischen Objekten und Arrays ist ihre length-Eigenschaft. Der Wert von length ist immer um 1 größer als der höchste Integerschlüssel im Array.
Standardgemäß werden Arrays so erzeugt:
var myArray = new Array();
Oder in der kurzen, literalen Variante mit eckigen Klammern:
var myArray = [];
Arrays sind nicht typisiert. Sie können Zahlen, Strings, bool'sche Werte, Objekte, Funktionen oder auch andere Arrays enthalten. Dabei dürfen die Datentypen beliebig gemischt sein.
Der erste Index im Array ist immer 0.
Wenn ein neues Element hinzugefügt wird, und der Schlüssel ist ein Integer X, der größer ist, als der aktuelle Wert von length, dann wird length automatisch auf X+1 gesetzt. Dies macht es einfach, mittels for- oder while-Schleife durch die Elemente eines Arrays zu wandern.
var i = myArray.length;
while (i--) alert(myArray[i]);
Ein neues Element kann entweder durch direkte Zuweisung aufgenommen werden,
myArray[10 + j] = "blabla";
oder durch die push-Methode.
myArray.push("blabla");
myArray.push("alpha", "beta", "gamma");
Ähnlich wie bei Objekten gibt es auch bei Arrays eine literale Notation, allerdings werden hier keine Bezeichner angegeben, sondern nur die Werte:
var Zutaten = ['Butter', 'Käse', 'Eier', 'Zimt'];
var month_lengths = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
var slides = [
{ url: 'slide01.html', title: 'Einleitung' },
{ url: 'slide08.html', title: 'Wege der Erleuchtung' },
{ url: 'slide23.html', title: 'Resumee' }
];
Mittels literaler Arraynotation lassen sich auch anonyme Arrays (mit einer unbenannten Liste vergleichbar) herstellen:
Funktionsergebnis als Liste
return [
"Mickey Mouse",
"Entenhausen",
1930,
"Hobbydetektiv"];
Lokale/temporäre Liste
alert([2, 4, 1, 3].sort()); // Anzeige: '1,2,3,4'
Arrays besitzen eine Methode zur Sortierung ihrer Elemente:
array.sort ( [comparefunction] )
Per Default werden die Elemente alphabetisch geordnet, was jedoch für numerische Werte ungeeignet ist, weil z.B. 1000 alphabetisch kleiner ist als 7. Deshalb kann optional eine benutzerdefinierte Vergleichsfunktion comparefunction angegeben werden, die dann während des Sortiervorgangs benutzt wird.
Die Vergleichsfunktion muss 2 Parameter zum Empfang der zu prüfenden Elemente bereitstellen.
function comparefunction ( para1 , para2 )
Nach dem Vergleich der Argumente muss sie dann je nach Ergebnis entweder 0, einen negativen oder einen positiven Wert zurückliefern:
| Vergleichsergebnis | Funktionswert |
| Para1 < Para2 | <0 (negativ) |
| Para1 == Para2 | 0 |
| Para1 > Para2 | >0 (positiv) |
Hier wird eine entsprechende numerische Vergleichsfunktion cmpNum() definiert und anschließend zur Sortierung eines Zahlenarrays volumes verwendet:
function cmpNum(a, b) { return a - b; }
volumes.sort(cmpNum);
In der Praxis wird die Funktion oft inline notiert:
volumes.sort(function cmpNum(a, b) { return a - b; });
Ist die Vergleichsfunktion temporär (d.h. sie wird nur an dieser Stelle benötigt), kann man sie auch anonym angeben:
volumes.sort(function (a, b) { return a - b; });
Insbesondere zur Sortierung von Objektarrays sind benutzerdefinierte Funktionen unerlässlich, denn die Objekte sollen ja nach dieser oder jener Eigenschaft sortiert werden können.
Im Folgenden wird zunächst eine Klasse User definiert. Zur Demo werden 4 Benutzer erzeugt und im Array Userlist abgelegt. Dann folgen verschiedene Beispiele, wie man das Array (hier mittels anonymer Funktionen) sortieren könnte:
User = function(name, age, accounts) {
this.Name = function() { return name; } // Name
this.Age = function() { return age; } // Alter
this.Accounts = function() { return accounts; } // Accountliste
}
Userlist = [
new User('Berta', 32, ['Guest']),
new User('Doris', 28, ['Admin', 'Sys', 'Tech', 'Guest']),
new User('Alfons', 41, ['Tech', 'Guest']),
new User('Charles', 37, [])];
Nach Name sortieren
Userlist.sort(function(a, b) {
return a.Name < b.Name? -1: b.Name > a.Name;
});
Nach Alter sortieren
Userlist.sort(function(a, b) {
return a.Age - b.Age;
});
Nach Accountanzahl (absteigend) sortieren
Userlist.sort(function(a, b) {
return b.Accounts.length - a.Accounts.length;
});
Funktionen in Javascript sehen aus wie C-Funktionen, ausser dass sie mit dem Schlüsselwort function deklariert werden anstatt einer Typenbezeichnung.
Beim Aufruf einer Funktion ist es nicht erforderlich, eine feste Anzahl von Parametern zu übergeben: überschüssige Parameter werden ignoriert, und fehlende Parameter werden auf den Wert undefined gesetzt. Dies vereinfacht die Behandlung optionaler Argumente.
Eine Funktion hat mittels arguments Zugriff auf ihre Parameterliste. Letztere enthält alle Parameter, die der Aufrufer übergeben hat. Dadurch sind Prozeduren mit variabler Argumentenanzahl realisierbar, z.B.:
function sum() {
for (var i = total = 0; i < arguments.length; ++i) total += arguments[i];
return total;
}
Javascript kennt innere Funktionen, die dem gleichen Zweck dienen wie innere Klassen in Java.
Ebenso gibt es anonyme Funktionen, die als Lambda-Ausdrücke agieren.
Man unterscheidet drei Notationsarten zur Funktionsdefinition: die function-Anweisung, den function-Operator und den function-Konstruktor.
| function-Anweisung |
erzeugt eine benannte Funktion im jeweiligen Gültigkeitsbereich.
function name ( arg_list ) block
arg_list enthält 0 oder mehr durch Komma getrennte Parameternamen.
block ist eine von geschweiften Klammern { } umschlossene Liste von 0 oder mehr Anweisungen/Befehlen.
function Add(a, b) { return a + b; }
Die function-Anweisung ist eine Kurzform der Operator-Form:
var name = function name ( arg_list ) block
var Add = function Add(a, b) { return a + b; };
|
| function-Operator |
ist ein Prefix-Operator, der ein Funktionsobjekt erzeugt und genauso aussieht wie die function-Anweisung.
... = function [name] ( arg_list ) block
Wenn der optionale name angegeben wird, kann er vom Funktionscode für einen rekursiven Aufruf benutzt werden.
Wenn name ausgelassen wird, dann handelt es sich um eine anonyme Funktion.
bla = function sayit(t) { alert(t); }; // benannt
x.onclick = function() { alert("Klick"); }; // anonym
Der function-Operator dient im Allgemeinen dazu, einem Prototyp eine Funktion zuzuweisen.
Er kann ausserdem dazu benutzt werden, Funktionen an Ort und Stelle zu definieren, was beim Schreiben von Callbacks vorteilhaft ist. |
| function-Konstruktor |
Der Konstruktor benötigt 2 Stringparameter (die Argumentenliste und den Codekörper) und erzeugt ein Funktionsobjekt.
... = new Function ( arg_list_string , body_string )
var Add = new Function("a,b", "return a + b;");
Auf diese Variante sollte wenn möglich verzichtet werden, weil...
...die Konventionen für Hochkommas es u.U. sehr schwer machen, einen Codekörper korrekt als String zu formulieren.
...im Stringformat keine frühzeitige Fehlerprüfung des Codes erfolgen kann.
...es die Performance drosselt, wenn bei jedem Konstruktoraufruf die Strings erneut geparst werden müssen.
...die eigene, unabhängige Implementation einer Funktion Speicherplatzverschwendung ist. |
Da eine Funktion ein Objekt ist, kann sie Elemente enthalten wie andere Objekte auch. Dies erlaubt einer Funktion, ihre eigenen Datentabellen zu besitzen und wie eine Klasse zu agieren; mit eigenem Konstruktor und einer Reihe von diesbezüglichen Methoden.
Wenn eine Funktion Element eines Objekts ist, nennt man sie Methode. Beim Aufruf einer Methode wird eine spezielle Variable namens this mit einem Verweis auf das Objekt initialisiert.
So wird z.B. im Ausdruck Mail.Send() die this-Variable (als eine Art von Extraargument für die Funktion Send()) auf das Objekt Mail gesetzt. Die Funktion Send() kann sich dann mittels this auf das Mail-Objekt beziehen.
In einem komplexeren Ausdruck wie Sys.Comm.Mail.Send() verweist this auf das Objekt Sys.Comm.Mail und nicht auf das Wurzelobjekt Sys.
In privaten Funktionen referenziert this das globale Objekt (also window), was nicht sonderlich logisch oder hilfreich ist. Das korrekte Verhalten wäre vielmehr die Beibehaltung des aktuellen Wertes von this, gerade beim Aufruf innerer Funktionen.
Eine Funktion, die zur Initialisierung von Objekten benutzt wird, nennt man Konstruktor.
Die Syntax für den Aufruf eines Konstruktors unterscheidet sich vom herkömmlichen Funktionsaufruf nur durch das vorangestellte Schlüsselwort new:
... = new Constructor ( arg_list )
Beispielsweise:
var p = new Person("Donald", "Duck");
Es hat sich eingebürgert, den Namen eines Konstruktors mit einem Großbuchstaben beginnen zu lassen.
Das new-Prefix ändert die Bedeutung der this-Variablen. Statt des gewohnten Wertes enthält this nun einen Verweis auf das neue Objekt.
Der Codekörper der Konstruktorfunktion initialisiert dabei die Elemente des Objekts.
Der Konstruktor liefert das erzeugte Objekt zurück, ausser es wird explizit durch einen anderslautenden return-Befehl überschrieben.
Zudem besitzt das neue Objekt einen impliziten Prototyp-Verweis, der eine Referenz auf die prototype-Eigenschaft des Konstruktors enthält.
Objekte enthalten eine versteckte Verweiseigenschaft, die auf die prototype-Eigenschaft des Objektkonstruktors zeigt.
Beim Zugriff auf Objektelemente mittels Punkt- oder Stringnotation tritt folgender Mechanismus in Kraft:
Wird das Element nicht im Objekt gefunden, dann wird das Verweisobjekt ausgeführt.
Falls das Element im Verweisobjekt nicht gefunden wird, und letzteres hat ein eigenes Verweisobjekt, dann wird dort weitergesucht.
Wenn die Kette der Verweisobjekte ergebnislos durchlaufen wurde, wird undefined zurückgeliefert.
Solche Prototyp-Verweisketten stellen eine Art von Vererbung dar.
Durch Zuweisung kann der Prototyp um neue Elemente erweitert werden.
Hier definieren wir eine Klasse Demo, die von der Klasse Basis abgeleitet wird und ihre eigene Methode Show() implementiert:
function Demo() {};
Demo.prototype = new Basis();
Demo.prototype.Show = function() {};
Näheres zu Prototypen und Vererbung siehe unter Klassen/OOP.
Benannte Variablen werden mit der Anweisung var definiert.
Innerhalb einer Funktion ist der Gültigkeitsbereich dieser Variablen auf die Funktion beschränkt, d.h. sie sind nicht von ausserhalb erreichbar. Dies ist übrigens die einzige Bereichsgranularität bei Javascript; insbesondere gibt es keinen Block-Gültigkeitsbereich wie etwa in C.
Jedwede Variablen, die innerhalb einer Funktion auftreten und hier nicht ausdrücklich mittels var definiert worden sind, gehören einem äusseren Gültigkeitsbereich an. Falls die Gültigkeitsbereiche nach aussen hin bis zum globalen Objekt durchlaufen wurden, ohne eine Initialisierung der Variablen zu finden, wird ihr Wert auf undefined gesetzt.
Grundsätzlich sind Variablen nicht typisiert; ihr Datentyp ist dynamisch und wird implizit erst bei einer Zuweisung festgelegt.
Lokale Variablen werden bei jedem Aufruf einer Funktion neu angelegt, wodurch Funktionen zur Rekursion fähig sind.
Weil Javascript keinen void-Typ besitzt (wie etwa C), sind alle Funktionen im wahrsten Sinne des Wortes funktional und müssen einen Wert zurückliefern. Der Defaultwert ist undefined, ausser bei Konstruktoren, wo der Defaultwert this ist.
Es gibt den Prefix-Operator void, der beim Aufruf wertliefernder Funktionen dazu benutzt werden kann, den Rückgabewert zu unterdrücken, d.h. undefined zu erzeugen.
Funktionen können nicht nur die üblichen Datentypen (wie Boolean, Zahlen oder Strings), sondern auch alle Arten von Objekten und damit natürlich auch komplette Funktionen zurückliefern, wodurch sich der Mechanismus einer Delegation nachbilden lässt.
Unter Delegation versteht man die Weiterleitung einer Information oder Anforderung in Abhängigkeit von bestimmten Kriterien. Der Begriff verfestigte sich im Umfeld der OOP; die Idee als solche wurde aber bereits in frühen BASIC-Dialekten in rudimentärer Form (z.B. mittels ongoto() oder ongosub()) realisiert.
Im Beispiel liefert FuServer() je nach Selektor eine von vier anonymen Funktionen (Summe, Differenz, Produkt und Dummy):
function FuServer(i) {
switch (i) {
case 1: return function(a, b) { return a + b; }; // 1: Summe
case 2: return function(a, b) { return Math.abs(a-b); }; // 2: Differenz
case 3: return function(a, b) { return a * b; }; // 3: Produkt
default: return function() { return 0; };
}
}
var f = FuServer(1); // Summenfunktion holen...
alert(f(3, 5)); // ...und ausführen. Anzeige: '8'
Die von FuServer() gelieferte Funktion wird in obigem Beispiel in der Variablen f gespeichert. Dies ist nicht unbedingt erforderlich; man könnte die resultierende Funktion auch an Ort und Stelle (hier wieder mit Angabe der Parameter 3 und 5) ausführen:
alert(FuServer(2)(3, 5)); // Anzeige: '2' (Differenzfunktion)
alert(FuServer(3)(3, 5)); // Anzeige: '15' (Produktfunktion)
Wenngleich diese Syntax ungewöhnlich anmutet - durch Verschachtelung von Delegation können auch exotische und komplexe Ausdrücke wie diese auftreten:
a = b(0)(0)(0);
a(b())().c() = d(e()()).f();
var x = Item(2, 10)('td')(Fib(3))(0.5, 1.9);
Funktionen können sich innerhalb anderer Funktionen befinden und haben dann Zugriff auf die Variablen und Parameter jener äusseren Funktionen.
Hier eine Verschachtelung mit 4 Ebenen (Demo, Innen, GanzInnen und GanzGanzInnen):
function Demo(a, b) {
var fakt = 2;
function Innen(x) {
function GanzInnen(y) {
function GanzGanzInnen(z) { return fakt * z; }
return GanzGanzInnen(y);
}
return GanzInnen(x);
}
return Innen(a) + Innen(b);
}
alert(Demo(1, 2)); // Anzeige: '6'
Falls eine Referenz auf eine innere Funktion überdauert (z.B. als ein Callback), dann bleiben auch die Variablen der äusseren Funktion erhalten.
Die Gruppe der Anweisungen umfasst
var if switch for while do break continue return try throw with
Ihre Bedeutung ist in Javascript meist die selbe wie in anderen C-ähnlichen Sprachen.
Die var-Anweisung besteht in einer Liste aus einem oder mehr Variablennamen, durch Komma getrennt und mit optionaler Initialisierung:
var a, b = window.document.body;
Tritt die var-Anweisung ausserhalb jeglicher Funktionen auf, fügt sie dem globalen Objekt neue Elemente hinzu.
Wenn sie innerhalb einer Funktion steht, definiert sie lokale Variablen der Funktion.
Im Bedingungsausdruck von if-, while- und do-Konstrukten sowie bei logischen Operatoren interpretiert Javascript die Werte false, null, undefined, "" (Leerstring), und die Zahl 0 als false. Alle anderen Werte werden als true angesehen.
Die case-Labels innerhalb einer switch-Anweisung können Konstanten, Literale Strings oder zusammengesetzte Ausdrücke sein.
Es gibt 2 Arten der for-Anweisung: zum einen die übliche (init; test; inc)-Form und zum anderen der Objekt-Iterator in der (name in object)-Form (vergleichbar mit der for each-Anweisung in anderen Sprachen):
for ( name in object ) { value = object [ name ] ; }
Der Block wird für jedes Element in object ausgeführt.
Die with-Anweisung (vergleichbar mit with in VBA/VisualBasic) macht nicht nur den Code schwer lesbar, sondern ist zudem noch fehlerträchtig implementiert. Sie sollte prinzipiell nicht benutzt werden.
Anweisungen können ein Label-Prefix (Bezeichner, gefolgt von einem Doppelpunkt) besitzen.
Bezüglich der Rangfolge siehe auch Anhang: Operatoren Priorität.
Javascript besitzt eine ziemlich große Anzahl von Operatoren, die auf die gleiche Weise funktionieren wie in anderen C-ähnlichen Sprachen.
Es gibt jedoch ein paar Unterschiede, auf die man achten sollte.
Der + Operator wird sowohl für die Addition als auch für Stringverkettungen benutzt.
Eine Stringverkettung erfolgt ab dem (von links nach rechts gesehen) ersten Operanden, der vom Typ String ist und wirkt bis zum letzten Operanden. Dieses etwas ungewöhnliche Verhalten kann leicht Fehler verursachen.
| Ausdruck | Ergebnis |
| "x"+1+2+3+4 | "x1234" |
| 1+2+"x"+3+4 | "3x34" |
| 1+2+3+4+"x" | "10x" |
Das Pluszeichen kann ausserdem als Prefix-Operator benutzt werden, um seinen Stringoperanden in eine Zahl zu konvertieren.
| Ausdruck | Ergebnis |
| 1+2+"3"+4+5 | "3345" |
| 1+2+(+"3")+4+5 | 15 |
Der ! Operator wandelt seinen Operanden in einen bool'schen Wert und negiert ihn anschließend.
Diesen Effekt ausnutzend, kann man mittels Prefix !! einen Wert zu Boolean konvertieren.
Der && Operator wird normalerweise logisches Und genannt. Man könnte ihn jedoch auch Wächter nennen:
Falls der erste Operand false, null, undefined, "" (Leerstring) oder die Zahl 0 ist, wird unverzüglich dieser erste Operand zurückgeliefert. Andernfalls wird der zweite Operand geliefert. Dies ermöglicht es, auf kompakte Weise einen Null-Check zu schreiben:
var value = p && p.name;
Der Wert von p.name wird nur dann abgefragt, wenn p selbst einen validen Wert besitzt. Somit wird ein Fehler vermieden.
Der && Operator ist hier eine Kurzform für: if (p) return p.name; else return p;
Der || Operator wird normalerweise logisches Oder genannt. Man könnte ihn jedoch auch Default nennen:
Falls der erste Operand false, null, undefined, "" (Leerstring) oder die Zahl 0 ist, wird der zweite Operand zurückgeliefert. Andernfalls wird der erste Operand geliefert. Dies ermöglicht es, auf kompakte Weise einen Defaultwert zu spezifizieren:
var value = v || 3;
Der Wert von v wird nur dann benutzt, wenn er valide ist. Sonst wird der Wert 3 benutzt.
Der || Operator ist hier eine Kurzform für: if (v) return v; else return 3;
Javascript bietet eine Reihe von Bit- und Shift-Operatoren, besitzt aber keinen Integer-Datentyp, auf den sie anwendbar wären. Tatsächlich wird der numerische Operand (eine 64-Bit Fließkommazahl) vor der Operation in einen 32-Bit Integer konvertiert und nach der Durchführung in eine Fließkommazahl zurückgewandelt.
In JavaScript ist void kein Typ sondern ein Prefix-Operator, der immer undefined liefert. Dies mag für C/Java-Programmierer anfangs etwas verwirrend sein und bedarf der Gewöhnung.
Der typeof Operator liefert (als String) den Typ seines Operanden. Allerdings lässt sich darüber streiten, ob Javascript hier konsequent genug ist:
| Operand | Ergebnis von typeof |
| Objekt | 'object' |
| Array | 'object' (zwar richtig, aber besser wäre 'array') |
| Funktion | 'function' |
| Text | 'string' |
| Zahl | 'number' |
| Boolean | 'boolean' |
| null | 'object' (verwirrend, besser wäre 'undefined') |
| undefined | 'undefined' |
Anmerkungen zu sprachlichen Eigenheiten:
Das globale Objekt ist der direkte Besitzer aller Variablen und Funktionen, die nicht innerhalb anderer Funktionen oder Objekte definiert wurden. Überraschenderweise hat das globale Objekt keinen expliziten Namen in der Sprache.
Manchmal verweist die this-Variable darauf, aber meistens ist dies nicht der Fall. Im Webbrowser sind window und self Elemente des globalen Objekts, die auf das globale Objekt zeigen und so einen Weg darstellen, es indirekt zu adressieren.
Wenn eine Variable angesprochen wird, die sich nicht im aktuellen Gültigkeitsbereich befindet, wird im globalen Objekt nach ihr gesucht. Ist sie auch dort nicht auffindbar, tritt ein Fehler auf.
Die ECMAScript-Spezifikation spricht zwar nicht über die Möglichkeit mehrerer globaler Objekte oder Kontexte, aber Webbrowser unterstützen es: jedes Fenster besitzt sein eigenes globales Objekt.
Eine der etwas zu laxen Regeln von Javascript ist das optionale Auslassen des Semikolons am Ende einer Zeile oder eines Blocks.
Diese Freiheit mag in intergrierten Entwicklungsumgebungen oder Shellprogrammen vertretbar sein, wo der Editor automatisch fehlende Semikolons ergänzt. Es ist jedoch in einer Sprachdefinition nicht sinnvoll, dies dem Interpreter zu überlassen.
Grundsätzlich sollten Semikolons im Quellcode also immer angegeben werden.
In nahezu jedem Javascript-Code benötigt man Namen für eigene Variablen, Funktionen und sonstigen Objekte.
Diese Namen unterliegen folgender Syntax:
- Erlaubt sind Buchstaben (a...z, A...Z), Groß- und Kleinschreibung werden unterschieden.
- Erlaubt sind Unterstrich (_) und Dollarzeichen ($).
- Erlaubt sind Ziffern (0...9), aber nicht als erstes Zeichen.
- Keine Sonderzeichen wie deutsche Umlaute oder scharfes S.
- Keine Leerzeichen.
- Keine reservierten Wörter.
I.d.R. macht man einen Bezeichner umso sprechender, je größer sein Gültigkeitsbereich ist:
Temporäre Laufvariablen in Schleifen bestehen oft nur aus einem einzelnen Buchstaben (z.B. i, j oder n).
Parameternamen und globale Variablen sind etwas länger (z.B. val, Tx oder iPos).
Objekte, Funktionen und Klassen sowie deren Elemente schließlich werden ausführlicher betitelt (z.B. Person, incrPos oder CalcAverage).
Hilfreich bei Variablennamen ist das Voranstellen eines bestimmten Buchstabens, um einen Hinweis auf den Typ zu geben:
| Typ | Prefix | Beispiel |
| Integer | n oder i | nLength |
| String/Text | s oder t | tInput |
| Boolean | b | bActive |
| Allgemeiner Wert | v | vValue |
| Objekt | o | oDiv |
| Funktion | fu | fuShow |
| Tabelle | tb | tbMain |
| Tabellenzeile | tr | trHead |
| Tabellenzelle | td | tdSum |
| Formular | f | fEdit |
Wichtige Namen sollten so vergeben werden, dass auch für Aussenstehende deren Bedeutung leicht erkennbar ist.
Meist werden Begriffe der englischen Sprache benutzt, weil sie international verständlich ist und ihre Wörter relativ kurz sind.
In Javascript existiert eine beachtliche Anzahl reservierter Wörter, von denen letztlich nur ein kleiner Teil (hier fett gedruckt) seinen Weg in den offiziellen Sprachschatz gefunden hat:
abstract
boolean break byte
case catch char class const continue
debugger default delete do double
else enum export extends
false final finally float for function
goto
if implements import in instanceof int
interface
long
native new null
package private protected public
return
short static super switch synchronized
this throw throws transient true try
typeof
var void volatile
while with
Die Restriktion betrifft folgende Fälle:
- Variablennamen
- Namen bei literaler Objektnotation
- Elementnamen bei Punktnotation
- Funktionsargumente
- Labels (z.B. bei case oder break)
| template |
 |