JavaScript unterstützt zwei Kommentarstile. Jeglicher Text, der zwischen der Zeichenfolge // und dem Ende einer Zeile steht, wird als Kommentar betrachtet und von JavaScript ignoriert. Jeglicher Text zwischen den Zeichenfolgen /* und */ wird ebenfalls als Kommentar betrachtet. Diese Kommentare können mehrere Zeilen lang sein, dürfen aber nicht geschachtelt werden. Die folgenden Codezeilen sind gültige JavaScript-Kommentare:

// Das ist ein einzeiliger Kommentar.
/* Das ist ebenfalls ein Kommentar */  
// Und hier ist ein weiterer.
/*
 * Noch ein Kommentar,
 * der mehrere Zeilen lang ist.
 */

Ein Bezeichner ist einfach ein Name. In JavaScript werden Bezeichner genutzt, um Variablen und Funktionen zu benennen und um Marken für bestimmte Schleifen in JavaScript-Code anzugeben. Ein JavaScript-Bezeichner muss mit einem Buchstaben, einem Unterstrich ( _) oder einem Dollarzeichen ( $) beginnen. Nachfolgende Zeichen können Buchstaben, Ziffern, Unterstriche und Dollarzeichen sein.

JavaScript reserviert einige Bezeichner als Schlüsselwörter der Sprache. Sie dürfen diese Wörter in Ihren Programmen nicht als Bezeichner nutzen:

break      delete     function   return     typeof
case       do         if         switch     var
catch      else       in         this       void
continue   false      instanceof throw      while
debugger   finally    new        true       with
default    for        null       try

JavaScript reserviert außerdem einige Wörter, die von der Sprache aktuell nicht genutzt werden, in zukünftigen Versionen aber genutzt werden könnten. ECMAScript 5 reserviert die folgenden Wörter:

class  const  enum  export  extends  import  super

Zusätzlich sind die folgenden Wörter, die in gewöhnlichem JavaScript-Code zulässig sind, im »strengen Modus« (strict mode) reserviert:

implements  let      private    public  yield
interface   package  protected  static

Außerdem beschränkt der Strict-Modus die Verwendung der folgenden Bezeichner. Sie sind nicht vollständig reserviert, dürfen aber nicht als Namen für Variablen, Funktionen oder Parameter genutzt werden:

arguments   eval

ECMAScript 3 reservierte alle Schlüsselwörter der Programmiersprache Java. Obgleich dies in ECMAScript 5 gelockert wurde, sollten Sie folgende Wörter in Ihrem Code als Bezeichner vermeiden, wenn Sie vorhaben, Ihren Code in einer ECMAScript 3-konformen JavaScript-Implementierung laufen zu lassen:

abstract   double     goto        native     static
boolean    enum       implements  package    super
byte       export     import      private    synchronized
char       extends    int         protected  throws
class      final      interface   public     transient
const      float      long        short      volatile

Wie viele andere Programmiersprachen nutzt JavaScript das Semikolon (;) um Anweisungen voneinander abzugrenzen (siehe Chapter 4). Das ist wichtig, um die Bedeutung Ihres Codes zu verdeutlichen: Ohne ein Trennzeichen könnte es scheinen, als sei das Ende der einen Anweisung der Anfang der nächsten oder umgekehrt. In JavaScript können Sie das Semikolon zwischen zwei Anweisungen gewöhnlich weglassen, wenn diese Anweisungen auf eigenständigen Zeilen stehen. (Außerdem können Sie das Semikolon am Ende eines Programms weglassen oder dann, wenn das nächste Token im Programm eine schließende geschweifte Klammer } ist.) Viele JavaScript-Programmierer (und der Code in diesem Buch) nutzen Semikola, um explizit das Ende einer Anweisung zu markieren, auch an Stellen, an denen sie nicht verwendet werden müssten. Ein anderer Stil ist, Semikola immer wegzulassen, wenn das möglich ist, und sie nur in den wenigen Situationen zu verwenden, in denen sie erforderlich sind. Unabhängig davon, für welchen Stil Sie sich entscheiden, sollten Sie ein paar Details zu optionalen Semikola in JavaScript begriffen haben.

Betrachten Sie den folgenden Code. Da die beiden Anweisungen auf zwei separaten Zeilen stehen, könnte das erste Semikolon weggelassen werden:

a = 3;
b = 4;

Schreibt man die Anweisungen jedoch folgendermaßen, ist das erste Semikolon erforderlich:

a = 3; b = 4;

