Werte, Variablen und Literale

  • Adressname der Version: JavaScript/javascript_guide/Werte,_Variablen_und_Literale
  • Titel der Version: Werte, Variablen und Literale
  • ID der Version: 13097
  • Erstellt:
  • Autor: eminor
  • Aktuelle Version? Nein
  • Kommentar 2 words added, 1 words removed

Inhalt der Version

Dieses Kapitel informiert über die Werte mit denen JavaScript arbeitet und beschreibt die grundlegenden Elemente von Ausdrücken: Variablen, Konstanten und Literale.

Werte

JavaScript kennt die folgenden verschiedenen Typen von Werten:

  • Numbers (numerische Werte), wie 42 or 3.14159
  • Boolean (boolesche Werte),  true oder false
  • Strings (Zeichenketten), wie z.B. "Hallo!"
  • null, ein spezielles Schlüsselwort, das einen null-Wert beschreibt; null ist auch ein primitiver Wert. Da JavaScript zwischen Groß- und Kleinschreibung unterscheidet, ist null nicht dasselbe wie Null, NULL oder jede andere Variante.
  • undefined, eine Top-Level-Eigenschaft, deren Wert undefiniert ist; undefined ist auch ein primitiver Wert.

Dieser relativ kleine Satz von unterschiedlichen Typen für Werte, auch Datentypen genannt, ermöglicht die Erstellung nützlicher Funktionen in Applikationen. Es gibt keine echte Unterscheidung zwischen Ganzzahlen und Gleitkommazahlen, beide sind vom Typ Number. Bei Operationen mit Kalenderdaten, Zeitpunkten und Datumsformaten kann mit dem Date-Objekt gearbeitet werden.

Objekte und Funktionen sind weitere Kernelemente der Sprache. Objekte kann man sich wie benannte Container für Werte vorstellen und Funktionen wie Prozeduren, die in der Applikation ausgeführt werden können.

Konvertierung von Datentypen

Javascript ist eine dynamisch typisierte Programmiersprache. Das bedeutet, dass der Typ einer Variablen nicht festgelegt werden muss, bevor ihr ein Wert zugewiesen wird. Eine Variable muss also nicht erst durch die Spezifikation eines Datentyps deklariert werden, wie meist bei anderen Programmiersprachen. Außerdem werden Datentypen automatisch so konvertiert, wie sie bei der Ausführung des Skripts benötigt werden.

Eine Variable kann z.B. so definiert werden:

var antwort = 42;

Später kann man derselben Variablen z.B. einen String zuweisen:

antwort = "Danke für den Fisch...";

Da Javascript dynamisch typisiert ist, erzeugt diese Zuweisung keine Fehlermeldung.

Wenn man in Ausdrücken numerische Werte (Numbers) und Zeichenketten (Strings) mit dem Operator + (Pluszeichen) verbindet, werden die numerischen Werte von Javascript automatisch in Strings umgewandelt:

x = "Die Antwort ist " + 42  // ergibt: "Die Antwort ist 42"
y = 42 + " ist die Antwort"  // ergibt: "42 ist die Antwort"

Werden bei Ausdrücken jedoch andere Operatoren verwendet, konvertiert Javascript den Wert nicht automatisch zu einem String:

"37" - 7 // returns 30
"37" + 7 // returns "377"

Konvertieren von Strings zu Numbers

Falls sich ein numerischer Wert in Form eines Strings im Speicher befindet, kann er mit passenden Methoden konvertiert werden.

parseInt() und parseFloat()

Siehe: parseInt() und parseFloat().

Die Methode parseInt gibt ausschließlich ganze Zahlen zurück, daher ist ihr Nutzen auf Dezimalzahlen beschränkt. Bei parseInt sollte man immer den radix-Parameter mit angeben.

Plus-Operator

Eine alternative Methode, um einen numerischen Wert aus einem String zu erhalten, ist die Verwendung des Operators + (Pluszeichen):

"1.1" + "1.1" = "1.11.1"
(+"1.1") + (+"1.1") = 2.2   // Anführungszeichen dienen der Übersichtlichkeit, nicht unbedingt nötig.

Variablen

Variablen werden als symbolische Namen für Werte eingesetzt. Die Namen der Variablen werden Bezeichner (oder engl. Identifier) genannt und folgen gewissen Regeln.

Ein JavaScript-Bezeichner muss mit einem Buchstaben, Unterstrich (_) oder Dollar-Zeichen ($) beginnen. Die darauf folgenden Zeichen dürfen auch Ziffern sein (0-9). Da JavaScript zwischen Groß- und Kleinschreibung unterscheidet, sind mit Buchstaben sowohl "A" bis "Z" (Großbuchstaben)  als auch "a" bist "z" (Kleinbuchstaben) gemeint.

Ab JavaScript 1.5 sind bei Bezeichnern auch Buchstaben aus den Zeichensätzen ISO 8859-1 oder Unicode wie å oder ü erlaubt. Außerdem dürfen auch die \uXXXX {{ web.link("#Unicode_escape_sequences", "Unicode-Escape-Sequenzen") }} bei Identifiern verwendet werden.

Ein paar Beispiele von zulässigen Bezeichnern: Number_hits, temp99, and _name.

Deklarieren von Variablen

Variablen kann man auf zwei verschiedene Arten deklarieren:

  • Mit dem Schlüsselwort var, welches dem Bezeichner vorangestellt wird: var x = 42. Auf diese Weise können sowohl lokale als auch globale Variablen deklariert werden.
  • Indem einfach einer Variablen ein Wert zugewiesen wird: x = 42. Dies erzeugt immer eine globale Variable und eine strikte JavaScript-Warnung. Deshalb wird von dieser Vorgehensweise abgeraten.

Auswerten von Variablen

Eine Variable, die mit dem var-Schlüsselwort deklariert wurde, ohne dass ihr ein Wert zugewiesen wurde, besitzt den Wert undefined.

Der Versuch, auf eine undeklarierte Variable zuzugreifen, scheitert mit dem Ergebnis einer ReferenceError-Ausnahmebehandlung:

var a;
console.log("Der Wert von a ist " + a); // gibt aus: "Der Wert von a ist undefined"
console.log("Der Wert von b ist " + b); // erzeugt ReferenceError-Ausnahmebehandlung

Ersteres Verhalten kann man sich zunutze machen, um zu überprüfen, ob eine Variable einen Wert enthält. Im folgenden Code-Beispiel wurde der Variablen myVar kein Wert zugewiesen und die Prüfung mit einer if-Anweisung ergibt deshalb true.

var myVar;
if(myVar === undefined){
  alert("myVar ist kein Wert zugewiesen.");
} else {
  alert("myVar ist ein Wert zugewiesen.");
}

Folgende Erläuterungen hängen mit den Beschreibungen zu Variablen zusammen. Je nachdem in welchem Kontext Variablen gebraucht und ausgewertet werden, werden die Werte unterschiedlich interpretiert.

Der Wert undefined evaluiert zu false, wenn er in einem booleschen Kontext verwendet wird. Zum Beispiel wird bei folgendem Code die Funktion myFunction ausgeführt, weil das Element myArray nicht definiert ist:

var myArray = new Array();
if (!myArray[0]) myFunction();

In numerischem Kontext wird undefined hingegen zu NaN konvertiert:

var a;
a + 2 = NaN

Eine Variable, die mit null deklariert ist, evaluiert in numerischem Kontext zu 0 und in booleschem Kontext zu false:

var n = null;
console.log(n * 32); // prints 0

Sichtbarkeitsbereich (Scope) von Variablen

Eine Variable, die außerhalb einer Funktion deklariert wird, ist eine globale Variable. Globale Variablen sind im ganzen Programm sichtbar und der Zugriff kann über den Code im Dokument von beliebiger Stelle aus erfolgen. Hingegen sind Variablen, die innerhalb von Funktionen definiert werden, lokale Variablen, die nur innerhalb der Funktion angesprochen werden können.

JavaScript grenzt die Sichtbarkeit von Block-Anweisungen nicht ein. Variablen innerhalb von Block-Anweisungen sind lokal zu dem Code, in dem sich der Anweisungsblock befindet. Zum Beispiel wird der folgende Code 5 in der Konsole ausgeben, weil die Sichtbarkeit von x auf die äußere Funktion (oder den globale Kontext) beschränkt ist und nicht auf den Block der if-Anweisung.

if (true) {
  var x = 5;
}
console.log(x);

Eine weitere Besonderheit bei Variablen in JavaScript ist, dass man sich auf eine Variable beziehen kann, die erst später deklariert wurde, ohne einen Ausnahmefehler zu erhalten. Dieses Konzept ist als "hoisting" (engl. Hochziehen) bekannt. Variablen in JavaScript werden gewissermaßen zum Anfang der Funktion hochgezogen oder angehoben. Jedoch liefern nicht initialisierte Variablen den Wert undefined.

// Beispiel 1

console.log(x === undefined); // loggt "true"
var x = 3;


// Beispiel 2

// gibt undefined zurück
var myVar = "mein Wert";

(function() {
  console.log(myVar); // undefined
  var myVar = "lokaler Wert";
})();

Das Beispiel 2 oben wird vom JavaScript-Interpreter so gedeutet:

var myVar = "mein Wert";

(function() {
  var myVar;  // hoisting
  console.log(myVar); // undefined
  myVar = "lokaler Wert";
})();

