path: root/files/de/web/javascript/reference/lexical_grammar/index.html

---
title: Lexikalische Grammatik
slug: Web/JavaScript/Reference/Lexical_grammar
tags:
  - JavaScript
  - Keyword
  - Lexical Grammer
  - Literal
translation_of: Web/JavaScript/Reference/Lexical_grammar
---
<div>{{JsSidebar("More")}}</div>

<p>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.</p>

<h2 id="Kontrollzeichen">Kontrollzeichen</h2>

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

<table class="standard-table">
 <caption>Unicode-Formatkontrollzeichen</caption>
 <tbody>
  <tr>
   <th>Codepoint</th>
   <th>Name</th>
   <th>Abkürzung</th>
   <th>Beschreibung</th>
  </tr>
  <tr>
   <td><code>U+200C</code></td>
   <td>Bindehemmer</td>
   <td>&lt;ZWNJ&gt;</td>
   <td>Zwischen Zeichen platziert, um zu verhindern, dass sie in bestimmte Sprachen in Ligaturen eingebunden werden (<a href="https://de.wikipedia.org/wiki/Bindehemmer">Wikipedia</a>).</td>
  </tr>
  <tr>
   <td><code>U+200D</code></td>
   <td>Breitenloser Verbinder</td>
   <td>&lt;ZWJ&gt;</td>
   <td>Platziert zwischen Zeichen, die normalerweise nicht verbunden sind, um zu bewirken, dass die Zeichen mit ihrer verbundenen Form in bestimmten Sprachen angezeigt werden (<a href="https://de.wikipedia.org/wiki/Breitenloser_Verbinder">Wikipedia</a>).</td>
  </tr>
  <tr>
   <td><code>U+FEFF</code></td>
   <td>Byte Order Mark</td>
   <td>&lt;BOM&gt;</td>
   <td>Wird am Anfang des Skripts verwendet, um es als Unicode und die Bytereihenfolge des Texts zu markieren (<a href="https://de.wikipedia.org/wiki/Byte_Order_Mark">Wikipedia</a>).</td>
  </tr>
 </tbody>
</table>

<h2 id="Whitespaces">Whitespaces</h2>

<p>Mit Spacezeichen wird die Lesbarkeit des Quelltextes verbessert und sie trennen Tokens voneinander. Diese Zeichen sind bedeutungslos für die Funktionalität des Programms. <a href="http://en.wikipedia.org/wiki/Minification_%28programming%29">Minification Tools</a> werden oft benutzt, um Whitespaces zu entfernen, um die übertragenen Daten zu reduzieren.</p>

<table class="standard-table">
 <caption>Whitespacezeichen</caption>
 <tbody>
  <tr>
   <th>Codepoint</th>
   <th>Name</th>
   <th>Abkürzung</th>
   <th>Beschreibung</th>
   <th>Maskierte Sequenz</th>
  </tr>
  <tr>
   <td>U+0009</td>
   <td>Zeichen Tabulator</td>
   <td>&lt;HT&gt;</td>
   <td>Horizontaler Tabulator</td>
   <td>\t</td>
  </tr>
  <tr>
   <td>U+000B</td>
   <td>Zeilen Tabulator</td>
   <td>&lt;VT&gt;</td>
   <td>Vertikaler Tabulator</td>
   <td>\v</td>
  </tr>
  <tr>
   <td>U+000C</td>
   <td>Form feed</td>
   <td>&lt;FF&gt;</td>
   <td>Kontrollzeichen für den Seitenumbruch (<a href="http://en.wikipedia.org/wiki/Page_break#Form_feed">Wikipedia</a>).</td>
   <td>\f</td>
  </tr>
  <tr>
   <td>U+0020</td>
   <td>Space</td>
   <td>&lt;SP&gt;</td>
   <td>Normales Leerzeichen</td>
   <td> </td>
  </tr>
  <tr>
   <td>U+00A0</td>
   <td>Nicht unterbrechenedes space</td>
   <td>&lt;NBSP&gt;</td>
   <td>Normal Leerzeichen, aber keine Stelle an der die Zeile unterbrochen werden kann.</td>
   <td> </td>
  </tr>
  <tr>
   <td>Others</td>
   <td>Andere Unicode Spacezeichen</td>
   <td>&lt;USP&gt;</td>
   <td><a href="https://de.wikipedia.org/wiki/Leerzeichen">Spaces in Unicode auf Wikipedia</a></td>
   <td> </td>
  </tr>
 </tbody>