Beachten Sie, dass JavaScript nicht jeden Zeilenumbruch als ein Semikolon betrachtet: Normalerweise betrachtet es einen Zeilenumbruch nur dann als ein Semikolon, wenn sich der Code ohne dieses Semikolon nicht parsen ließe. Genauer gesagt: JavaScript interpretiert einen Zeilenumbruch als Semikolon, wenn der Umbruch entweder auf eines der Schlüsselwörter return, break bzw. continue folgt, wenn er vor den Operatoren ++ oder -- steht oder wenn das folgende Nicht-Leerzeichen nicht als Fortsetzung der gegenwärtigen Anweisung interpretiert werden kann.

Diese Regeln zum Abschluss von Anweisungen können zu einigen überraschenden Fällen führen. Folgender Code scheint aus zwei eigenständigen Anweisungen zu bestehen, die durch einen Zeilenumbruch getrennt werden:

var y = x + f
(a+b).toString()

Aber die Klammern zu Anfang der zweiten Codezeile können als ein Funktionsaufruf auf dem f-Element der ersten Zeile gelesen werden, und JavaScript interpretiert diesen Code folgendermaßen :

var y = x + f(a+b).toString();

Anders als viele andere Sprachen macht JavaScript keinen Unterschied zwischen Ganzzahlen (oder Integern) und Gleitkommazahlen . In JavaScript werden alle Zahlen als Gleitkommawerte dargestellt. JavaScript repräsentiert Zahlen in dem 64-Bit-Gleitkommaformat, das im IEEE-Standard 754 definiert wird. Das heißt, es können Zahlen bis hinauf zu ±1.7976931348623157 × 10³⁰⁸ und bis hinab zu ±5 × 10⁻³²⁴ repräsentiert werden.

Das JavaScript-Zahlenformat ermöglicht es Ihnen, alle ganzen Zahlen zwischen −9007199254740992 (−2⁵³) und 9007199254740992 (2⁵³) exakt festzuhalten, die Grenzen eingeschlossen. Nutzen Sie größere ganzzahlige Werte, können Sie in den letzten Ziffern an Genauigkeit verlieren. Beachten Sie jedoch, dass in JavaScript bestimmte Operationen (wie die Indizierung von Arrays und die in Chapter 3 beschriebenen Bit-Operationen) mit 32-Bit-Ganzzahlen durchgeführt werden.

Erscheint eine Zahl unmittelbar in einem JavaScript-Programm, bezeichnet man das als ein Zahlliteral. JavaScript unterstützt Zahlliterale in verschiedenen Formaten. Beachten Sie, dass jedem Zahlliteral ein Minuszeichen (-) vorangestellt werden kann, um die Zahl negativ zu machen.

Eine ganze Zahl zur Basis 10 wird in einem JavaScript-Programm als Folge von Ziffern geschrieben . Zum Beispiel:

0
1024

Neben Ganzzahlliteralen zur Basis 10 kennt JavaScript Hexadezimalliterale (zur Basis 16). Ein Hexadezimalliteral beginnt mit den Zeichen »0x« oder »0X«, auf die eine Reihe hexadezimaler Ziffern folgt. Hexadezimale Ziffern sind die arabischen Ziffern 0 bis 9 und die Buchstaben a (oder A) bis f (oder F), die die Werte von 10 bis 15 repräsentieren. Hier sind einige Beispiele für hexadezimale Ganzzahlliterale:

0xff  // 15*16 + 15 = 255 (Basis 10)
0xCAFE911

Gleitkommaliterale können einen Dezimaltrenner enthalten und nutzen die traditionelle Syntax für reelle Zahlen. Eine reelle Zahl wird mit einem ganzzahligen Teil, einem Punkt als Dezimaltrenner und dem Nachkommateil der Zahl dargestellt.

Gleitkommaliterale können auch in wissenschaftlicher Notation dargestellt werden. Bei dieser folgen auf eine reelle Zahl der Buchstabe e (oder E), ein optionales Plus- oder Minuszeichen und ein ganzzahliger Exponent. Eine in dieser Notation dargestellte Zahl entspricht der reellen Zahl mal 10 hoch dem Exponenten.

Kompakter formuliert, sieht diese Syntax so aus:

[Ziffern][.Ziffern][(E|e)[(+|-)]Ziffern]

Zum Beispiel:

3.14
6.02e23        // 6.02 × 1023
1.4738223E-32  // 1.4738223 × 10−32

