Lexikalische Grammatik

Diese Seite beschreibt die lexikalische Grammatik von JavaScript. Der Programmcode von ECMAScript-Skripten wird von links nach rechts gelesen und in eine Sequenz von Eingangselementen konvertiert, welche Tokens, Kontrollzeichen, Zeilentrenner, Kommentare oder Whitespaces sein können. ECMAScript definiert zudem einige Schlüsselworte und Literale und hat Regeln für automatisch eingefügte Semikolons am ende eines Statements.

Kontrollzeichen

Kontrollzeichen haben keine sichtbare Repräsentation werden aber für die Kontrolle der Interpretation des Textes benutzt.

Whitespaces

Mit Spacezeichen wird die Lesbarkeit des Quelltextes verbessert und sie trennen Tokens voneinander. Diese Zeichen sind bedeutungslos für die Funktionalität des Programms. Minification Tools werden oft benutzt, um Whitespaces zu entfernen, um die übertragenen Daten zu reduzieren.

Zeilenumbruch

Neben Whitespacezeichen werden Zeilenumbrüche auch eingesetzt, um die Lesbarkeit des Programmes zu verbessern. Es gibt ein paar Fälle, bei denen ein Zeilenumbruch einen Einfluss auf die Ausführung von JavaScript Programmen kann und an wenigen Stellen sind sie verboten. Zeilenumbrüche haben zudem einen Einfluss auf den Prozess der automatischen eingefügten Semikolons. Zeilenumbrüche werden mit der \s Klasse in Regulären Ausdrücken erkannt.

Nur die folgenden Unicode Codepoints werden als Zeilenumbrüche in ECMAScript erkannt. Andere Zeilenumbruchszeichen werden als Whitespaces erkannt (zum Beispiel sind Next Line, NEL, U+0085 Whitspaces).

Kommentare

Kommentare werden benutzt, um Hinweise, Notizen, Vorschläge oder Warnungen im JavaScript Programmcode zu hinterlassen. Das kann zur Lesbarkeit und Verständnis beisteuern. Sie können auch eingesetzt werden, um ein Programmzeil auszuschalten, damit es nicht ausgeführt wird; das kan ein Werkzeug zum Debuggen sein.

JavaScript kennt zwei Typen von Kommentaren.

Der erste Typ ist der // Kommentar; Dieser macht alle folgenden Zeichen in der gleichen Zeile zu einem Kommentar. Zum Beispiel:

function comment() {
  // Dieses ist ein einzeiliger JavaScript Kommentar
  console.log('Hello world!');
}
comment();

Der zweite Typ ist der /* */ Style, welcher deutlich flexibler ist.

Zum Beispiel kann er auf eine Zeile angewendet werden:

function comment() {
  /* Dieses ist ein einzeiliger JavaScript Kommentar */
  console.log('Hello world!');
}
comment();

Man kann aber auch mehrzeilige Kommentare wie folgenden machen:

function comment() {
  /* Dieses ist ein mehrzeiliger Kommentar. Zu beachten ist, 
     dass wir den Kommentar erst beenden müssen, wenn wir fertig sind. */
  console.log('Hello world!');
}
comment();

Man kann aber auch einen Kommentar mitten in einer Zeile machen. Diese kann die Lesbarkeit aber negativ beeinträchtigen, weshalb diese Art mit Vorsicht zu genießen ist:

function comment(x) {
  console.log('Hello ' + x /* Fügt den Wert von x ein */ + ' !');
}
comment('world');

Natürlich kann diese Art auch eingesetzt werden, um Programmteile zu deaktivieren, wie es folgendes Beispiel zeigt:

function comment() {
  /* console.log('Hello world!'); */
}
comment();

In diese Fall wird der Aufruf von console.log() nie ausgeführt, weil er in einem Kommentar ist. Jede Zeile im Programm kann so deaktiviert werden.

Schlüsselwörter

Reservierte Schlüsselwörter in ECMAScript 2015

• break
• case
• catch
• class
• const
• continue
• debugger
• default
• delete
• do
• else
• export
• extends
• finally
• for
• function
• if
• import
• in
• instanceof
• new
• return
• super
• switch
• this
• throw
• try
• typeof
• var
• void
• while
• with
• yield

Reservierte zukünftige Schlüsselworte

Die folgenden Schlüsselwörter sind für die Zukunft von der ECMAScript Spezifikation reserviert. Sie haben aktuell keine spezielle Funktion, können aber in Zukunft eine Funktion bekommen, weshalb sie nicht als Bezeichner verwendet werden können.