</table>

<h2 id="Zeilenumbruch">Zeilenumbruch</h2>

<p>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 <a href="/de/docs/Web/JavaScript/Reference/Lexical_grammar#Automatisches_Einfügen_von_Semikolons">automatischen eingefügten Semikolons</a>. Zeilenumbrüche werden mit der <strong>\s</strong> Klasse in <a href="/de/docs/Web/JavaScript/Guide/Regular_Expressions">Regulären Ausdrücken</a> erkannt.</p>

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

<table class="standard-table">
 <caption>Zeilenumbruchszeichen</caption>
 <tbody>
  <tr>
   <th>Codepoint</th>
   <th>Name</th>
   <th>Abkürzung</th>
   <th>Beschreibung</th>
   <th>Maskierte Sequenz</th>
  </tr>
  <tr>
   <td>U+000A</td>
   <td>Line Feed</td>
   <td>&lt;LF&gt;</td>
   <td>Zeichen für Zeilenumbruch in UNIX Systemen.</td>
   <td>\n</td>
  </tr>
  <tr>
   <td>U+000D</td>
   <td>Carriage Return</td>
   <td>&lt;CR&gt;</td>
   <td>Zeichen für Zeilenumbruch in Commodore und frühen Mac Systemen.</td>
   <td>\r</td>
  </tr>
  <tr>
   <td>U+2028</td>
   <td>Line Separator</td>
   <td>&lt;LS&gt;</td>
   <td><a href="https://de.wikipedia.org/wiki/Zeilenumbruch">Wikipedia</a></td>
   <td> </td>
  </tr>
  <tr>
   <td>U+2029</td>
   <td>Paragraph Separator</td>
   <td>&lt;PS&gt;</td>
   <td><a href="https://de.wikipedia.org/wiki/Zeilenumbruch">Wikipedia</a></td>
   <td> </td>
  </tr>
 </tbody>
</table>

<h2 id="Kommentare">Kommentare</h2>

<p>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.</p>

<p>JavaScript kennt zwei Typen von Kommentaren.</p>

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

<pre class="brush: js">function comment() {
  // Dieses ist ein einzeiliger JavaScript Kommentar
  console.log('Hello world!');
}
comment();
</pre>

<p>Der zweite Typ ist der <code>/* */</code> Style, welcher deutlich flexibler ist.</p>

<p>Zum Beispiel kann er auf eine Zeile angewendet werden:</p>

<pre class="brush: js">function comment() {
  /* Dieses ist ein einzeiliger JavaScript Kommentar */
  console.log('Hello world!');
}
comment();</pre>

<p>Man kann aber auch mehrzeilige Kommentare wie folgenden machen:</p>

<pre class="brush: js">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();</pre>

<p>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:</p>

<pre class="brush: js">function comment(x) {
  console.log('Hello ' + x /* Fügt den Wert von x ein */ + ' !');
}
comment('world');</pre>

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

<pre class="brush: js">function comment() {
  /* console.log('Hello world!'); */
}
comment();</pre>

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

<h2 id="Schlüsselwörter">Schlüsselwörter</h2>

<h3 id="Reservierte_Schlüsselwörter_in_ECMAScript_2015">Reservierte Schlüsselwörter in ECMAScript 2015</h3>