JavaScript-Programme arbeiten bei Zahlen mit den arithmetischen Operatoren, die die Sprache bietet. Zu diesen zählen + für die Addition, - für die Subtraktion, * für die Multiplikation, / für die Division und % für die Modulodivision (den Rest nach der Division). Vollständige Angaben zu diesen und weiteren Operatoren finden Sie in Chapter 3.

Neben diesen elementaren arithmetischen Operatoren unterstützt JavaScript komplexere mathematische Operationen über die Funktionen und Konstanten, die als Eigenschaften des Math-Objekts definiert sind:

 Math.pow(2,53)  // => 9007199254740992: 2 hoch 53.
  
 Math.round(.6)  // => 1.0: auf die nächste ganze Zahl 
                   // runden.
  
 Math.ceil(.6)   // => 1.0: auf die nächste ganze Zahl 
                   // aufrunden.
  
 Math.floor(.6)  // => 0.0: auf die nächste ganze Zahl 
                   // abrunden.
  
 Math.abs(-5)    // => 5: Absolutwert.
  
 Math.max(x,y,z) // Das größte der Argumente ermitteln.
  
 Math.min(x,y,z) // Das kleinste der Argumente ermitteln.
  
 Math.random()   // Pseudo-Zufallszahl, für deren Wert 
                   // 0 <= x < 1.0 gilt.
  
 Math.PI         // π: Kreisumfang / Kreisdurchmesser.
  
 Math.E          // e: Die Basis des natürlichen 
                   // Logarithmus.
  
 Math.sqrt(3)    // Die Quadratwurzel von 3.
   Math.pow(3,1/3)  // Die Kubikwurzel von 3.
  
 Math.sin(0)     // Trigonometrie: auch Math.cos, 
                   // Math.atan usw.
  
 Math.log(10)    // Natürlicher Logarithmus von 10.
  
 Math.log(100)/Math.LN10 // Logarithmus zur Basis 10 von 100.
  
 Math.log(512)/Math.LN2  // Logarithmus zur Basis 2 von 512.
  
 Math.exp(3)             // Math.E hoch 3.

In JavaScript lösen arithmetische Operationen keine Fehler aus, wenn es zu Wertüberläufen, Wertunterläufen oder einer Division durch null kommt. Ist das Ergebnis einer numerischen Operation größer als die größte darstellbare Zahl (Überlauf), ist das Ergebnis ein spezieller Wert für unendlich, den JavaScript als Infinity ausgibt. Wird ein negativer Wert kleiner als die kleinste darstellbare negative Zahl, ist das Ergebnis minus unendlich und wird als -Infinity ausgegeben. Unendliche Werte verhalten sich, wie man erwarten würde: Additions-, Subtraktions-, Multiplikations- und Divisionsoperationen auf einem unendlichen Wert liefern als Ergebnis wieder einen unendlichen Wert (eventuell mit umgekehrtem Vorzeichen).

Die Division durch null ist in JavaScript kein Fehler: Sie liefert einfach Infinity oder -Infinity. Es gibt allerdings eine Ausnahme: Null geteilt durch null hat keinen wohldefinierten Wert. Das Ergebnis dieser Operation ist ein spezieller »Keine-Zahl«-Wert, der als NaN (kurz für Not-a-number) ausgegeben wird. NaN resultiert ebenfalls, wenn Sie versuchen, unendlich durch unendlich zu teilen, die Quadratwurzel einer negativen Zahl zu ermitteln, oder wenn Sie arithmetische Operatoren auf nicht numerischen Operanden nutzen, die sich nicht in Zahlen umwandeln lassen.

JavaScript definiert die globalen Variablen Infinity und NaN zur Repräsentation von plus unendlich und »Keine-Zahl«.

NaN hat in JavaScript eine ungewöhnliche Eigenschaft: Dieser Wert ist keinem anderen Wert gleich, nicht einmal sich selbst. Das heißt, Sie können nicht x == NaN schreiben, um zu prüfen, ob der Wert einer Variablen x gleich NaN ist. Stattdessen sollten Sie x != x schreiben. Dieser Ausdruck ist nur dann wahr, wenn x gleich NaN ist. Alternativ können Sie die Funktion isNaN() nutzen. Diese liefert true, wenn ihr Argument NaN oder ein nicht-numerischer Wert wie ein String oder ein Objekt ist, der nicht in einen numerischen Wert umgewandelt werden kann. Die verwandte Funktion isFinite() liefert true, wenn ihr Argument eine Zahl ist, die nicht NaN, Infinity oder -Infinity ist.