Dieses ist immer reserviert:

• enum

Die folgenden sind nur reserviert, wenn sie im strict mode benutzt werden:

• implements
• interface
• let
• package
• private
• protected
• public
• static

Die folgenden sind nur reserviert, wenn sie im Modul-Quelltext benutzt werden:

• await

Reservierte zukünftige Schlüsselwörter aus älteren Standards

Die folgenden Schlüsselwörter wurden als zukünftige Schlüsselwörter in älteren ECMAScript Spezifikationen (ECMAScript 1 bis 3) definiert.

• abstract
• boolean
• byte
• char
• double
• final
• float
• goto
• int
• long
• native
• short
• synchronized
• throws
• transient
• volatile

Zudem können die Literale null, true, und false nicht als Bezeichner in ECMAScript verwendet werden.

Reservierte Wörter benutzen

Reservierte Wörter gelten aktuell nur für Bezeichner (vs. Bezeichnernamen). Wie im es5.github.com/#A.1 beschrieben ist, sind diese alle Bezeichnernamen welches, bei welchen die Reservierten Wörter nicht ausgenommen sind.

a.import
a['import']
a = { import: 'test' }.

Auf der anderes Seite ist das folgende nicht erlaubt, weil es ein Bezeichner ist, der welcher ein Bezeichnername ohne ein reserviertes Wort ist. Bezeichner werden für Funktionsdeklarationen, Funktionsausdrücke, Variablendeklarationen und so weiter benutzt. Bezeichnernamen werden für Eigenschaftsausdrücke, Aufrufausdrücke und so weiter eingesetzt.

function import() {} // Illegal.

Literale

Null Literal

Sie bei null für mehr Informationen.

null

Boolean Literal

Siehe bei Boolean für mehr Informationen.

true
false

Nummerische Literale

Dezimal

1234567890
42

// Vorsicht beim Einsatz von führenden Nullen:
0888 // 888 parsed as decimal
0777 // parsed as octal, 511 in decimal

Zu bemerken ist, dass Dezimal Literale mit eine Null (0) starten können gefolgt von anderen Dezimalstellen, aber wenn alle Zifferen nach der führenden 0 kleiner als 8 sind, wird die Zahl als Oktalzahl interpretiert. Dieses erzeugt in JavaScript keinen Fehler (siehe Bug 957513). Sie zudem auch auf der Seite über parseInt().

Binär

Die Syntax für Binärzahlen setzt sich aus einer führenden Null gefolgt von einem großen oder kleinen lateinischem Buchstachen "B" (0b oder 0B). Weil dieses Syntax in ECMAScript 2015 neu ist, sollte auf die Kompatibilitätstabelle unten geschaut werden. Wenn Ziffern nach 0b nicht 0 oder 1 sind, wird folgender SyntaxError erzeugt: "Missing binary digits after 0b".

var FLT_SIGNBIT  = 0b10000000000000000000000000000000; // 2147483648
var FLT_EXPONENT = 0b01111111100000000000000000000000; // 2139095040
var FLT_MANTISSA = 0B00000000011111111111111111111111; // 8388607

Oktal

Die Syntax für Oktalzahlen setzt sich aus einer führenden Null gefolgt von einem großen oder kleinen lateinischem Buchstachen "O" (0o oder 0O). Weil dieses Syntax in ECMAScript 2015 neu ist, sollte auf die Kompatibilitätstabelle unten geschaut werden. Wenn Ziffern nach 0o außerhalb der Grenzen (01234567) sind, wird folgender SyntaxError erzeugt: "Missing octal digits after 0o".

var n = 0O755; // 493
var m = 0o644; // 420

// Auch mit nur einer führenden Null möglich (siehe dazu die Bemerkung bei den Dezimalzahlen)
0755
0644

Hexadezimal

Die Syntax für Hexadezimalahlen setzt sich aus einer führenden Null gefolgt von einem großen oder kleinen lateinischem Buchstachen "X" (0x oder 0X). Wenn Ziffern nach 0x außerhalb der Grenzen (0123456789ABCDEF) sind, wird folgender SyntaxError erzeugt: "Identifier starts immediately after numeric literal".

0xFFFFFFFFFFFFFFFFF // 295147905179352830000
0x123456789ABCDEF   // 81985529216486900
0XA                 // 10

Objekt-Literale

Siehe Object und Objektinitialisierer für mehr Informationen.

var o = { a: 'foo', b: 'bar', c: 42 };