<ul class="threecolumns">
 <li>{{jsxref("Statements/break", "break")}}</li>
 <li>{{jsxref("Statements/switch", "case")}}</li>
 <li>{{jsxref("Statements/try...catch", "catch")}}</li>
 <li>{{jsxref("Statements/class", "class")}}</li>
 <li>{{jsxref("Statements/const", "const")}}</li>
 <li>{{jsxref("Statements/continue", "continue")}}</li>
 <li>{{jsxref("Statements/debugger", "debugger")}}</li>
 <li>{{jsxref("Statements/default", "default")}}</li>
 <li>{{jsxref("Operators/delete", "delete")}}</li>
 <li>{{jsxref("Statements/do...while", "do")}}</li>
 <li>{{jsxref("Statements/if...else", "else")}}</li>
 <li>{{jsxref("Statements/export", "export")}}</li>
 <li>{{jsxref("Statements/class", "extends")}}</li>
 <li>{{jsxref("Statements/try...catch", "finally")}}</li>
 <li>{{jsxref("Statements/for", "for")}}</li>
 <li>{{jsxref("Statements/function", "function")}}</li>
 <li>{{jsxref("Statements/if...else", "if")}}</li>
 <li>{{jsxref("Statements/import", "import")}}</li>
 <li>{{jsxref("Operators/in", "in")}}</li>
 <li>{{jsxref("Operators/instanceof", "instanceof")}}</li>
 <li>{{jsxref("Operators/new", "new")}}</li>
 <li>{{jsxref("Statements/return", "return")}}</li>
 <li>{{jsxref("Operators/super", "super")}}</li>
 <li>{{jsxref("Statements/switch", "switch")}}</li>
 <li>{{jsxref("Operators/this", "this")}}</li>
 <li>{{jsxref("Statements/throw", "throw")}}</li>
 <li>{{jsxref("Statements/try...catch", "try")}}</li>
 <li>{{jsxref("Operators/typeof", "typeof")}}</li>
 <li>{{jsxref("Statements/var", "var")}}</li>
 <li>{{jsxref("Operators/void", "void")}}</li>
 <li>{{jsxref("Statements/while", "while")}}</li>
 <li>{{jsxref("Statements/with", "with")}}</li>
 <li>{{jsxref("Operators/yield", "yield")}}</li>
</ul>

<h3 id="Reservierte_zukünftige_Schlüsselworte">Reservierte zukünftige Schlüsselworte</h3>

<p>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.</p>

<p>Dieses ist immer reserviert:</p>

<ul>
 <li><code>enum</code></li>
</ul>

<p>Die folgenden sind nur reserviert, wenn sie im strict mode benutzt werden:</p>

<ul class="threecolumns">
 <li><code>implements</code></li>
 <li><code>interface</code></li>
 <li>{{jsxref("Statements/let", "let")}}</li>
 <li><code>package</code></li>
 <li><code>private</code></li>
 <li><code>protected</code></li>
 <li><code>public</code></li>
 <li><code>static</code></li>
</ul>

<p>Die folgenden sind nur reserviert, wenn sie im Modul-Quelltext benutzt werden:</p>

<ul>
 <li><code>await</code></li>
</ul>

<h4 id="Reservierte_zukünftige_Schlüsselwörter_aus_älteren_Standards">Reservierte zukünftige Schlüsselwörter aus älteren Standards</h4>

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

<ul class="threecolumns">
 <li><code>abstract</code></li>
 <li><code>boolean</code></li>
 <li><code>byte</code></li>
 <li><code>char</code></li>
 <li><code>double</code></li>
 <li><code>final</code></li>
 <li><code>float</code></li>
 <li><code>goto</code></li>
 <li><code>int</code></li>
 <li><code>long</code></li>
 <li><code>native</code></li>
 <li><code>short</code></li>
 <li><code>synchronized</code></li>
 <li><code>throws</code></li>
 <li><code>transient</code></li>
 <li><code>volatile</code></li>
</ul>

<p>Zudem können die Literale <code>null</code>, <code>true</code>, und <code>false</code> nicht als Bezeichner in ECMAScript verwendet werden.</p>

<h3 id="Reservierte_Wörter_benutzen">Reservierte Wörter benutzen</h3>

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

<pre class="brush: js">a.import
a['import']
a = { import: 'test' }.
</pre>

<p>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.</p>

<pre class="brush: js">function import() {} // Illegal.</pre>

<h2 id="Literale">Literale</h2>

<h3 id="Null_Literal">Null Literal</h3>

<p>Sie bei <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/null"><code>null</code></a> für mehr Informationen.</p>

<pre class="brush: js">null</pre>

<h3 id="Boolean_Literal">Boolean Literal</h3>

<p>Siehe bei <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean"><code>Boolean</code></a> für mehr Informationen.</p>

<pre class="brush: js">true
false</pre>

<h3 id="Nummerische_Literale">Nummerische Literale</h3>

<h4 id="Dezimal">Dezimal</h4>

<pre class="brush: js">1234567890
42

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