Es gibt unendlich viele reelle Zahlen, von denen im JavaScript-Gleitkommaformat aber nur eine endliche Anzahl (18437736874454810627, um genau zu sein) exakt repräsentiert werden kann. Das heißt, dass die Darstellungen der Gleitkommazahlen, mit denen Sie in JavaScript arbeiten, häufig nur Näherungswerte für die eigentlichen Zahlen sind und es daher zu Rundungsfehlern kommen kann.

Ein String ist eine unveränderliche Folge von 16-Bit-Werten, die üblicherweise Unicode-Zeichen darstellen – Strings sind der JavaScript-Typ zur Darstellung von Text. Die Länge eines Strings ist die Anzahl an 16-Bit-Werten, die er enthält. In JavaScript sind die Indizes für Strings (und Arrays) nullbasiert: Der erste 16-Bit-Wert befindet sich an Position 0, der zweite an Position 1 und so weiter. Der leere String ist der String der Länge 0. JavaScript hat keinen speziellen Typ zur Darstellung eines einzelnen String-Elements. Zur Darstellung eines einzelnen 16-Bit-Werts nutzen Sie einfach einen String der Länge 1.

""  // Der leere String: Er enthält keine Zeichen.
'name="formular"'
"Hätten Sie nicht lieber ein O'Reilly-Buch?"
"Dieser String\nhat zwei Zeilen."
"π = 3.14"

'You\'re right, it can\'t be a quote'

msg = "Hallo " + "Welt";   // => "Hallo Welt"

s.length

var s = "Hallo Welt" // Definiert einen Text.
s.charAt(0)          // => "H": Das erste Zeichen.
s.charAt(s.length-1) // => "t": Das letzte Zeichen.
s.substring(1,4)     // => "all": Das 2., 3. und 4. Zeichen.
s.slice(1,4)         // => "all": Das Gleiche.
s.slice(-3)          // => "elt": Die letzten drei Zeichen.
s.indexOf("l")       // => 2: Position des ersten 
                     // Vorkommens des Buchstabens l.
s.lastIndexOf("l")   // => 9: Position des letzten 
                     // Vorkommens des Buchstabens l.
s.indexOf("l", 3)    // => 3: Position des ersten 
                     // "l" nach oder bei der 3. Position.
s.split(", ")        // => ["Hallo", "Welt"]: 
                     // In Substrings aufgetrennt.
s.replace("h", "H")  // => "hallo Welt": Ersetzt Vorkommen.
s.toUpperCase()      // => "HALLO WELT": Alles in 
                     // Großbuchstaben.

s = "Hallo Welt";
s[0]                  // => "H"
s[s.length-1]         // => "t"

Ein boolescher Wert repräsentiert Wahrheit oder Falschheit, an oder aus, ja oder nein. Für diesen Typ gibt es folglich nur zwei mögliche Werte. Die reservierten Wörter true und false werden zu diesen beiden Werten ausgewertet.

Boolesche Werte sind in der Regel die Ergebnisse von Vergleichen, die Sie in Ihren JavaScript-Programmen anstellen. Zum Beispiel:

a == 4

Dieser Code prüft, ob der Wert der Variablen a gleich der Zahl 4 ist. Ist das der Fall, ist das Ergebnis dieses Vergleichs der boolesche Wert true. Ist a nicht gleich 4, ist das Ergebnis des Vergleichs false.

Boolesche Werte kommen häufig in den Kontrollstrukturen von JavaScript zum Einsatz. Beispielsweise führt die if/else-Anweisung von JavaScript eine von zwei Aktionen aus, wenn ein boolescher Wert true ist, und die andere, wenn er false ist. Üblicherweise binden Sie den Vergleich, der den booleschen Wert hervorbringt, direkt in die Anweisung ein, die ihn nutzt. Das sieht dann folgendermaßen aus:

if (a == 4)
  b = b + 1;
else
  a = a + 1;

Dieser Code prüft, ob a gleich 4 ist. Ist das der Fall, addiert er 1 zu b hinzu; andernfalls addiert er 1 zu a hinzu.

Wie wir im Abschnitt Typumwandlungen erörtern werden, kann jeder JavaScript-Wert in einen booleschen Wert umgewandelt werden. Die folgenden Werte werden in false umgewandelt und verhalten sich deswegen auch wie false:

undefined
null
0
-0
NaN
""  // Der leere String.

