MDN may have intermittent access issues April 18 13:00 - April 19 01:00 UTC. See whistlepig.mozilla.org for all notifications.

mozilla
Ihre Suchergebnisse

    Werte, Variablen und Literale

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

    Werte

    Bei JavaScript wird zwischen den folgenden verschiedenen Typen für Werte unterschieden:

    Typ Beispiele zu den Werten / Anmerkungen
    Numbers (numerische Werte) 42, 3.14159

    Logisch (Boolesche Werte)

    true / false
    Strings (Zeichenketten) "Howdy"
    null Ein spezielles Schlüsselwort, das für einen Null-Wert steht. Da JavaScript zwischen Groß- und Kleinschreibung unterscheidet, ist null nicht dasselbe wie Null, NULL oder eine andere Variante.
    undefined Eine Top-Level-Eigenschaft, deren Wert undefiniert ist; undefined ist auch ein primitiver Wert.

    Schon dieser relativ kleine Satz von Datentypen ist für die Unterscheidung zwischen verschiedenartigen Werten und Programmierung nützlicher Funktionen in JavaScript ausreichend.

    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.

    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. Außerdem werden Datentypen von JavaScript automatisch so konvertiert, wie JavaScript annimmt, dass sie bei der Ausführung des Skripts benötigt werden.

    Eine Variable kann z.B. so definiert werden:

    var antwort = 42;

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

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

    Da Javascript dynamisch typisiert ist, erzeugt diese Zuweisung keine Fehlermeldung. JavaScript erkennt, dass es sich bei der zweiten Zuweisung um einen String handelt, und wandelt den Datentyp automatisch um.

    Wenn man in Ausdrücken Numbers und Strings mit dem Operator + verbindet, werden die numerischen Werte automatisch in Strings umgewandelt:

    x = "Die Antwort ist " + 42  // Gibt "Die Antwort ist 42" aus
    y = 42 + " ist die Antwort"  // Gibt "42 ist die Antwort" aus

    Dies gilt allerdings nur für den +-Operator. Werden andere Operatoren verwendet, konvertiert Javascript den Wert nicht automatisch zu einem String:

    "37" - 7 // Gibt 30 aus
    "37" + 7 // Gibt "377" aus

    Konvertieren von Strings zu Numbers

    Falls ein numerischer Wert in Form eines Strings abgespeichert wurde, kann dieser mit der entspreichenden Methode 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 immer der radix-Parameter mit angegeben werden.

    Plus-Operator

    Eine alternative Methode, um einen numerischen Wert aus einem String zu erhalten, ist das Voranstellen des +-Operators:

    "1.1" + "1.1" = "1.11.1"
    (+"1.1") + (+"1.1") = 2.2   // Klammern dienen der Übersichtlichkeit, nicht zwingend nötig

    Variablen

    Variablen sind symbolische Namen für Werte. Die Namen der Variablen werden Bezeichner (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 "A" bis "Z" (Großbuchstaben)  und "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 Unicode-Escape-Sequenzen (\uXXXX) bei Identifiern verwendet werden.

    Hier ein paar Beispiele für zulässige Bezeichner: Number_hits, temp99 und _name.

    Deklarieren von Variablen

    Variablen können auf zwei verschiedene Arten deklariert werden:

    • 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. Daher 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-Ausnahme:

    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 einer Variable ein Wert zugewiesen ist. 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.");
    }

    Je nachdem in welchem Kontext Variablen eingesetzt und ausgewertet werden, werden die Werte unterschiedlich interpretiert.

    Der Wert undefined evaluiert in booleschem Kontext zu false. Bei folgendem Code wird z.B. 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 mit var definierte 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 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. Nicht-initialisierte Variablen geben den Wert undefined zurück.

    // 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 zweite Beispiel wird vom JavaScript-Interpreter so gedeutet:

    var myVar = "mein Wert";
    
    (function() {
      var myVar;  // hoisting der lokalen Variablen ohne Wert
      console.log(myVar); // undefined
      myVar = "lokaler Wert";
    })();

    Aufgrund des hoisting sollten alle var-Anweisungen in einer Funktion so nahe wie möglich am Anfang platziert werden. Dadurch wird die Übersichtlichkeit des Codes verbessert und Interpretationsfehler beim Lesen vermieden.

    Globale Variablen

    Globale Variablen sind Eigenschaften des globalen Objekts. Bei Webseiten ist das globale Objekt window, sodass globale Variablen über die Syntax window.variable angesprochen werden können.

    Auf globale Variablen, die in einem Fenster oder Frame deklariert wurden, kann von einem anderen Fenster oder Frame aus zugegriffen werden, indem der Name des Fensters oder Frames angegeben wird. 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 werden Konstanten erzeugt. 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 demselben Namen innerhalb eines gemeinsamen Sichtbarkeitsbereichs zu deklarieren:

    // Falsch:
    function f() {};
    const f = 5;
    
    // Auch falsch:
    function f() {
      const g = 5;
      var g;
    
      // Anweisungen
    }

    Literale

    Literale repräsentieren feste Werte in JavaScript und werden in direkten Darstellung festgelegt.

    Array-Literale

    Ein Array-Literal ist eine Liste mit 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 Benutzung von Objekt-Literalen.

    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.

    Zusätzliche Kommas bei 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-Objekt 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 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.

    Mehr Informationen zu Unicode findet man auf der Unicode-Homepage und im Buch Unicode Standard, Version 2.0, erschienen im Verlag Addison-Wesley, 1996.

    Schlagwörter des Dokuments und Mitwirkende

    Schlagwörter: 
    Mitwirkende an dieser Seite: Hans_Mueller, eminor, NickRussler, siggi-heltau, fscholz
    Zuletzt aktualisiert von: siggi-heltau,