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.

Unicode-Formatkontrollzeichen
Codepoint Name Abkürzung Beschreibung
U+200C Bindehemmer <ZWNJ> Zwischen Zeichen platziert, um zu verhindern, dass sie in bestimmte Sprachen in Ligaturen eingebunden werden (Wikipedia).
U+200D Breitenloser Verbinder <ZWJ> Platziert zwischen Zeichen, die normalerweise nicht verbunden sind, um zu bewirken, dass die Zeichen mit ihrer verbundenen Form in bestimmten Sprachen angezeigt werden (Wikipedia).
U+FEFF Byte Order Mark <BOM> Wird am Anfang des Skripts verwendet, um es als Unicode und die Bytereihenfolge des Texts zu markieren (Wikipedia).

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.

Whitespacezeichen
Codepoint Name Abkürzung Beschreibung Maskierte Sequenz
U+0009 Zeichen Tabulator <HT> Horizontaler Tabulator \t
U+000B Zeilen Tabulator <VT> Vertikaler Tabulator \v
U+000C Form feed <FF> Kontrollzeichen für den Seitenumbruch (Wikipedia). \f
U+0020 Space <SP> Normales Leerzeichen  
U+00A0 Nicht unterbrechenedes space <NBSP> Normal Leerzeichen, aber keine Stelle an der die Zeile unterbrochen werden kann.  
Others Andere Unicode Spacezeichen <USP> Spaces in Unicode auf Wikipedia  

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).

Zeilenumbruchszeichen
Codepoint Name Abkürzung Beschreibung Maskierte Sequenz
U+000A Line Feed <LF> Zeichen für Zeilenumbruch in UNIX Systemen. \n
U+000D Carriage Return <CR> Zeichen für Zeilenumbruch in Commodore und frühen Mac Systemen. \r
U+2028 Line Separator <LS> Wikipedia  
U+2029 Paragraph Separator <PS> Wikipedia  

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

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

'\xA9' // "©"

Unicode maskierte Sequenzen

Eine Unicode maskierte Sequenz besteht aus genau vier Hexadezimalstellen nach einem \u. Jede bestimmt ein zwei Byte Zeichen in der UTF-16 Kodierung. Für Codepoints zwischen 0 und FFFF sind die Ziffern identisch mit den Codepoints. Höhere Codepoints müssen über zwei maskierte Sequenzen, einem Ersatzpaar, angegeben werden. Das Ersatzpaar unterscheidet sich vom Codepoint.

'\u00A9' // "©"

Unicode Codepointmaskierung

Neu in ECMAScript 2015. Mit Unicode Codepointmaskierung ist es möglich jedes Zeichen mit Hexadezimalzahlen zu Maskierung bis hin zu dem Codepoint 0x10FFFF. Mit einfacher Unicodemaskierung ist es oft nötig die zwei Hälften des Ersatzpaares zu schreiben, um das gleiche zu erzielen.

Siehe zudem bei String.fromCodePoint() oder String.prototype.codePointAt() nach.

'\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

Spezifikation Status Kommentar
ECMAScript 1st Edition (ECMA-262) Standard Initiale Definition.
ECMAScript 5.1 (ECMA-262)
Die Definition von 'Lexical Conventions' in dieser Spezifikation.
Standard  
ECMAScript 2015 (6th Edition, ECMA-262)
Die Definition von 'Lexical Grammar' in dieser Spezifikation.
Standard Hinzugefügt: Binäre und Oktal Zahlenliterale, Unicode Codepoint-Maskierung, Templates
ECMAScript Latest Draft (ECMA-262)
Die Definition von 'Lexical Grammar' in dieser Spezifikation.
Entwurf  

Browserkompatibilität

FeatureChromeEdgeFirefoxInternet ExplorerOperaSafari
Array literals ([1, 2, 3]) Ja Ja1 Ja Ja Ja
Binary numeric literals (0b)411225 ?289
Boolean literals (true/false) Ja Ja1 Ja Ja Ja
Decimal numeric literals (1234567890) Ja Ja1 Ja Ja Ja
Hexadecimal escape sequences ('\0xA9') Ja Ja1 Ja Ja Ja
Hexadecimal numeric literals (0xAF) Ja Ja1 Ja Ja Ja
Null literal (null) Ja Ja1 Ja Ja Ja
Octal numeric literals (0o)411225 ?289
Regular expression literals (/ab+c/g) Ja Ja1 Ja Ja Ja
String literals ('Hello world') Ja Ja1 Ja Ja Ja
Unicode escape sequences ('\u00A9') Ja Ja1 Ja Ja Ja
Unicode point escapes (\u{})441240 Nein319
Shorthand notation for object literals431233 Nein309
Template literals411234 Nein289
Trailing commas Ja Ja1 Ja Ja Ja
FeatureAndroid webviewChrome for AndroidEdge mobileFirefox for AndroidOpera AndroidiOS SafariSamsung Internet
Array literals ([1, 2, 3]) Ja Ja Ja4 Ja Ja Ja
Binary numeric literals (0b)4141122528 Ja4.0
Boolean literals (true/false) Ja Ja Ja4 Ja Ja Ja
Decimal numeric literals (1234567890) Ja Ja Ja4 Ja Ja Ja
Hexadecimal escape sequences ('\0xA9') Ja Ja Ja4 Ja Ja Ja
Hexadecimal numeric literals (0xAF) Ja Ja Ja4 Ja Ja Ja
Null literal (null) Ja Ja Ja4 Ja Ja Ja
Octal numeric literals (0o)4141122528 Ja4.0
Regular expression literals (/ab+c/g) Ja Ja Ja4 Ja Ja Ja
String literals ('Hello world') Ja Ja Ja4 Ja Ja Ja
Unicode escape sequences ('\u00A9') Ja Ja Ja4 Ja Ja Ja
Unicode point escapes (\u{})4444124031 ?4.0
Shorthand notation for object literals4343123330 ?4.0
Template literals4141123428 ?4.0
Trailing commas Ja Ja Ja4 Ja Ja Ja

Siehe auch

Schlagwörter des Dokuments und Mitwirkende

 Mitwirkende an dieser Seite: schlagi123
 Zuletzt aktualisiert von: schlagi123,