Alle anderen Werte, einschließlich aller Objekte (und Arrays) werden in true umgewandelt und verhalten sich wie true. false und die sechs Werte, die in false umgewandelt werden, werden gelegentlich als falsy, alle anderen Werte als truthy bezeichnet. (Das führen wir hier nur für den Fall an, dass Sie in englischer Literatur einmal auf diese Bezeichnungen stoßen. Wir werden hier einfach von falschen und wahren Werten sprechen.) Erwartet JavaScript einen booleschen Wert, verhält sich ein falscher Wert wie false, ein wahrer Wert wie true.

Nehmen Sie zum Beispiel an, die Variable o enthielte entweder ein Objekt oder den Wert null. Dass o nicht null ist, könnten Sie dann explizit mit einer if-Anweisung wie der folgenden prüfen:

if (o !== null) ...

Der Ungleich-Operator !== vergleicht o mit null und wird entweder zu true oder zu false ausgewertet. Sie können den Vergleich aber auch gleich weglassen und sich auf den Umstand stützen, dass null ein falscher Wert ist, Objekte hingegen wahre Werte sind:

if (o) ...

Im ersten Fall wird der Inhalt des ifs nur ausgeführt, wenn o nicht null ist. Der zweite Fall ist weniger exakt: Der Body des ifs wird ausgeführt, wenn o nicht false oder irgendein falscher Wert (wie null oder undefined) ist. Welche if-Anweisung für Ihr Programm angemessen ist, hängt vollkommen davon ab, welche Werte Sie für o erwarten. Wenn null anders behandelt werden soll als 0 und "", müssen Sie einen expliziten Vergleich einsetzen.

null ist ein Schlüsselwort, das zu einem speziellen Wert ausgewertet wird, der üblicherweise genutzt wird, um das Fehlen eines Wertes anzuzeigen. Wird der typeof-Operator auf null angewandt, erhält man als Ergebnis den String »object«. Das zeigt an, dass null als spezieller Objektwert betrachtet werden kann, der »kein Objekt« bedeutet. In der Praxis wird null üblicherweise jedoch als einziges Exemplar seines eigenen Typs betrachtet und kann ebenso eingesetzt werden, um für Zahlen oder Strings »kein Wert« anzuzeigen. Die meisten Programmiersprachen besitzen ein Äquivalent zu JavaScripts null: Vielleicht kennen Sie es als null oder nil.

JavaScript kennt noch einen weiteren Wert, der das Fehlen eines Wertes anzeigt. Der undefinierte Wert steht für ein grundlegenderes Fehlen. Es ist der Wert, den Variablen haben, die noch nicht initialisiert wurden, und der Wert, den Sie erhalten, wenn Sie den Wert einer Objekteigenschaft oder eines Array-Elements abfragen, die bzw. das es nicht gibt. Der undefinierte Wert wird auch von Funktionen geliefert, die keinen Rückgabewert haben, und er wird als Wert für Funktionsparameter geliefert, für die kein Argument übergeben wurde. undefined ist eine vordefinierte globale Variable (kein Sprachschlüsselwort wie null), die auf den undefinierten Wert initialisiert ist. Wendet man den typeof-Operator auf den undefinierten Wert an, liefert er »undefined«. Das zeigt an, dass dieser Wert das einzige Exemplar eines speziellen Typs ist.

Trotz dieser Unterschiede können null und undefined beide das Fehlen eines Wertes anzeigen und häufig austauschbar verwendet werden. Der Gleichheitsoperator == betrachtet sie als gleich. (Nutzen Sie den strengen Gleichheitsoperator ===, wenn Sie sie unterscheiden müssen.) Beides sind falsche Werte und verhalten sich wie false, wenn ein boolescher Wert benötigt wird. Weder null noch undefined haben irgendwelche Eigenschaften oder Methoden. Wenn Sie versuchen, mit . oder [] auf eine Eigenschaft oder Methode eines dieser Werte zuzugreifen, führt das sogar zu einem TypeError .

Die vorangegangenen Abschnitte haben die elementaren Typen und Werte von JavaScript behandelt. Objekttypen – Objekte, Arrays und Funktionen – werden weiter unten im Buch in eigenständigen Kapiteln behandelt. Es gibt allerdings ein sehr wichtiges Objekt, das wir jetzt behandeln müssen. Das globale Objekt ist ein gewöhnliches JavaScript-Objekt, das einen sehr wichtigen Zweck erfüllt: Die Eigenschaften dieses Objekts sind die global definierten Symbole, die einem JavaScript-Programm zur Verfügung stehen. Wenn der JavaScript-Interpreter startet (oder ein Webbrowser eine neue Seite lädt), erstellt er ein neues globales Objekt und gibt ihm einen anfänglichen Satz von Eigenschaften, die Folgendes definieren:

Die anfänglichen Eigenschaften des globalen Objekts sind keine reservierten Wörter, verdienen es aber, als solche behandelt zu werden. Dieses Kapitel hat sich bereits mit einigen dieser globalen Eigenschaften befasst. Mit den meisten anderen werden wir uns an anderen Stellen dieses Buchs noch befassen.

Auf der obersten Codeebene – JavaScript-Code, der nicht Teil einer Funktion ist – können Sie das JavaScript-Schlüsselwort this nutzen, um auf das globale Objekt zu verweisen:

var global = this; // /Auf das globale Objekt verweisen.

Bei clientseitigem JavaScript dient das Window-Objekt als das globale Objekt. Dieses globale Window-Objekt hat eine selbstreferenzielle window-Eigenschaft, um auf das globale Objekt zu verweisen. Das Window-Objekt definiert die globalen Eigenschaften des Sprachkerns von JavaScript und darüber hinaus eine ganze Menge andere globale Eigenschaften, die für Webbrowser und clientseitiges JavaScript eigentümlich sind (siehe Chapter 10).

Nachdem es erstellt wurde, definiert das globale Objekt alle vordefinierten globalen Werte von JavaScript. Aber dieses spezielle Objekt hält auch von Programmen definierte globale Werte fest. Wenn Ihr Code eine globale Variable deklariert, ist diese Variable eine Eigenschaft des globalen Objekts.

JavaScript ist sehr flexibel in Bezug auf die Typen der Werte, die es verlangt. Bei booleschen Werten haben wir das bereits gesehen: Erwartet JavaScript einen booleschen Wert, können Sie einen Wert beliebigen Typs angeben, der von JavaScript in die erforderliche Form umgewandelt oder konvertiert wird. Einige Werte (wahre Werte) werden in true umgewandelt, andere (falsche Werte) in false. Das Gleiche erfolgt auch bei anderen Werten: Braucht JavaScript einen String, wandelt es den von Ihnen übergebenen Wert in einen String um. Braucht JavaScript eine Zahl, versucht es den von Ihnen angegebenen Wert in eine Zahl umzuwandeln (oder wandelt ihn in NaN um, wenn er nicht in eine vernünftige Zahl umgewandelt werden kann). Ein paar Beispiele:

10 + " Objekte"  // => "10 Objekte". 10 -> String
"7" * "4"        // => 28: Beide Strings -> Zahlen
var n = 1 - "x"; // => NaN: "x" kann nicht in eine Zahl 
                 // umgewandelt werden.
n + " objects"   // => "NaN Objekte": NaN -> "NaN"

Table 2-2 fasst zusammen, wie Werte in JavaScript von einem Typ in einen anderen umgewandelt werden. Fettgedruckte Tabelleneinträge unterstreichen Umwandlungen, die für Sie vielleicht überraschend sein könnten. Leere Zellen zeigen an, dass keine Umwandlung erforderlich ist und auch keine durchgeführt wird.

Weil JavaScript Werte so flexibel umwandeln kann, hat sein ==-Gleichheitsoperator auch einen sehr flexiblen Begriff von Gleichheit. Alle nachfolgenden Vergleiche sind beispielsweise wahr:

null == undefined // Diese beiden Werte werden als gleich 
                  // betrachtet.
"0" == 0          // Der String wird vor dem Vergleich in eine 
                  // Zahl umgewandelt.
0 == false        // Der boolesche Wert wird vor dem 
                  // Vergleich in eine Zahl umgewandelt.
"0" == false      // Beide Operanden werden vor dem 
                  // Vergleich in Zahlen umgewandelt.

Obgleich JavaScript viele Typumwandlungen automatisch durchführt, werden Sie gelegentlich genötigt sein, Umwandlungen explizit durchzuführen, oder vielleicht ziehen Sie es einfach vor, die Umwandlung explizit anzugeben, um den Code verständlicher zu machen.

Die einfachste Art, eine explizite Typumwandlung anzufordern, ist die Verwendung der Boolean()-, Number()-, String()- oder Object()-Funktionen :

Number("3")           // => 3
String(false)         // => "false" Oder false.toString()
Boolean([])           // => true
Object(3)             // => new Number(3)

Beachten Sie, dass alle Werte außer null und undefined eine toString()-Methode haben, deren Ergebnis üblicherweise dem entspricht, was von der Funktion String() geliefert wird.