Aufgrund des "hoisting" sollten alle var-Anweisungen in einer Funktion so nahe wie möglich an den Anfang platziert werden. Diese Vorgehensweise verbessert die Übersichtlichkeit des Codes.

Globale Variablen

need links to pages discussing scope chains and the global object

Globale Variablen sind tatsächlich Eigenschaften des globalen Objekts. Bei Webseiten ist das globale Objekt window, sodass man globale Variablen über die Syntax window.variable ansprechen kann.

Globale Variablen, die in einem Fenster oder Frame deklariert wurden, lassen sich von einem anderen Fenster oder Frame aus ansprechen, indem man den Namen des Fensters oder Frames spezifiziert. Wenn z.B. eine globale Variable Telefonnummer auf einer Webseite deklariert wurde, die ein FRAMESET enthält, lässt sich diese von den Frames aus ansprechen.

Konstanten

Mit dem Schlüsselwort const erzeugt man Konstanten. Die Syntax für Bezeichner von Konstanten ist dieselbe wie bei Variablen.

const prefix = '212';

Der Wert einer Konstanten kann während der Laufzeit des Skripts nicht geändert und nicht neu deklariert werden.

Auch die Sichtbarkeitsregeln für Konstanten sind dieselben wie bei Variablen, außer dass das Schlüsselwort const zwingend angegeben werden muss. Dies gilt auch für globale Konstanten. Wenn das Schlüsselwort nicht angegeben wird, wird der Bezeichner als Variable interpretiert.

Es ist nicht erlaubt, Konstanten und Variablen mit dem Namen einer Funktion oder Variablen innerhalb desselben Sichtbarkeitsbereichs zu deklarieren:

// LOEST EINEN ERROR AUS
function f() {};
const f = 5;

// EBENFALLS ERROR
function f() {
  const g = 5;
  var g;

  // Anweisungen
}

Literale

Literale repräsentieren feste Werte in JavaScript, die buchstäblich festgelegt werden.

  • {{ web.link("#Array_literals", "Array-Literale") }}
  • {{ web.link("#Boolean_literals", "Boolean-Literale") }}
  • {{ web.link("#Floating-point_literals", "Gleitkommazahlen-Literale") }}
  • {{ web.link("#Integers", "Ganzzahlen (Integer)") }}
  • {{ web.link("#Object_literals", "Objekt-Literale") }}
  • {{ web.link("#String_literals", "String-Literale") }}

Array-Literale

Ein Array-Literal ist eine Liste von Null oder mehreren Ausdrücken von denen jeder ein Array-Element repräsentiert. Arrays werden in eckige Klammern ([]) eingeschlossen. Wenn man ein Array über ein Array-Literal erstellt, wird es mit den angegebenen Werten als dessen Elemente initialisiert. Die Länge des Arrays entspricht dann der Anzahl der Elemente.

Im folgenden Beispiel wird das Array Kaffees mit drei Elementen und einer Länge von 3 erstellt:

var Kaffees = ["French Roast", "Colombian", "Kona"];

Merke: Ein Array ist eine Art Objekt-Initializer. Siehe Using Object Initializers.

Wenn ein Array über einen Literal in einem Top-Level-Skript erstellt wird, interpretiert JavaScript das Array jedes Mal erneut, wenn die Anweisung evaluiert wird, welche den Array-Literal enthält. Ein Literal innerhalb einer Funktion wird jedes Mal neu erstellt, wenn die Funktion ausgeführt wird.

Array-Literale sind auch Objekte. Im Abschnitt zu Array-Objekten findet man weitere Informationen.

Extra Kommas in Array-Literalen

In einem Array-Literal müssen nicht alle Elemente angegeben werden. Wenn man zwei Kommas nacheinander schreibt, also die Stelle für ein Element frei lässt, bekommt das entsprechende Element den Wert undefined:

var fish = ["Lion", , "Angel"];   // fish[1] ist undefined

Dieses Array hat zwei Elemente mit String-Werten und ein leeres Element. Da man mit 0 zu zählen beginnt, ist das erste Element fish[0] und hat den Wert "Lion". Das zweite Element ist fish[1] und undefined. Das dritte Element fish[2] hat den Wert "Angel".

Wenn man ein zusätzliches Komma am Ende der Liste angibt, wird dieses Komma ignoriert. Beim folgenden Beispiel ist die Länge des Arrays drei. Demzufolge existiert kein Element myList[3], weil man ja mit 0 zu zählen beginnt. (Merke: Die Kommas am Ende können zu Fehlern bei älteren Browsern führen und es ist am besten, sie zu entfernen).

var myList = ['home', , 'school', ];

Beim folgenden Beispiel ist die Länge des Arrays vier. Die Elemente myList[0] und myList[2] fehlen und sind darum undefined.

var myList = [ , 'home', , 'school'];

Noch ein Beispiel: Die Länge des Arrays ist hier ebenfalls vier. Die Elmente myList[1] und myList[3] fehlen und nur das letzte Komma wird ignoriert.

var myList = ['home', , 'school', , ];

Es ist wichtig zu verstehen, was zusätzliche Kommas bewirken, um JavaScript als Sprache zu verstehen. Wenn man aber selbst Code schreibt, ist es besser, die fehlenden Elemente mit undefined zu deklarieren, um die Lesbarkeit, Übersichtlichkeit und Wartbarkeit zu verbessern.

Boolean-Literale

Der boolesche Datentyp kennt zwei literale Werte: true und false.

Die primitiven booleschen Werte sollten nicht mit den true- und false-Werten des booleschen Objekts verwechselt werden. Das boolesche Objekt ist eine Hülle für den primitiven booleschen Datentyp. Siehe Boolean-Objekt für mehr Informationen.

Integer (ganze Zahlen)

Integer können mit Dezimalzahlen (Basis: 10), Hexadezimalzahlen (Basis: 16) und Oktalzahlen (Basis: 8) ausgedrückt werden.

  • Literale mit dezimalen Ganzzahlen bestehen aus einer Reihe von Ziffern, ohne eine führende 0 (Null).
  • Eine 0 (Null) an erster Stelle bedeutet, dass es sich um eine Oktalzahl handelt.  Oktalzahlen können außschließlich die Ziffern 0-7 beinhalten.
  • Eine Hexadezimalzahl kennzeichnet sich durch 0x (oder 0X) am Anfang. Hexadezimale Zahlen bestehen aus den Ziffern 0-9 und den Buchstaben A-F.

Oktalzahlen-Literale sind veraltet und wurden aus dem Standard ECMA-262, Edition 3 (im strict mode) entfernt. JavaScript 1.5 unterstützt sie aber weiterhin aus Gründen der Abwärtskompatibilität.

Ein paar Beispiele von Integer-Literalen sind:

0, 117 und -345 (dezimal, Basis 10)
015, 0001 and -077 (oktal, Basis 8) 
0x1123, 0x00111 and -0xF1A7 (hexadezimal, "hex" oder Basis 16)

Gleitkommazahlen-Literale

Eine Gleitkommazahl kann folgende Bestandteile haben:

  • Eine Dezimalzahl mit Vorzeichen ( "+" oder "-"),
  • Einen Dezimalpunkt ("."),
  • Einen Bruchteil mit weiteren Dezimalzahlen,
  • Einen Exponenten.

Der Teil mit dem Exponent ist ein "e" oder "E" gefolgt von einer Ganzzahl, die ein Vorzeichen haben kann ("+" or "-"). Eine Gleitkommazahl muss mindestens eine Ziffer besitzen und einen Dezimalpunkt oder "e" (oder "E").

Ein paar Beispiele für Gleitkommazahlen-Literale sind 3.1415, -3.1E12, .1e12 und 2E-12.

Beschreibung der Syntax:

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

Weitere Beispiele:

3.14
2345.789
.3333333333333333333

Objekt-Literale

Ein Objekt-Literal ist eine Liste von Null oder mehreren Paaren von Eigenschaftsnamen und assoziierten Werten, die zu einem Objekt gehören, eingeschlossen in geschweifte Klammern ({}). Ein Objekt-Literal sollte nicht am Anfang einer Anweisung verwendet werden. Dies führt zu einem Fehler oder verhält sich anders als gewollt, weil die erste Klammer wie der Anfang eines Blocks interpretiert wird.

Das folgende Beispiel zeigt ein Objekt-Literal. Das erste Element des Objekts car definiert eine Eigenschaft myCar,.Das zweite Element, die Eigenschaft getCar, ruft eine Funktion CarTypes("Honda") auf. Das dritte Element, die Eigenschaft special, benutzt eine existierende Variable (Sales).

var Sales = "Toyota";

function CarTypes(name) {
  return (name == "Honda") ?
    name :
    "Sorry, we don't sell " + name + "." ;
}

var car = { myCar: "Saturn", getCar: CarTypes("Honda"), special: Sales };

console.log(car.myCar);   // Saturn
console.log(car.getCar);  // Honda
console.log(car.special); // Toyota 

Des Weiteren kann man einen numerischen Literal oder String-Literal für den Namen der Eigenschaft benutzen oder Objekte ineinander verschachteln:

var car = { manyCars: {a: "Saab", "b": "Jeep"}, 7: "Mazda" };

console.log(car.manyCars.b); // Jeep
console.log(car[7]); // Mazda