<p>Zu bemerken ist, dass Dezimal Literale mit eine Null (<code>0</code>) starten können gefolgt von anderen Dezimalstellen, aber wenn alle Zifferen nach der führenden <code>0</code> kleiner als <code>8</code> sind, wird die Zahl als Oktalzahl interpretiert. Dieses erzeugt in JavaScript keinen Fehler (siehe {{bug(957513)}}). Sie zudem auch auf der Seite über <a href="/de/docs/Web/JavaScript/Reference/Global_Objects/parseInt#Octal_interpretations_with_no_radix"><code>parseInt()</code></a>.</p>

<h4 id="Binär">Binär</h4>

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

<pre class="brush: js">var FLT_SIGNBIT  = 0b10000000000000000000000000000000; // 2147483648
var FLT_EXPONENT = 0b01111111100000000000000000000000; // 2139095040
var FLT_MANTISSA = 0B00000000011111111111111111111111; // 8388607</pre>

<h4 id="Oktal">Oktal</h4>

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

<pre class="brush: js">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
</pre>

<h4 id="Hexadezimal">Hexadezimal</h4>

<p>Die Syntax für Hexadezimalahlen setzt sich aus einer führenden Null gefolgt von einem großen oder kleinen lateinischem Buchstachen "X" (<code>0x</code> oder <code>0X</code>). Wenn Ziffern nach <code>0x</code> außerhalb der Grenzen (0123456789ABCDEF) sind, wird folgender <code><a href="/de/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError">SyntaxError</a></code> erzeugt: "Identifier starts immediately after numeric literal".</p>

<pre class="brush: js">0xFFFFFFFFFFFFFFFFF // 295147905179352830000
0x123456789ABCDEF   // 81985529216486900
0XA                 // 10
</pre>

<h3 id="Objekt-Literale">Objekt-Literale</h3>

<p>Siehe {{jsxref("Object")}} und <a href="/de/docs/Web/JavaScript/Reference/Operators/Object_initializer">Objektinitialisierer</a> für mehr Informationen.</p>

<pre class="brush: js">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 };
</pre>

<h3 id="Array_Literale">Array Literale</h3>

<p>Siehe {{jsxref("Array")}} für mehr Informationen.</p>

<pre class="brush: js">[1954, 1974, 1990, 2014]</pre>

<h3 id="String_Literale">String Literale</h3>

<pre class="brush: js">'foo'
"bar"</pre>

<h4 id="Hexadezimal_maskierte_Sequenzen">Hexadezimal maskierte Sequenzen</h4>

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

<pre class="brush: js">'\xA9' // "©"
</pre>

<h4 id="Unicode_maskierte_Sequenzen">Unicode maskierte Sequenzen</h4>

<p>Eine Unicode maskierte Sequenz besteht aus genau vier Hexadezimalstellen nach einem <code>\u</code>. 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.</p>

<p>Siehe dazu auch {{jsxref("String.fromCharCode()")}} und {{jsxref("String.prototype.charCodeAt()")}}.</p>

<pre class="brush: js">'\u00A9' // "©" (U+A9)</pre>

<h4 id="Unicode_Codepointmaskierung">Unicode Codepointmaskierung</h4>

<p>Mit Unicode Codepointmaskierung besteht aus <code>\u{</code> gefolgt von einem Codepoint in hexadezimaler Basis gefolgt von <code>}</code>. 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.</p>

<p>Siehe zudem auch {{jsxref("String.fromCodePoint()")}} und {{jsxref("String.prototype.codePointAt()")}}.</p>

<pre class="brush: js">'\u{2F804}' // <code class="language-js"><span class="comment token">CJK COMPATIBILITY IDEOGRAPH-2F804 (U+2F804)</span></code>

// Das gleiche mit einfache Unicodemaskierung
'\uD87E\uDC04'</pre>

<h3 id="Reguläre_Ausdrucksliterale">Reguläre Ausdrucksliterale</h3>

<p>Siehe zudem <a href="/de/docs/Web/JavaScript/Reference/Global_Objects/RegExp"><code>RegExp</code></a> für mehr Informationen.</p>

<pre class="brush: js">/ab+c/g

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

<h3 id="Template_Literale">Template Literale</h3>

<p>Siehe zudem <a href="/de/docs/Web/JavaScript/Reference/template_strings">Template Strings</a> für mehr Informationen.</p>

<pre class="brush: js">`string text`

`string text zeile 1
 string text zeile 2`

`string text ${ausdruck} string text`

tag `string text ${ausdruck} string text`</pre>