Bestimmte JavaScript-Operatoren führen implizite Typumwandlungen durch und werden gelegentlich eingesetzt, um eine Typumwandlung zu erzwingen. Ist einer der Operanden des +-Operators ein String, wird der andere in einen String umgewandelt. Der unäre +-Operator wandelt seinen Operanden in eine Zahl um. Und der unäre !-Operator wandelt seinen Operanden in einen booleschen Wert um und negiert diesen. Diese Umstände sind für die folgenden Idiome für Typumwandlungen verantwortlich, auf die Sie gelegentlich in Code stoßen können:

x + "" // Das Gleiche wie String(x)
+x     // Das Gleiche wie Number(x). Auch x-0
!!x    // Das Gleiche wie Boolean(x). 
       // Beachten Sie das doppelte !.

Computer-Programme stehen häufig vor der Aufgabe, Zahlen formatieren und parsen zu müssen, und JavaScript besitzt spezialisierte Funktionen und Methoden, die eine genauere Kontrolle von Zahl/String- und String/Zahl-Umwandlungen ermöglichen.

Die toString()-Methode, die von der Klasse Number definiert wird, akzeptiert ein optionales Argument, das eine Basis für die Umwandlung angibt. Geben Sie dieses Argument nicht an, erfolgt die Umwandlung zur Basis 10. Aber Sie können auch Zahlen zu anderen Basen (zwischen 2 und 36) umwandeln. Zum Beispiel:

var n = 17;
binary_string = n.toString(2);      // Wird zu "10001" 
                                    // ausgewertet.
octal_string = "0" + n.toString(8); // Wird zu "021" 
                                    // ausgewertet.
hex_string = "0x" + n.toString(16); // Wird zu "0x11" 
                                    // ausgewertet.

Wenn Sie mit Daten aus dem Finanzwesen oder der Wissenschaft arbeiten, müssen Sie bei der Umwandlung von Zahlen in Strings gelegentlich genauer steuern können, wie viele Nachkommastellen oder signifikante Ziffern das Ergebnis hat, oder wollen erreichen, dass die wissenschaftliche Notation verwendet wird. Die Klasse Number definiert drei Methoden für derartige Zahl/String-Umwandlungen:

var n = 123456.789;
n.toFixed(2);         // "123456.79"
n.toExponential(3);   // "1.235e+5"
n.toPrecision(7);     // "123456.8"

Wenn Sie der Umwandlungsfunktion Number() einen String übergeben, versucht sie, den String als Ganzzahl- oder Gleitkommaliteral zu parsen. Diese Funktion funktioniert nur bei ganzen Zahlen zur Basis 10 und erlaubt nach dem Zahlliteral keine Zeichen, die nicht Teil des Literals sind. Die Funktionen parseInt() und parseFloat() (das sind globale Funktionen, nicht Methoden einer Klasse) sind flexibler. parseInt() parst nur ganze Zahlen, während parseFloat() ganze Zahlen und Gleitkommazahlen parst. Beginnt ein String mit »0x« oder »0X«, interpretiert parseInt() ihn als hexadezimale Zahl. parseInt() und parseFloat() überspringen Leerraum am Stringanfang, parsen so viele numerische Zeichen wie möglich und ignorieren alles, was darauf folgt. Wenn das erste Nicht-Whitespace-Zeichen kein zulässiger Bestandteil eines numerischen Literals ist, liefern beide NaN:

parseInt("3 blinde Mäuse")   // => 3
parseFloat(" 3.14 Meter")    // => 3.14
parseInt("-12.34")           // => -12
parseInt("0xFF")             // => 255
parseFloat("$72.47");        // => NaN

parseInt() akzeptiert ein optionales zweites Argument, über das die Basis der zu parsenden Zahl angegeben werden kann. Für dieses Argument sind Werte zwischen 2 und 36 erlaubt. Zum Beispiel:

parseInt("11", 2);           // => 3 (1*2 + 1)
parseInt("077", 8);          // => 63 (7*8 + 7)
parseInt("ff", 16);          // => 255 (15*16 + 15)

Bevor Sie in einem JavaScript-Programm eine Variable nutzen, sollten Sie diese deklarieren. Variablen werden folgendermaßen mit dem Schlüsselwort var deklariert:

var i;
var sum;

Sie können auch mehrere Variablen mit einem var-Schlüsselwort deklarieren:

var i, sum;

Und Sie können die Variablendeklaration mit der Variableninitialisierung kombinieren:

var message = "Hallo";
var i = 0, j = 0, k = 0;