Merke:

var foo = {a: "alpha", 2: "zwei"};
console.log(foo.a);    // alpha
console.log(foo[2]);   // zwei
//console.log(foo.2);  // Error: fehlende ) nach der Argumentliste
//console.log(foo[a]); // Error: a ist nicht definiert
console.log(foo["a"]); // alpha
console.log(foo["2"]); // zwei

String-Literale

String-Literale können aus Null oder mehr Zeichen bestehen. Sie werden in doppelten (") oder einfachen (') Anführungszeichen eingeschlossen. Dabei muss der Typ der beiden Anführungszeichen am Anfang und Ende stets derselbe sein, d.h. entweder sind beide Anführungszeichen einfach oder doppelt.

Hier ein paar Beispiele für String-Literale:

  • "foo"
  • 'bar'
  • "1234"
  • "Eine Zeile \n Noch eine Zeile"
  • "John's Katze

Jede der Methoden des String-Objekts kann man auf einen String anwenden - JavaScript konvertiert den String-Literal automatisch zu einem temporären String-Objekt, ruft die Methode auf und verwirft das temporäre Objekt wieder. Auch die Eigenschaften String.length kann bei String-Literale benutzt werden:

"John's Katze".length

String-Literale sollte man verwenden, solange man kein String-Objekt benötigt. Siehe String Object für mehr Informationen.

Escape-Sequenzen in Strings

Außer den normalen Zeichen kann man auch die sogenannten Escape-Sequenzen in Strings verwenden. Das sind eine Reihe von speziellen Zeichenkombinationen, die mit einem Backslash beginnen und eine Sonderbedeutung haben.

"Eine Zeile \n Noch eine Zeile"

Die folgende Tabelle listet die speziellen Zeichen (und deren Bedeutung) auf, die in JavaScript benutzt werden können.


Tabelle 2.1 Escape-Sequenzen bei JavaScript
Sequenz Bedeutung
\b Rückschritt (Backspace)
\f Seitenvorschub (Form feed)
\n Zeilenvorschub (New line)
\r Wagenrücklauf (Carriage return)
\t Horizontaler Tabulator
\v Vertikaler Tabulator
\' Apostroph oder einfaches Anführungszeichen
\" Doppeltes Anführungszeichen
\\ Umgekehrter Schrägstrich (\).
\XXX Das Zeichen aus dem Zeichensatz Latin-1 mit Angabe der dreistelligen oktalen Zahl XXX zwischen 0 und 377. Zum Beispiel ist \251 die oktale Sequenz für das Copyright-Symbol.
\xXX Das Zeichen aus dem Zeichensatz Latin-1 mit Angabe der zweistelligen hexadezimalen Zahl XX zwischen 00 und FF. Zum Beispiel ist \xA9 die hexadezimale Sequenz für das Copyright-Symbol.
\uXXXX Das Unicode-Zeichen mit Angabe der vierstelligen hexadezimalen Zahl XXXX. Zum Beispiel ist \u00A9 die Unicode-Sequenz für das Copyright-Symbol. Siehe {{ web.link("#Unicode_escape_sequences", "Unicode Escape-Sequenzen") }}.

Escapen-Sequenzen

Bei Zeichen, die nicht in der Tabelle aufgelistet sind, wird ein Backslash ignoriert, sollte jedoch vermieden werden (veraltet).

Innerhalb eines Strings kann man Anführungszeichen verwenden, indem man einen Backslash voranstellt. Dies wird als escapen eines Anführungszeichens bezeichnet. Zum Beispiel:

var buchtitel = "Sie liest \"Per Anhalter durch die Galaxis\" von Douglas Adams.";
console.log(buchtitel);

Das Resultat wäre:

Sie liest "Per Anhalter durch die Galaxis" von Douglas Adams.

Um einen normalen Backslash in einen Strings einzufügen, muss man diesen escapen. Hier ein Beispiel für eine Zuweisung mit einem Dateipfad:

var home = "c:\\temp";

Darüber hinaus kann man auch Zeilenumbrüche markieren (escapen), indem man einen Backslash als letztes Zeichen (vor den Zeilenumbruch) schreibt. Beim Ergebnis wird sowohl der Backslash als auch der Zeilenumbruch aus dem String entfernt.

var str = "Dieser String \
ist über \
mehrere Zeilen \
verteilt."
console.log(str);   // Dieser String ist über mehrere Zeilen verteilt.

Obwohl JavaScript nicht die "heredoc"-Syntax unterstützt, kann man Ähnliches erreichen, indem man am Ende der Zeile einen Zeilenvorschub (new line) einfügt und anschließend den Zeilenumbruch markiert:

var poem = 
"Rosen sind rot,\n\
Veilchen sind blau.\n\
Ich bin schizophren\n\
Und das bin ich auch."

Unicode

Unicode ist ein internationaler Standard, in dem langfristig für jedes sinntragende Schriftzeichen oder Textelement aller bekannten Schriftkulturen und Zeichensysteme ein digitaler Code festgelegt wird. Ziel ist es, die Verwendung unterschiedlicher und inkompatibler Kodierungen in verschiedenen Ländern oder Kulturkreisen zu beseitigen. Unicode wird ständig um Zeichen weiterer Schriftsysteme ergänzt.

Der Unicode-Zeichensatz kann für alle bekannten Kodierungen benutzt werden. Unicode ist nach dem ASCII-Zeichensatz entworfen. Jedes Zeichen hat einen numerischen Wert und einen Namen. Die Zeichenkodierung beschreibt die Identität des Zeichens und den numerischen Wert (Code-Position), als auch die Repräsentation des Werts in Bits. Der 16-Bit breite numerische Wert (digitaler Code) definiert sich durch eine hexadezimale Zahl und ein Prefix U. zum Beispiel steht U+0041 für den Buchstaben A. Der individuelle Name für diesen Buchstaben ist LATIN CAPITAL LETTER A.

Unicode wird nicht von JavaScript vor Version 1.3 unterstützt.

Unicode Kompatiblität zu ASCII und ISO

Unicode ist vollständig kompatibel mit dem internationalen Standard ISO/IEC 10646-1; 1993, welcher eine Untermenge von ISO 10646 ist. ISO 10646 ist die von ISO verwendete, praktisch bedeutungsgleiche Bezeichnung des Unicode-Zeichensatzes; er wird dort als Universal Character Set (UCS) bezeichnet.

Neben dem eigentlichen Zeichensatz sind auch eine Reihe von Zeichenkodierungen definiert, die den Unicode-Zeichensatz implementieren und die eingesetzt werden können, um den vollen Zugriff auf alle Unicode-Zeichen zu gewährleisten. Sie werden Unicode Transformation Format (kurz UTF) genannt.

Die Kodierung UTF-8 ist kompatibel mit ASCII und wird von vielen Programmen unterstützt. Die ersten 128 Unicode-Zeichen sind die gleichen wie beim ASCII-Zeichensatz und haben denselben Bytewert. Die Unicode-Zeichen U+0020 bis U+007E sind equivalent zu den ASCII-Zeichen 0x20 bis 0x7E. Anders als der ASCII-Zeichensatz, der das lateinische Alphabet in Groß- und Kleinschreibung, die zehn arabischen Ziffern und diverse nicht druckbare Zeichen enthält und jedem Zeichen ein Bitmuster aus 7-Bit zuordnet, sind UTF-8-Zeichen zwischen einem und vier Oktetts (Oktett bedeutet ein Byte oder 8 Bit) breit. Dies erlaubt die Darstellung von merhreren Millionen verschiedenen Zeichen.

Ein alternativer Kodierungsstandard namens UTF-16 verwendet zwei Oktett, um die Unicode-Zeichen darzustellen. Eine Escape-Sequenz erlaubt UTF-16 die ganze Spanne des Unicode-Zeichensatzes mit vier Oktett aufzunehmen. Der ISO UCS-2 (Universal Character Set) verwendet zwei Oktetts.

Die Unterstützung bei JavaScript und Navigator für UTF-8/Unicode erlaubt die Nutzung von nicht-lateinischen, internationalen und lokalisierten Zeichen, plus besondere technische Symbole in JavaScript-Programmen. Unicode definiert eine Standardmethode für die Kodierung von mehrsprachigem Text. Da die UTF-8-Kodierung kompatibel mit ASCII ist, können Programme auch ASCII-Zeichen verwenden. Zeichen, die nicht im ASCII enthalten sind, kann man in Kommentaren, String-Literalen, Bezeichner und regulären Ausdrücken verwenden.

Unicode Escape-Sequenzen

Die Unicode-Escape-Sequenzen dürfen in String-Literalen, regulären Ausdrücken und Bezeichner zum Einsatz kommen. Die Escape-Sequenzen bestehen aus sechs ASCII-Zeichen: den ersten beiden Zeichen "\u" und anschließend einer vierstelligen hexadezimale Zahl. Zum Beispiel steht \u00A9 für das Copyright-Symbol. Jede Unicode-Escape-Sequenz in JavaScript wird als ein Zeichen interpretiert.

Der folgende Code liefert das Copyright-Symbol und den String "Mozilla Firefox".

var x = "\u00A9 Mozilla Firefox";

In der nachstehenden Tabelle werden die oft gebrauchten Zeichen und ihr Unicode-Wert aufgelistet.

Tabelle 2.2 Unicode-Werte für Zeichenfolgen mit Sonderbedeutung
Kategorie Unicode-Wert Name Formatname
Zwischenraumzeichen (Whitespace) \u0009 Horizontaler Tabulator (Tab) <TAB>
\u000B Vertikaler Tabulator <VT>
\u000C Seitenvorschub (Form Feed) <FF>
\u0020 Leerzeichen (Space) <SP>
Zeilenumbruch \u000A Zeilenvorschub (Line Feed) <LF>
\u000D Wagenrücklauf (Carriage Return) <CR>
Weitere Unicode-Escape-Sequenzen \u0008 Rückschritt (Backspace) <BS>
\u0009 Horizontal Tabulator (Tab) <HT>
\u0022 Doppelte Anführungszeichen "
\u0027 Einfache Anführungszeichen '
\u005C Umgekehrter Schrägstrich (Backslash) \

Bei JavaScript läuft die Interpretation der Unicode-Escape-Sequenzen etwas anders ab als bei Java. JavaScript betrachtet Escape-Sequenzen nie zuerst als eine Zeichenfolge mit Sonderbedeutung. Ein String wird z.B. nicht durch eine Zeilenumbruch-Sequenz beendet, bevor die Sequenz von einer Funktion ausgewertet wurde. JavaScript ignoriert alle Escape-Sequenzen in Kommentaren. Bei Java wird eine Escape-Sequenz als Unicode-Zeichen interpretiert, sofern sie in einem einzeiligen Kommentar steht. Bei String-Literalen interpretiert der Java-Compiler zuerst die Escape-Sequenz. Wenn in Java z.B. ein Unicode-Zeilenvorschub (\u000A) benutzt wird, beendet dieser den String-Literal. Möchte man einen Zeilenvorschub in einem String erreichen, muss man stattdessen auf \n zurückgreifen. Bei JavaScript hingegen funktioniert ein Unicode-Zeilenvorschub genau wie bei Verwendung von \n.

Unicode-Zeichen in JavaScript-Dateien

Frühere Versionen von Gecko nahmen für Javascript-Dateien an, dass sie mit dem Latin-1-Zeichensatz kodiert sind. Seit Gecko 1.8 wird die Zeichenkodierung von der XUL-Datei übernommen. Unter International characters in XUL JavaScript findet man mehr Informationen.

Anzeigen von Zeichen mit Unicode

Mit Unicode kann man Zeichen für verschiedene Sprachen und technische Symbole anzeigen lassen. Damit die Zeichen richtig dargestellt werden, muss die Client-Software wie z.B. Firefox die Unicode-Zeichenkodierung unterstützen. Außerdem muss dem Client ein brauchbarer Unicode-Font zur Verfügung stehen und die Plattform muss Unicode ebenfalls unterstützen. Meistens können Unicode-Fonts nicht alle Zeichen darstellen. Manche Plattformen, wie z.B. Windows 95, unterstützen Unicode nur zum Teil.

Um nicht-ASCII-Zeicheneingaben zu erhalten, muss der Client die Eingabe als Unicode senden. Bei der Benutzung einer Standard-Tastatur kann der Client viele der Zeichen nicht so einfach eingeben, die von Unicode unterstützt werden. Deshalb ist manchmal die Verwendung von Unicode-Escape-Sequenzen die einzige Möglichkeit.

Für mehr Informationen zu Unicode, werfen sie einen Blick auf die Unicode-Homepage und den Unicode-Standard, Version 2.0, erschienen im Verlag Addison-Wesley, 1996.

autoPreviousNext("JSGChapters");
wiki.languages({
  "zh-tw": "zh_tw/Core_JavaScript_1.5_教學/JavaScript_概要",
  "es": "es/Gu\u00eda_JavaScript_1.5/Concepto_de_JavaScript",
  "fr": "fr/Guide_JavaScript_1.5/Aper\u00e7u_de_JavaScript",
  "ja": "ja/Core_JavaScript_1.5_Guide/JavaScript_Overview",
  "ko": "ko/Core_JavaScript_1.5_Guide/JavaScript_Overview",
  "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Przegl\u0105d_JavaScriptu",
  "zh-cn": "cn/Core_JavaScript_1.5_Guide/JavaScript\u603b\u89c8"
});

Quelltext der Version

<p>Dieses Kapitel informiert über die Werte mit denen JavaScript arbeitet und beschreibt die grundlegenden Elemente von Ausdrücken: Variablen, Konstanten und Literale.</p>
<h2>Werte</h2>
<p>JavaScript kennt die folgenden verschiedenen Typen von Werten:</p>
<ul> <li><a href="/en/JavaScript/Reference/Global_Objects/Number" title="en/JavaScript/Reference/Global Objects/Number">Numbers</a> (numerische Werte), wie 42 or 3.14159</li> <li><a href="/en/JavaScript/Reference/Global_Objects/Boolean" title="en/JavaScript/Reference/Global Objects/Boolean">Boolean (boolesche Werte</a>),  <code>true</code> oder <code>false</code></li> <li><a href="/en/JavaScript/Reference/Global_Objects/String" title="en/JavaScript/Reference/Global Objects/String">Strings</a> (Zeichenketten), wie z.B. "Hallo!"</li> <li><code>null</code>, ein spezielles Schlüsselwort, das einen null-Wert beschreibt; <code>null</code> ist auch ein primitiver Wert. Da JavaScript zwischen Groß- und Kleinschreibung unterscheidet, ist <code>null</code> nicht dasselbe wie <code>Null</code>, <code>NULL</code> oder jede andere Variante.</li> <li><code><a href="/en/JavaScript/Reference/Global_Objects/undefined" title="en/JavaScript/Reference/Global Objects/undefined">undefined</a></code>, eine Top-Level-Eigenschaft, deren Wert undefiniert ist; <code>undefined</code> ist auch ein primitiver Wert.</li>
</ul>
<p>Dieser relativ kleine Satz von unterschiedlichen Typen für Werte, auch <em>Datentypen</em> genannt, ermöglicht die Erstellung nützlicher Funktionen in Applikationen. Es gibt keine echte Unterscheidung zwischen Ganzzahlen und Gleitkommazahlen, beide sind vom Typ <em>Number</em>. Bei Operationen mit Kalenderdaten, Zeitpunkten und Datumsformaten kann mit dem <code><a href="/en/JavaScript/Reference/Global_Objects/Date" title="en/JavaScript/Reference/Global Objects/Date">Date</a></code>-Objekt gearbeitet werden.</p>
<p><a href="/en/JavaScript/Reference/Global_Objects/Object" title="en/JavaScript/Reference/Global Objects/Object">Objekte</a> und <a href="/en/JavaScript/Reference/Global_Objects/Function" title="en/JavaScript/Reference/Global Objects/Function">Funktionen </a>sind weitere Kernelemente der Sprache. Objekte kann man sich wie benannte Container für Werte vorstellen und Funktionen wie Prozeduren, die in der Applikation ausgeführt werden können.</p>
<h3>Konvertierung von Datentypen</h3>
<p>Javascript ist eine dynamisch typisierte Programmiersprache. Das bedeutet, dass der Typ einer Variablen nicht festgelegt werden muss, bevor ihr ein Wert zugewiesen wird. Eine Variable muss also nicht erst durch die Spezifikation eines Datentyps deklariert werden, wie meist bei anderen Programmiersprachen. Außerdem werden Datentypen automatisch so konvertiert, wie sie bei der Ausführung des Skripts benötigt werden.</p>
<p>Eine Variable kann z.B. so definiert werden:</p>
<pre class="brush: js"><code>var antwort = 42;</code>
</pre>
<p>Später kann man derselben Variablen z.B. einen String zuweisen:</p>
<pre class="brush: js">antwort = "Danke für den Fisch...";
</pre>
<p>Da Javascript dynamisch typisiert ist, erzeugt diese Zuweisung keine Fehlermeldung.</p>
<p>Wenn man in Ausdrücken numerische Werte (Numbers) und Zeichenketten (Strings) mit dem Operator <code>+</code> (Pluszeichen) verbindet, werden die numerischen Werte von Javascript automatisch in Strings umgewandelt:</p>
<pre class="brush: js">x = "Die Antwort ist " + 42  // ergibt: "Die Antwort ist 42"
y = 42 + " ist die Antwort"  // ergibt: "42 ist die Antwort"
</pre>
<p>Werden bei Ausdrücken jedoch andere Operatoren verwendet, konvertiert Javascript den Wert nicht automatisch zu einem String:</p>
<pre class="brush: js">"37" - 7 // returns 30
"37" + 7 // returns "377"
</pre>
<h3>Konvertieren von Strings zu Numbers</h3>
<p>Falls sich ein numerischer Wert in Form eines Strings im Speicher befindet, kann er mit passenden Methoden konvertiert werden.</p>
<h4><code>parseInt()</code> und <code>parseFloat()</code></h4>
<p>Siehe: <code><a href="/en/JavaScript/Reference/Global_Objects/parseInt" title="en/JavaScript/Reference/Global Objects/parseInt">parseInt()</a></code> und <code><a href="/en/JavaScript/Reference/Global_Objects/parseFloat" title="en/JavaScript/Reference/Global Objects/parseFloat">parseFloat()</a></code>.</p>
<p>Die Methode <code>parseInt</code> gibt ausschließlich ganze Zahlen zurück, daher ist ihr Nutzen auf Dezimalzahlen beschränkt. Bei <code>parseInt</code> sollte man immer den radix-Parameter mit angeben.</p>
<h4>Plus-Operator</h4>
<p>Eine alternative Methode, um einen numerischen Wert aus einem String zu erhalten, ist die Verwendung des Operators + (Pluszeichen):</p>
<pre class="brush: js">"1.1" + "1.1" = "1.11.1"
(+"1.1") + (+"1.1") = 2.2   // Anführungszeichen dienen der Übersichtlichkeit, nicht unbedingt nötig.
</pre>
<h2><a name="Variablen">Variablen</a></h2><a name="Variablen">
<p>Variablen werden als symbolische Namen für Werte eingesetzt. Die Namen der Variablen werden <em>Bezeichner (</em>oder engl. <em>Identifier)</em> genannt und folgen gewissen Regeln.</p>
<p>Ein JavaScript-Bezeichner muss mit einem Buchstaben, Unterstrich (_) oder Dollar-Zeichen ($) beginnen. Die darauf folgenden Zeichen dürfen auch Ziffern sein (0-9). Da JavaScript zwischen Groß- und Kleinschreibung unterscheidet, sind mit Buchstaben sowohl "A" bis "Z" (Großbuchstaben)  als auch "a" bist "z" (Kleinbuchstaben) gemeint.</p>
<p>Ab JavaScript 1.5 sind bei Bezeichnern auch Buchstaben aus den Zeichensätzen ISO 8859-1 oder Unicode wie å oder ü erlaubt. Außerdem dürfen auch die \uXXXX {{ web.link("#Unicode_escape_sequences", "Unicode-Escape-Sequenzen") }} bei Identifiern verwendet werden.</p>
<p>Ein paar Beispiele von zulässigen Bezeichnern: <code>Number_hits</code>, <code>temp99</code>, and <code>_name</code>.</p>
<h3>Deklarieren von Variablen</h3>
<p>Variablen kann man auf zwei verschiedene Arten deklarieren:</p>
</a><ul><a name="Variablen"> </a><li><a name="Variablen">Mit dem Schlüsselwort </a><a href="/en/JavaScript/Reference/Statements/var" title="en/JavaScript/Reference/Statements/var">var</a>, welches dem Bezeichner vorangestellt wird: <code>var x = 42</code>. Auf diese Weise können sowohl<a href="#Variable_Scope"> lokale als auch globale</a> Variablen deklariert werden.</li> <li>Indem einfach einer Variablen ein Wert zugewiesen wird: <code>x = 42</code>. Dies erzeugt immer eine <a href="#Global_Variables">globale Variable</a> und eine strikte JavaScript-Warnung. Deshalb wird von dieser Vorgehensweise abgeraten.</li>
</ul>
<h3>Auswerten von Variablen</h3>
<p>Eine Variable, die mit dem <code>var</code>-Schlüsselwort deklariert wurde, ohne dass ihr ein Wert zugewiesen wurde, besitzt den Wert <code><a href="/en/JavaScript/Reference/Global_Objects/undefined" title="en/JavaScript/Reference/Global Objects/undefined">undefined</a></code>.</p>
<p>Der Versuch, auf eine undeklarierte Variable zuzugreifen, scheitert mit dem Ergebnis einer <code>ReferenceError</code>-Ausnahmebehandlung:</p>
<pre class="brush: js">var a;
console.log("Der Wert von a ist " + a); // gibt aus: "Der Wert von a ist undefined"
console.log("Der Wert von b ist " + b); // erzeugt ReferenceError-Ausnahmebehandlung
</pre>
<p>Ersteres Verhalten kann man sich zunutze machen, um zu überprüfen, ob eine Variable einen Wert enthält. Im folgenden Code-Beispiel wurde der Variablen <code>myVar</code> kein Wert zugewiesen und die Prüfung mit einer <code>if</code>-Anweisung ergibt deshalb <code>true</code>.</p>
<pre class="brush: js">var myVar;
if(myVar === undefined){
  alert("myVar ist kein Wert zugewiesen.");
} else {
  alert("myVar ist ein Wert zugewiesen.");
}
</pre>
<p><span class="comment">Folgende Erläuterungen hängen mit den Beschreibungen zu Variablen zusammen.</span> Je nachdem in welchem Kontext Variablen gebraucht und ausgewertet werden, werden die Werte unterschiedlich interpretiert.</p>
<p>Der Wert <code>undefined</code> evaluiert zu <code>false</code>, wenn er in einem booleschen Kontext verwendet wird. Zum Beispiel wird bei folgendem Code die Funktion <code>myFunction</code> ausgeführt, weil das Element <code>myArray</code> nicht definiert ist:</p>
<pre class="brush: js"><code>var myArray = new Array();
if (!myArray[0]) myFunction();</code>
</pre>
<p>In numerischem Kontext wird <code>undefined</code> hingegen zu <code>NaN</code> konvertiert:</p>
<pre class="brush: js">var a;
a + 2 = NaN
</pre>
<p>Eine Variable, die mit <code>null</code> deklariert ist, evaluiert in numerischem Kontext zu 0 und in booleschem Kontext zu <code>false</code>:</p>
<pre class="brush: js">var n = null;
console.log(n * 32); // prints 0
</pre>
<h3>Sichtbarkeitsbereich (Scope) von Variablen</h3>
<p>Eine Variable, die außerhalb einer Funktion deklariert wird, ist eine globale Variable. Globale Variablen sind im ganzen Programm sichtbar und der Zugriff kann über den Code im Dokument von beliebiger Stelle aus erfolgen. Hingegen sind Variablen, die innerhalb von Funktionen definiert werden, lokale Variablen, die nur innerhalb der Funktion angesprochen werden können.</p>
<p>JavaScript grenzt die Sichtbarkeit von <a href="/en/JavaScript/Guide/Statements#Block_Statement" title="en/JavaScript/Guide/Statements#Block Statement">Block-Anweisungen</a> nicht ein. Variablen innerhalb von Block-Anweisungen sind lokal zu dem Code, in dem sich der Anweisungsblock befindet. Zum Beispiel wird der folgende Code <code>5</code> in der Konsole ausgeben, weil die Sichtbarkeit von x auf die äußere Funktion (oder den globale Kontext) beschränkt ist und nicht auf den Block der <code>if</code>-Anweisung.</p>
<pre class="brush: js"><code>if (true) {
  var x = 5;
}
console.log(x);</code>
</pre>
<p>Eine weitere Besonderheit bei Variablen in JavaScript ist, dass man sich auf eine Variable beziehen kann, die erst später deklariert wurde, ohne einen Ausnahmefehler zu erhalten. Dieses Konzept ist als "hoisting" (engl. Hochziehen) bekannt. Variablen in JavaScript werden gewissermaßen zum Anfang der Funktion <em>hochgezogen</em> oder angehoben. Jedoch liefern nicht initialisierte Variablen den Wert <code>undefined</code>.</p>
<pre class="brush: js"><code>// Beispiel 1

console.log(x === undefined); // loggt "true"
var x = 3;


// Beispiel 2

// gibt undefined zurück
var myVar = "mein Wert";

(function() {
  console.log(myVar); // undefined
  var myVar = "lokaler Wert";
})();</code>
</pre>
<p>Das Beispiel 2 oben wird vom JavaScript-Interpreter so gedeutet:</p>
<pre class="brush: js"><code>var myVar = "mein Wert";

(function() {
  var myVar;  // hoisting
  console.log(myVar); // undefined
  myVar = "lokaler Wert";
})();</code>
</pre>
<p>Aufgrund des "hoisting" sollten alle <code>var</code>-Anweisungen in einer Funktion so nahe wie möglich an den Anfang platziert werden. Diese Vorgehensweise verbessert die Übersichtlichkeit des Codes.</p>
<h3>Globale Variablen</h3>
<p><span style="color:#d3d3d3;"><span class="comment">need links to pages discussing scope chains and the global object</span></span></p>
<p>Globale Variablen sind tatsächlich Eigenschaften des <em>globalen Objekts</em>. Bei Webseiten ist das globale Objekt <code><a href="/en/DOM/window" title="en/DOM/window">window</a></code>, sodass man globale Variablen über die Syntax <code>window.<em>variable</em></code> ansprechen kann.</p>
<p>Globale Variablen, die in einem Fenster oder Frame deklariert wurden, lassen sich von einem anderen Fenster oder Frame aus ansprechen, indem man den Namen des Fensters oder Frames spezifiziert. Wenn z.B. eine globale Variable <code>Telefonnummer</code> auf einer Webseite deklariert wurde, die ein <code>FRAMESET</code> enthält, lässt sich diese von den Frames aus ansprechen.</p>
<h2>Konstanten</h2>
<p>Mit dem Schlüsselwort <code><a href="/en/JavaScript/Reference/Statements/const" title="en/Core_JavaScript_1.5_Reference/Statements/const">const</a></code> erzeugt man Konstanten. Die Syntax für Bezeichner von Konstanten ist dieselbe wie bei Variablen.</p>
<pre class="brush: js"><code>const prefix = '212';</code>
</pre>
<p>Der Wert einer Konstanten kann während der Laufzeit des Skripts nicht geändert und nicht neu deklariert werden.</p>
<p>Auch die Sichtbarkeitsregeln für Konstanten sind dieselben wie bei Variablen, außer dass das Schlüsselwort const zwingend angegeben werden muss. Dies gilt auch für globale Konstanten. Wenn das Schlüsselwort nicht angegeben wird, wird der Bezeichner als Variable interpretiert.</p>
<p>Es ist nicht erlaubt, Konstanten und Variablen mit dem Namen einer Funktion oder Variablen innerhalb desselben Sichtbarkeitsbereichs zu deklarieren:</p>
<pre class="brush: js"><code>// LOEST EINEN ERROR AUS
function f() {};
const f = 5;

// EBENFALLS ERROR
function f() {
  const g = 5;
  var g;

  // Anweisungen
}</code>
</pre>
<h2>Literale</h2>
<p>Literale repräsentieren feste Werte in JavaScript, die <em>buchstäblich</em> festgelegt werden.</p>
<ul> <li>{{ web.link("#Array_literals", "Array-Literale") }}</li> <li>{{ web.link("#Boolean_literals", "Boolean-Literale") }}</li> <li>{{ web.link("#Floating-point_literals", "Gleitkommazahlen-Literale") }}</li> <li>{{ web.link("#Integers", "Ganzzahlen (Integer)") }}</li> <li>{{ web.link("#Object_literals", "Objekt-Literale") }}</li> <li>{{ web.link("#String_literals", "String-Literale") }}</li>
</ul>
<h3>Array-Literale</h3>
<p>Ein Array-Literal ist eine Liste von Null oder mehreren Ausdrücken von denen jeder ein Array-Element repräsentiert. Arrays werden in eckige Klammern ([]) eingeschlossen. Wenn man ein Array über ein Array-Literal erstellt, wird es mit den angegebenen Werten als dessen Elemente initialisiert. Die Länge des Arrays entspricht dann der Anzahl der Elemente.</p>
<p>Im folgenden Beispiel wird das Array <code>Kaffees</code> mit drei Elementen und einer Länge von 3 erstellt:</p>
<pre class="brush: js">var Kaffees = ["French Roast", "Colombian", "Kona"];
</pre>
<p><strong>Merke: </strong>Ein Array ist eine Art Objekt-Initializer. Siehe <a href="/en/JavaScript/Guide/Working_with_Objects#Using_Object_Initializers" title="en/JavaScript/Guide/Working with Objects#Using Object Initializers">Using Object Initializers</a>.</p>
<p>Wenn ein Array über einen Literal in einem Top-Level-Skript erstellt wird, interpretiert JavaScript das Array jedes Mal erneut, wenn die Anweisung evaluiert wird, welche den Array-Literal enthält. Ein Literal innerhalb einer Funktion wird jedes Mal neu erstellt, wenn die Funktion ausgeführt wird.</p>
<p>Array-Literale sind auch Objekte. Im Abschnitt zu <a href="/en/JavaScript/Guide/Predefined_Core_Objects#Array_Object" title="en/JavaScript/Guide/Predefined Core Objects#Array Object">Array-Objekten </a>findet man weitere Informationen.</p>
<h4>Extra Kommas in Array-Literalen</h4>
<p>In einem Array-Literal müssen nicht alle Elemente angegeben werden. Wenn man zwei Kommas nacheinander schreibt, also die Stelle für ein Element frei lässt, bekommt das entsprechende Element den Wert <code>undefined</code>:</p>
<pre class="brush: js">var fish = ["Lion", , "Angel"];   // fish[1] ist undefined
</pre>
<p>Dieses Array hat zwei Elemente mit String-Werten und ein leeres Element. Da man mit 0 zu zählen beginnt, ist das erste Element <code>fish[0]</code> und hat den Wert "Lion". Das zweite Element ist <code>fish[1]</code> und <code>undefined. D</code>as dritte Element <code>fish[2]</code> hat den Wert "Angel".</p>
<p>Wenn man ein zusätzliches Komma am Ende der Liste angibt, wird dieses Komma ignoriert. Beim folgenden Beispiel ist die Länge des Arrays drei. Demzufolge existiert kein Element <code>myList[3]</code>, weil man ja mit 0 zu zählen beginnt. (<strong>Merke:</strong> Die Kommas am Ende können zu Fehlern bei älteren Browsern führen und es ist am besten, sie zu entfernen).</p>
<pre class="brush: js">var myList = ['home', , 'school', ];
</pre>
<p>Beim folgenden Beispiel ist die Länge des Arrays vier. Die Elemente <code>myList[0]</code> und <code>myList[2]</code> fehlen und sind darum <code>undefined</code>.</p>
<pre class="brush: js">var myList = [ , 'home', , 'school'];
</pre>
<p>Noch ein Beispiel: Die Länge des Arrays ist hier ebenfalls vier. Die Elmente <code>myList[1]</code> und <code>myList[3]</code> fehlen und nur das letzte Komma wird ignoriert.</p>
<pre class="brush: js">var myList = ['home', , 'school', , ];
</pre>
<p>Es ist wichtig zu verstehen, was zusätzliche Kommas bewirken, um JavaScript als Sprache zu verstehen. Wenn man aber selbst Code schreibt, ist es besser, die fehlenden Elemente mit <code>undefined</code> zu deklarieren, um die Lesbarkeit, Übersichtlichkeit und Wartbarkeit zu verbessern.</p><h3>Boolean-Literale</h3>
<p>Der boolesche Datentyp kennt zwei literale Werte: <code>true</code> und <code>false</code>.</p>
<p>Die primitiven booleschen Werte sollten nicht mit den true- und false-Werten des booleschen Objekts verwechselt werden. Das boolesche Objekt ist eine Hülle für den primitiven booleschen Datentyp. Siehe <a href="/en/JavaScript/Guide/Predefined_Core_Objects#Boolean_Object" title="en/JavaScript/Guide/Predefined Core Objects#Boolean Object">Boolean-Objekt</a> für mehr Informationen.</p>
<h3>Integer (ganze Zahlen)</h3>
<p>Integer können mit Dezimalzahlen (Basis: 10), Hexadezimalzahlen (Basis: 16) und Oktalzahlen (Basis: 8) ausgedrückt werden.</p>
<ul> <li>Literale mit dezimalen Ganzzahlen bestehen aus einer Reihe von Ziffern, ohne eine führende 0 (Null).</li> <li>Eine 0 (Null) an erster Stelle bedeutet, dass es sich um eine Oktalzahl handelt.  Oktalzahlen können außschließlich die Ziffern 0-7 beinhalten.</li> <li>Eine Hexadezimalzahl kennzeichnet sich durch 0x (oder 0X) am Anfang. Hexadezimale Zahlen bestehen aus den Ziffern 0-9 und den Buchstaben A-F.</li>
</ul>
<p>Oktalzahlen-Literale sind veraltet und wurden aus dem Standard ECMA-262, Edition 3 (im <em>strict mode</em>) entfernt. JavaScript 1.5 unterstützt sie aber weiterhin aus Gründen der Abwärtskompatibilität.</p>
<p>Ein paar Beispiele von Integer-Literalen sind:</p>
<pre class="brush: js">0, 117 und -345 (dezimal, Basis 10)
015, 0001 and -077 (oktal, Basis 8) 
0x1123, 0x00111 and -0xF1A7 (hexadezimal, "hex" oder Basis 16)
</pre>
<h3>Gleitkommazahlen-Literale</h3>
<p>Eine Gleitkommazahl kann folgende Bestandteile haben:</p>
<ul> <li>Eine Dezimalzahl mit Vorzeichen ( "+" oder "-"),</li> <li>Einen Dezimalpunkt ("."),</li> <li>Einen Bruchteil mit weiteren Dezimalzahlen,</li> <li>Einen Exponenten.</li>
</ul>
<p>Der Teil mit dem Exponent ist ein "e" oder "E" gefolgt von einer Ganzzahl, die ein Vorzeichen haben kann ("+" or "-"). Eine Gleitkommazahl muss mindestens eine Ziffer besitzen und einen Dezimalpunkt oder "e" (oder "E").</p>
<p>Ein paar Beispiele für Gleitkommazahlen-Literale sind 3.1415, -3.1E12, .1e12 und 2E-12.</p>
<p>Beschreibung der Syntax:</p>
<pre class="brush: js">[digits][.digits][(E|e)[(+|-)]digits]
</pre>
<p>Weitere Beispiele:</p>
<pre class="brush: js">3.14
2345.789
.3333333333333333333
</pre>
<h3>Objekt-Literale</h3>
<p>Ein Objekt-Literal ist eine Liste von Null oder mehreren Paaren von Eigenschaftsnamen und assoziierten Werten, die zu einem Objekt gehören, eingeschlossen in geschweifte Klammern ({}). Ein Objekt-Literal sollte nicht am Anfang einer Anweisung verwendet werden. Dies führt zu einem Fehler oder verhält sich anders als gewollt, weil die erste Klammer wie der Anfang eines Blocks interpretiert wird.</p>
<p>Das folgende Beispiel zeigt ein Objekt-Literal. Das erste Element des Objekts <code>car</code> definiert eine Eigenschaft <code>myCar</code>,.Das zweite Element, die Eigenschaft <code>getCar,</code> ruft eine Funktion <code>CarTypes("Honda")</code> auf. Das dritte Element, die Eigenschaft <code>special</code>, benutzt eine existierende Variable (<code>Sales</code>).</p>
<pre class="brush: js"><code>var Sales = "Toyota";

function CarTypes(name) {
  return (name == "Honda") ?
    name :
    "Sorry, we don't sell " + name + "." ;
}

var car = { myCar: "Saturn", getCar: CarTypes("Honda"), special: Sales };

console.log(car.myCar);   // Saturn
console.log(car.getCar);  // Honda
console.log(car.special); // Toyota </code>
</pre>
<p>Des Weiteren kann man einen numerischen Literal oder String-Literal für den Namen der Eigenschaft benutzen oder Objekte ineinander verschachteln:</p>
<pre class="brush: js"><code>var car = { manyCars: {a: "Saab", "b": "Jeep"}, 7: "Mazda" };

console.log(car.manyCars.b); // Jeep
console.log(car[7]); // Mazda</code>
</pre>
<p><span style="font-family: monospace;">Merke:</span></p>
<pre class="brush: js"><code>var foo = {a: "alpha", 2: "zwei"};
console.log(foo.a);    // alpha
console.log(foo[2]);   // zwei
//console.log(foo.2);  // Error: fehlende ) nach der Argumentliste
//console.log(foo[a]); // Error: a ist nicht definiert
console.log(foo["a"]); // alpha
console.log(foo["2"]); // zwei</code>
</pre>
<h3>String-Literale</h3>
<p>String-Literale können aus Null oder mehr Zeichen bestehen. Sie werden in doppelten (<code>"</code>) oder einfachen (<code>'</code>) Anführungszeichen eingeschlossen. Dabei muss der Typ der beiden Anführungszeichen am Anfang und Ende stets derselbe sein, d.h. entweder sind beide Anführungszeichen einfach oder doppelt.</p>
<p>Hier ein paar Beispiele für String-Literale:</p>
<ul> <li><code>"foo"</code></li> <li><code>'bar'</code></li> <li><code>"1234"</code></li> <li><code>"Eine Zeile \n Noch eine Zeile"</code></li> <li><code>"John's Katze</code></li>
</ul>
<p>Jede der Methoden des String-Objekts kann man auf einen String anwenden - JavaScript konvertiert den String-Literal automatisch zu einem temporären String-Objekt, ruft die Methode auf und verwirft das temporäre Objekt wieder. Auch die Eigenschaften String.length kann bei String-Literale benutzt werden:</p>
<pre class="brush: js">"John's Katze".length
</pre>
<p>String-Literale sollte man verwenden, solange man kein String-Objekt benötigt. Siehe <a href="/en/JavaScript/Guide/Predefined_Core_Objects#String_Object" title="en/JavaScript/Guide/Predefined Core Objects#String Object">String Object</a> für mehr Informationen.</p>
<h4>Escape-Sequenzen in Strings</h4>
<p>Außer den normalen Zeichen kann man auch die sogenannten Escape-Sequenzen in Strings verwenden. Das sind eine Reihe von speziellen Zeichenkombinationen, die mit einem Backslash beginnen und eine Sonderbedeutung haben.</p>
<pre class="brush: js"><code>"Eine Zeile \n Noch eine Zeile"</code>
</pre>
<p>Die folgende Tabelle listet die speziellen Zeichen (und deren Bedeutung) auf, die in JavaScript benutzt werden können.</p>
<br>
<table class="standard-table"> <caption style="text-align: left;">Tabelle 2.1 Escape-Sequenzen bei JavaScript</caption> <thead> <tr> <th scope="col">Sequenz</th> <th scope="col">Bedeutung</th> </tr> </thead> <tbody> <tr> <td><code>\b</code></td> <td>Rückschritt (Backspace)</td> </tr> <tr> <td><code>\f</code></td> <td>Seitenvorschub (Form feed)</td> </tr> <tr> <td><code>\n</code></td> <td>Zeilenvorschub (New line)</td> </tr> <tr> <td><code>\r</code></td> <td>Wagenrücklauf (Carriage return)</td> </tr> <tr> <td><code>\t</code></td> <td>Horizontaler Tabulator</td> </tr> <tr> <td><code>\v</code></td> <td>Vertikaler Tabulator</td> </tr> <tr> <td><code>\'</code></td> <td>Apostroph oder einfaches Anführungszeichen</td> </tr> <tr> <td><code>\"</code></td> <td>Doppeltes Anführungszeichen</td> </tr> <tr> <td><code>\\</code></td> <td>Umgekehrter Schrägstrich (\).</td> </tr> <tr> <td><code>\<em>XXX</em></code></td> <td>Das Zeichen aus dem Zeichensatz Latin-1 mit Angabe der dreistelligen oktalen Zahl <em>XXX</em> zwischen 0 und 377. Zum Beispiel ist \251 die oktale Sequenz für das Copyright-Symbol.</td> </tr> <tr> <td><code>\x<em>XX</em></code></td> <td>Das Zeichen aus dem Zeichensatz Latin-1 mit Angabe der zweistelligen hexadezimalen Zahl <em>XX</em> zwischen 00 und FF. Zum Beispiel ist \xA9 die hexadezimale Sequenz für das Copyright-Symbol.</td> </tr> <tr> <td><code>\u<em>XXXX</em></code></td> <td>Das Unicode-Zeichen mit Angabe der vierstelligen hexadezimalen Zahl <em>XXXX</em>. Zum Beispiel ist \u00A9 die Unicode-Sequenz für das Copyright-Symbol. Siehe {{ web.link("#Unicode_escape_sequences", "Unicode Escape-Sequenzen") }}.</td> </tr> </tbody>
</table>
<h4>Escapen-Sequenzen</h4>
<p>Bei Zeichen, die nicht in der Tabelle aufgelistet sind, wird ein Backslash ignoriert, sollte jedoch vermieden werden (veraltet).</p>
<p>Innerhalb eines Strings kann man Anführungszeichen verwenden, indem man einen Backslash voranstellt. Dies wird als <em>escapen</em> eines Anführungszeichens bezeichnet. Zum Beispiel:</p>
<pre class="eval deki-transform">var buchtitel = "Sie liest \"Per Anhalter durch die Galaxis\" von Douglas Adams.";
console.log(buchtitel);
</pre>
<p>Das Resultat wäre:</p>
<pre class="brush: js">Sie liest "Per Anhalter durch die Galaxis" von Douglas Adams.
</pre>
<p>Um einen normalen Backslash in einen Strings einzufügen, muss man diesen <em>escapen</em>. Hier ein Beispiel für eine Zuweisung mit einem Dateipfad:</p>
<pre class="brush: js"><code>var home = "c:\\temp";</code>
</pre>
<p>Darüber hinaus kann man auch Zeilenumbrüche markieren (escapen), indem man einen Backslash als letztes Zeichen (vor den Zeilenumbruch) schreibt. Beim Ergebnis wird sowohl der Backslash als auch der Zeilenumbruch aus dem String entfernt.</p>
<pre class="brush: js">var str = "Dieser String \
ist über \
mehrere Zeilen \
verteilt."
<span class="objectBox objectBox-text ">console.log(str);</span>   // <span class="objectBox objectBox-text ">Dieser String ist über mehrere Zeilen verteilt.</span>
</pre>
<p>Obwohl JavaScript nicht die "heredoc"-Syntax unterstützt, kann man Ähnliches erreichen, indem man am Ende der Zeile einen Zeilenvorschub (new line) einfügt und anschließend den Zeilenumbruch markiert:</p>
<pre class="brush: js">var poem = 
"Rosen sind rot,\n\
Veilchen sind blau.\n\
Ich bin schizophren\n\
Und das bin ich auch."
</pre>
<h2>Unicode</h2>
<p>Unicode ist ein internationaler Standard, in dem langfristig für jedes sinntragende Schriftzeichen oder Textelement aller bekannten Schriftkulturen und Zeichensysteme ein digitaler Code festgelegt wird. Ziel ist es, die Verwendung unterschiedlicher und inkompatibler Kodierungen in verschiedenen Ländern oder Kulturkreisen zu beseitigen. Unicode wird ständig<a href="/de/JavaScript/javascript_guide/Werte,_Variablen_und_Literale" title="Werte, Variablen und Literale"> </a>um Zeichen weiterer Schriftsysteme ergänzt.</p>
<p>Der Unicode-Zeichensatz kann für alle bekannten Kodierungen benutzt werden. Unicode ist nach dem ASCII-Zeichensatz entworfen. Jedes Zeichen hat einen numerischen Wert und einen Namen. Die Zeichenkodierung beschreibt die Identität des Zeichens und den numerischen Wert (Code-Position), als auch die Repräsentation des Werts in Bits. Der 16-Bit breite numerische Wert (digitaler Code) definiert sich durch eine hexadezimale Zahl und ein Prefix <em>U</em>. zum Beispiel steht U+0041 für den Buchstaben A. Der individuelle Name für diesen Buchstaben ist LATIN CAPITAL LETTER A.</p>
<p><strong>Unicode wird nicht von JavaScript vor Version 1.3 unterstützt.</strong></p>
<h3>Unicode Kompatiblität zu ASCII und ISO</h3>
<p>Unicode ist vollständig kompatibel mit dem internationalen Standard ISO/IEC 10646-1; 1993, welcher eine Untermenge von ISO 10646 ist. ISO 10646 ist die von ISO verwendete, praktisch bedeutungsgleiche Bezeichnung des Unicode-Zeichensatzes; er wird dort als <em>Universal Character Set (UCS)</em> bezeichnet.</p>
<p>Neben dem eigentlichen Zeichensatz sind auch eine Reihe von Zeichenkodierungen definiert, die den Unicode-Zeichensatz implementieren und die eingesetzt werden können, um den vollen Zugriff auf alle Unicode-Zeichen zu gewährleisten. Sie werden <em>Unicode Transformation Format (kurz UTF)</em> genannt.</p>
<p>Die Kodierung <em>UTF-8</em> ist kompatibel mit ASCII und wird von vielen Programmen unterstützt. Die ersten 128 Unicode-Zeichen sind die gleichen wie beim ASCII-Zeichensatz und haben denselben Bytewert. Die Unicode-Zeichen U+0020 bis U+007E sind equivalent zu den ASCII-Zeichen 0x20 bis 0x7E. Anders als der ASCII-Zeichensatz, der das lateinische Alphabet in Groß- und Kleinschreibung, die zehn <span class="mw-redirect">arabischen Ziffern und</span> diverse nicht druckbare Zeichen enthält und jedem Zeichen ein Bitmuster aus 7-Bit zuordnet, sind UTF-8-Zeichen zwischen einem und vier Oktetts (Oktett bedeutet ein Byte oder 8 Bit) breit. Dies erlaubt die Darstellung von merhreren Millionen verschiedenen Zeichen.</p>
<p>Ein alternativer Kodierungsstandard namens UTF-16 verwendet zwei Oktett, um die Unicode-Zeichen darzustellen. Eine Escape-Sequenz erlaubt UTF-16 die ganze Spanne des Unicode-Zeichensatzes mit vier Oktett aufzunehmen. Der ISO UCS-2 (Universal Character Set) verwendet zwei Oktetts.</p>
<p>Die Unterstützung bei JavaScript und Navigator für UTF-8/Unicode erlaubt die Nutzung von nicht-lateinischen, internationalen und lokalisierten Zeichen, plus besondere technische Symbole in JavaScript-Programmen. Unicode definiert eine Standardmethode für die Kodierung von mehrsprachigem Text. Da die UTF-8-Kodierung kompatibel mit ASCII ist, können Programme auch ASCII-Zeichen verwenden. Zeichen, die nicht im ASCII enthalten sind, kann man in Kommentaren, String-Literalen, Bezeichner und regulären Ausdrücken verwenden.</p>
<h3>Unicode Escape-Sequenzen</h3>
<p>Die Unicode-Escape-Sequenzen dürfen in String-Literalen, regulären Ausdrücken und Bezeichner zum Einsatz kommen. Die Escape-Sequenzen bestehen aus sechs ASCII-Zeichen: den ersten beiden Zeichen "\u" und anschließend einer vierstelligen hexadezimale Zahl. Zum Beispiel steht \u00A9 für das Copyright-Symbol. Jede Unicode-Escape-Sequenz in JavaScript wird als ein Zeichen interpretiert.</p>
<p>Der folgende Code liefert das Copyright-Symbol und den String "Mozilla Firefox".</p>
<pre class="deki-transform">var x = "\u00A9 Mozilla Firefox";
</pre>
<p>In der nachstehenden Tabelle werden die oft gebrauchten Zeichen und ihr Unicode-Wert aufgelistet.</p>
<table class="standard-table"> <caption style="text-align: left;">Tabelle 2.2 Unicode-Werte für Zeichenfolgen mit Sonderbedeutung</caption> <thead> <tr> <th scope="col">Kategorie</th> <th scope="col">Unicode-Wert</th> <th scope="col">Name</th> <th scope="col">Formatname</th> </tr> </thead> <tbody> <tr> <td rowspan="4">Zwischenraumzeichen (Whitespace)</td> <td>\u0009</td> <td>Horizontaler Tabulator (Tab)</td> <td>&lt;TAB&gt;</td> </tr> <tr> <td>\u000B</td> <td>Vertikaler Tabulator</td> <td>&lt;VT&gt;</td> </tr> <tr> <td>\u000C</td> <td>Seitenvorschub (Form Feed)</td> <td>&lt;FF&gt;</td> </tr> <tr> <td>\u0020</td> <td>Leerzeichen (Space)</td> <td>&lt;SP&gt;</td> </tr> <tr> <td rowspan="2">Zeilenumbruch</td> <td>\u000A</td> <td>Zeilenvorschub (Line Feed)</td> <td>&lt;LF&gt;</td> </tr> <tr> <td>\u000D</td> <td>Wagenrücklauf (Carriage Return)</td> <td>&lt;CR&gt;</td> </tr> <tr> <td rowspan="5">Weitere Unicode-Escape-Sequenzen</td> <td>\u0008</td> <td>Rückschritt (Backspace)</td> <td>&lt;BS&gt;</td> </tr> <tr> <td>\u0009</td> <td>Horizontal Tabulator (Tab)</td> <td>&lt;HT&gt;</td> </tr> <tr> <td>\u0022</td> <td>Doppelte <span class="searchmatch">Anführungszeichen</span></td> <td>"</td> </tr> <tr> <td>\u0027</td> <td>E<span class="searchmatch">infache</span> <span class="searchmatch">Anführungszeichen</span></td> <td>'</td> </tr> <tr> <td>\u005C</td> <td>Umgekehrter Schrägstrich (Backslash)</td> <td>\</td> </tr> </tbody>
</table>
<p>Bei JavaScript läuft die Interpretation der Unicode-Escape-Sequenzen etwas anders ab als bei Java. JavaScript betrachtet Escape-Sequenzen nie zuerst als eine Zeichenfolge mit Sonderbedeutung. Ein String wird z.B. nicht durch eine Zeilenumbruch-Sequenz beendet, bevor die Sequenz von einer Funktion ausgewertet wurde. JavaScript ignoriert alle Escape-Sequenzen in Kommentaren. Bei Java wird eine Escape-Sequenz als Unicode-Zeichen interpretiert, sofern sie in einem einzeiligen Kommentar steht. Bei String-Literalen interpretiert der Java-Compiler zuerst die Escape-Sequenz. Wenn in Java z.B. ein Unicode-Zeilenvorschub (\u000A) benutzt wird, beendet dieser den String-Literal. Möchte man einen Zeilenvorschub in einem String erreichen, muss man stattdessen auf \n zurückgreifen. Bei JavaScript hingegen funktioniert ein Unicode-Zeilenvorschub genau wie bei Verwendung von \n.</p><h3>Unicode-Zeichen in JavaScript-Dateien</h3>
<p>Frühere Versionen von <a href="/en/Gecko" title="en/Gecko">Gecko</a> nahmen für Javascript-Dateien an, dass sie mit dem Latin-1-Zeichensatz kodiert sind. Seit Gecko 1.8 wird die Zeichenkodierung von der XUL-Datei übernommen. Unter <a href="/en/International_characters_in_XUL_JavaScript" title="en/International_characters_in_XUL_JavaScript">International characters in XUL JavaScript</a> findet man mehr Informationen.</p><h3>Anzeigen von Zeichen mit Unicode</h3>
<p>Mit Unicode kann man Zeichen für verschiedene Sprachen und technische Symbole anzeigen lassen. Damit die Zeichen richtig dargestellt werden, muss die Client-Software wie z.B. Firefox die Unicode-Zeichenkodierung unterstützen. Außerdem muss dem Client ein brauchbarer Unicode-Font zur Verfügung stehen und die Plattform muss Unicode ebenfalls unterstützen. Meistens können Unicode-Fonts nicht alle Zeichen darstellen. Manche Plattformen, wie z.B. Windows 95, unterstützen Unicode nur zum Teil.</p>
<p>Um nicht-ASCII-Zeicheneingaben zu erhalten, muss der Client die Eingabe als Unicode senden. Bei der Benutzung einer Standard-Tastatur kann der Client viele der Zeichen nicht so einfach eingeben, die von Unicode unterstützt werden. Deshalb ist manchmal die Verwendung von Unicode-Escape-Sequenzen die einzige Möglichkeit.</p>
<p>Für mehr Informationen zu Unicode, werfen sie einen Blick auf die <a class="external" href="http://www.unicode.org/">Unicode-Homepage</a> und den Unicode-Standard, Version 2.0, erschienen im Verlag Addison-Wesley, 1996.</p>
<pre class="script" style="font-size: 16px;">autoPreviousNext("JSGChapters");
wiki.languages({
  "zh-tw": "zh_tw/Core_JavaScript_1.5_教學/JavaScript_概要",
  "es": "es/Gu\u00eda_JavaScript_1.5/Concepto_de_JavaScript",
  "fr": "fr/Guide_JavaScript_1.5/Aper\u00e7u_de_JavaScript",
  "ja": "ja/Core_JavaScript_1.5_Guide/JavaScript_Overview",
  "ko": "ko/Core_JavaScript_1.5_Guide/JavaScript_Overview",
  "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Przegl\u0105d_JavaScriptu",
  "zh-cn": "cn/Core_JavaScript_1.5_Guide/JavaScript\u603b\u89c8"
});
</pre>
Zu dieser Version zurücksetzen