<h2 id="Automatisches_Einfügen_von_Semikolons">Automatisches Einfügen von Semikolons</h2>

<p>Eine <a href="/de/docs/Web/JavaScript/Reference/Statements">JavaScript Statements</a> müssen durch ein Semikolon beendet werden, wodurch die automatisches Einfügen von Semikolon (ASI kurz für <em>automatic semicolon insertion</em>) einen Einfluss auf diese hat:</p>

<ul>
 <li>Leeres Statement</li>
 <li><code>let</code>, <code>const</code>, Variablen Statements</li>
 <li><code>import</code>, <code>export</code>, Modul Deklarationen</li>
 <li>Ausdrucksstatements</li>
 <li><code>debugger</code></li>
 <li><code>continue</code>, <code>break</code>, <code>throw</code></li>
 <li><code>return</code></li>
</ul>

<p>Die ECMAScript Spezifikation erwähnt <a href="https://tc39.github.io/ecma262/#sec-rules-of-automatic-semicolon-insertion">drei Regeln für automatisches Einfügen von Semikolons</a>.</p>

<p>1. Ein Semikolon wird eingefügt, bevor ein <a href="#">Zeilenumbruch</a> oder "}" angegeben wird, welches nicht von der Grammatik erlaubt ist.</p>

<pre class="brush: js">{ 1 2 } 3

// Wird von ASI in folgendes transformiert

{ 1 2 ;} 3;</pre>

<p>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.</p>

<p>Hier wird <code>++</code> nicht als <a href="/de/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Inkrement_()">Postfixoperator</a> für die Variable <code>b</code> erkannt, weil ein Zeilenumbruch zwischen <code>b</code> und <code>++</code> ist.</p>

<pre class="brush: js">a = b
++c

// Wird von ASI in folgendes transformiert

a = b;
++c;
</pre>

<p>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:</p>

<ul>
 <li>Postfixausdrücke (<code>++</code> und <code>--</code>)</li>
 <li><code>continue</code></li>
 <li><code>break</code></li>
 <li><code>return</code></li>
 <li><code>yield</code>, <code>yield*</code></li>
 <li><code>module</code></li>
</ul>

<pre class="brush: js">return
a + b

// Wird von ASI in folgendes transformiert

return;
a + b;
</pre>

<h2 id="Spezifikationen">Spezifikationen</h2>

<table class="standard-table">
 <tbody>
  <tr>
   <th scope="col">Spezifikation</th>
   <th scope="col">Status</th>
   <th scope="col">Kommentar</th>
  </tr>
  <tr>
   <td>{{SpecName('ES1')}}</td>
   <td>{{Spec2("ES1")}}</td>
   <td>Initiale Definition.</td>
  </tr>
  <tr>
   <td>{{SpecName('ES5.1', '#sec-7', 'Lexical Conventions')}}</td>
   <td>{{Spec2('ES5.1')}}</td>
   <td> </td>
  </tr>
  <tr>
   <td>{{SpecName('ES6', '#sec-ecmascript-language-lexical-grammar', 'Lexical Grammar')}}</td>
   <td>{{Spec2('ES6')}}</td>
   <td>Hinzugefügt: Binäre und Oktal Zahlenliterale, Unicode Codepoint-Maskierung, Templates</td>
  </tr>
  <tr>
   <td>{{SpecName('ESDraft', '#sec-ecmascript-language-lexical-grammar', 'Lexical Grammar')}}</td>
   <td>{{Spec2('ESDraft')}}</td>
   <td> </td>
  </tr>
 </tbody>
</table>

<h2 id="Browserkompatibilität">Browserkompatibilität</h2>



<p>{{Compat("javascript.grammar")}}</p>

<h2 id="Siehe_auch">Siehe auch</h2>

<ul>
 <li><a href="http://whereswalden.com/2013/08/12/micro-feature-from-es6-now-in-firefox-aurora-and-nightly-binary-and-octal-numbers/">Jeff Walden: Binary and octal numbers</a></li>
 <li><a href="http://mathiasbynens.be/notes/javascript-escapes">Mathias Bynens: JavaScript character escape sequences</a></li>
 <li>{{jsxref("Boolean")}}</li>
 <li>{{jsxref("Number")}}</li>
 <li>{{jsxref("RegExp")}}</li>
 <li>{{jsxref("String")}}</li>
</ul>