Sie müssen in der var-Anweisung keinen Anfangswert für eine Variable angeben, aber wenn Sie es nicht tun, bleibt der Wert der Variablen undefined, bis Ihr Code einen Wert in ihr speichert.

Beachten Sie, dass die var-Anweisung auch als Teil der for- und for/in-Schleifen erscheinen kann (die in Chapter 4 eingeführt werden). Das ermöglicht Ihnen, die Variable auf kompakte Weise als Teil der Schleifensyntax selbst zu deklarieren. Zum Beispiel:

for(var i = 0; i < 10; i++) console.log(i);
for(var i = 0, j=10; i < 10; i++,j--) console.log(i*j);
for(var p in o) console.log(p);

Wenn Sie mit statisch typisierten Programmiersprachen wie C oder Java vertraut sind, wird Ihnen wahrscheinlich aufgefallen sein, dass bei den Variablendeklarationen von JavaScript kein Typ angegeben wird. Eine JavaScript-Variable kann einen Wert eines beliebigen Typs enthalten. Beispielsweise ist es in JavaScript vollkommen legal, einer Variable erst eine Zahl und später dann einen String zuzuweisen:

var i = 10;
i = "ten";

Es ist erlaubt und mit keinerlei Risiken verbunden, eine Variable mehrfach mit der var-Anweisung zu deklarieren. Hat die erneute Deklaration einen Initialisierer, verhält sie sich wie eine gewöhnliche Zuweisungsanweisung.

Versuchen Sie, den Wert einer nicht deklarierten Variablen zu lesen, meldet JavaScript einen Fehler. Im Strict-Modus von ECMAScript 5 (siehe den Abschnitt »use strict« in Chapter 4) ist es auch ein Fehler, wenn einer nicht deklarierten Variablen ein Wert zugewiesen wird. Aber in älteren Versionen und im Nicht-Strict-Modus erstellt JavaScript die Variable als Eigenschaft des globalen Objekts, wenn Sie einer undeklarierten Variable einen Wert zuweisen, und verhält sich dabei ähnlich wie bei einer ordentlich deklarierten globalen Variablen. Das heißt, dass Sie damit durchkommen können, wenn Sie Ihre globalen Variablen nicht deklarieren. Es ist jedoch eine schlechte Angewohnheit und eine Fehlerquelle. Sie sollten Ihre Variablen deswegen immer mit dem Schlüsselwort var deklarieren.

Die Geltung oder der Geltungsbereich einer Variablen ist der Bereich im Quellcode Ihres Programms, in dem sie definiert ist. Eine globale Variable hat globale Geltung und ist überall in Ihrem JavaScript-Code definiert. Variablen, die in einer Funktion deklariert wurden, sind hingegen nur im Inhalt dieser Funktion definiert. Es sind lokale Variablen mit lokaler Geltung. Funktionsparameter sind ebenfalls lokale Variablen und nur im Rumpf der Funktion definiert.

Wenn Sie Code im globalen Geltungsbereich schreiben, können Sie damit durchkommen, wenn Sie die var-Anweisung nicht verwenden. Aber wenn Sie lokale Variablen deklarieren, müssen Sie var immer verwenden. Funktionsdefinitionen können geschachtelt werden. Jede Funktion hat ihren eigenen lokalen Geltungsbereich. Man kann also mehrere geschachtelte Schichten lokaler Geltungsbereiche haben.

In C-artigen Programmiersprachen hat jeder Codeblock in geschweiften Klammern seinen eigenen Geltungsbereich, und Variablen sind nur in dem Geltungsbereich sichtbar, in dem sie deklariert wurden. Das bezeichnet man als Blockgeltung, die es in JavaScript aber nicht gibt. JavaScript nutzt stattdessen Funktionsgeltung: Variablen sind in der Funktion sichtbar, in der sie deklariert wurden, sowie in allen Funktionen, die in diese Funktion eingebettet sind.

Die Funktionsgeltung für Variablen in JavaScript bedeutet, dass alle in einer Funktion deklarierten Variablen innerhalb der gesamten Funktion definiert sind. Kurioserweise bedeutet das auch, dass Variablen sogar sichtbar sind, bevor sie deklariert wurden. Diese Einrichtung von JavaScript wird informell als Hoisting, »Heben«, bezeichnet: JavaScript-Code verhält sich, als stünden alle Variablendeklarationen in einer Funktion (aber nicht die entsprechenden Zuweisungen) am Anfang der Funktion (als wären sie dorthin verschoben oder »gehoben« worden).