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.
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.
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).
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
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()
(en-US).
'\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()
(en-US) und String.prototype.codePointAt()
(en-US).
'\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 Statementsimport
,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 (ECMA-262) Die Definition von 'Lexical Grammar' in dieser Spezifikation. |
Lebender Standard |
Browserkompatibilität
BCD tables only load in the browser