// Kurzschreibweise. Neu in ES2015
var a = 'foo', b = 'bar', c = 42;
var o = {a, b, c};

// stattdessen
var o = { a: a, b: b, c: c };

Array Literale

Siehe Array für mehr Informationen.

[1954, 1974, 1990, 2014]

String Literale

'foo'
"bar"

Hexadezimal maskierte Sequenzen

Hexadezimal maskierte Sequenzen bestehen aus \x gefolgt von exakt zwei Hexadezimalziffern, die eine Codeeinheit oder einen Codepoint in einem Bereich von 0x0000 bis 0x00FF repräsentieren.

'\xA9' // "©"

Unicode maskierte Sequenzen

Eine Unicode maskierte Sequenz besteht aus genau vier Hexadezimalstellen nach einem \u. Sie bestimmt ein zwei Byte Zeichen in der UTF-16 Kodierung. Für Codepoints zwischen U+0000 und U+FFFF sind die Ziffern identisch mit den Codepoints. Codepoints von U+10000 bis U+10FFFF müssen über zwei maskierte Sequenzen, einem Ersatzpaar, angegeben werden. Das Ersatzpaar unterscheidet sich vom Codepoint.

Siehe dazu auch String.fromCharCode() und String.prototype.charCodeAt().

'\u00A9' // "©" (U+A9)

Unicode Codepointmaskierung

Mit Unicode Codepointmaskierung besteht aus \u{ gefolgt von einem Codepoint in hexadezimaler Basis gefolgt von }. Die Werte der Hexadezimalstellen müssen in einem Bereich von 0 und 0x10FFFF inklusiv sein. Codepoints in einem Bereich von U+10000 bis U+10FFFF müssen nicht als Ersatzpaar angegeben werden. Codepointsmaskierung wurde in ECMAScript 2015 (ES6) zu JavaSCript hinzugefügt.

Siehe zudem auch String.fromCodePoint() und String.prototype.codePointAt().

'\u{2F804}' // CJK COMPATIBILITY IDEOGRAPH-2F804 (U+2F804)

// Das gleiche mit einfache Unicodemaskierung
'\uD87E\uDC04'

Reguläre Ausdrucksliterale

Siehe zudem RegExp für mehr Informationen.

/ab+c/g

// Ein "leerers" Regulärers Ausdrucksliteral
// Die leere Gruppe ist notwendig,
// um einen einzeiligen Kommentar zu verhindern.
/(?:)/

Template Literale

Siehe zudem Template Strings für mehr Informationen.

`string text`

`string text zeile 1
 string text zeile 2`

`string text ${ausdruck} string text`

tag `string text ${ausdruck} string text`

Automatisches Einfügen von Semikolons

Eine JavaScript Statements müssen durch ein Semikolon beendet werden, wodurch die automatisches Einfügen von Semikolon (ASI kurz für automatic semicolon insertion) einen Einfluss auf diese hat:

• Leeres Statement
• let, const, Variablen Statements
• import, export, Modul Deklarationen
• Ausdrucksstatements
• debugger
• continue, break, throw
• return

Die ECMAScript Spezifikation erwähnt drei Regeln für automatisches Einfügen von Semikolons.

1. Ein Semikolon wird eingefügt, bevor ein Zeilenumbruch oder "}" angegeben wird, welches nicht von der Grammatik erlaubt ist.

{ 1 2 } 3 

// Wird von ASI in folgendes transformiert 

{ 1 2 ;} 3;

2. Ein Semikolon wird am ende Eingefügt, wenn das Ende der eingehenden Tokens erkannt wurde und der Parser nicht in der Lage ist den Input als ganzes Programm zu erkennen.

Hier wird ++ nicht als Postfixoperator für die Variable b erkannt, weil ein Zeilenumbruch zwischen b und ++ ist.

a = b
++c

// Wird von ASI in folgendes transformiert

a = b;
++c;

3. Ein Semikolon wird am Ende eingefügt, wenn auf eine Anweisung mit eingeschränkten Produktionen in der Grammatik ein Zeilenabschlusszeichen folgt. Diese Anweisungen mit "no LineTerminator here"-Regeln lauten:

• Postfixausdrücke (++ und --)
• continue
• break
• return
• yield, yield*
• module

return
a + b

// Wird von ASI in folgendes transformiert

return;
a + b;

Spezifikationen

Browserkompatibilität

Siehe auch

• Jeff Walden: Binary and octal numbers
• Mathias Bynens: JavaScript character escape sequences
• Boolean
• Number
• RegExp
• String