Expression statement

expression;

expression

Ein beliebiger Ausdruck, der ausgewertet werden soll. Es gibt bestimmte Ausdrücke, die mit anderen Statements mehrdeutig sein können und daher verboten sind.

Abgesehen von den dedizierten Statement-Syntaxen können Sie auch fast jeden Ausdruck eigenständig als Statement verwenden. Die Syntax für ein Expression Statement erfordert ein Semikolon am Ende, aber der Prozess der automatischen Semikolon-Einfügung kann eines für Sie einfügen, wenn das Fehlen eines Semikolons zu ungültiger Syntax führt.

Da der Ausdruck ausgewertet und dann verworfen wird, ist das Ergebnis des Ausdrucks nicht verfügbar. Daher muss der Ausdruck einen Nebeneffekt haben, um nützlich zu sein. Expression Statements sind häufig:

• Funktionsaufrufe (console.log("Hallo");, [1, 2, 3].forEach((i) => console.log(i));)
• Getaggte Template-Literale
• Zuweisungsausdrücke, einschließlich zusammengesetzter Zuweisungen
• Inkrement- und Dekrementoperatoren
• delete
• import()
• yield und yield*

Andere können ebenfalls Nebeneffekte haben, wenn sie Getter aufrufen oder Typenkonvertierungen auslösen.

Damit ein Ausdruck als Statement verwendet werden kann, darf er nicht mit anderen Statement-Syntaxen mehrdeutig sein. Daher darf der Ausdruck nicht mit einem der folgenden Tokens beginnen:

• function: dies wäre eine function Deklaration oder function* Deklaration, kein function Ausdruck oder function* Ausdruck
• async function: dies wäre eine async function Deklaration oder async function* Deklaration, kein async function Ausdruck oder async function* Ausdruck
• class: dies wäre eine class Deklaration, kein class Ausdruck
• let[: dies wäre eine let Deklaration mit Array-Dekonstruktion, kein Eigenschaftsaccessor auf einer Variablen mit dem Namen let (let kann nur in nicht-striktem Modus ein Bezeichner sein)
• {: dies wäre ein Block-Statement, kein Objektliteral

Daher sind alle folgenden ungültig:

function foo() {
  console.log("foo");
}(); // SyntaxError: Unexpected token '('

// For some reason, you have a variable called `let`
var let = [1, 2, 3];
let[0] = 4; // SyntaxError: Invalid destructuring assignment target

{
  foo: 1,
  bar: 2, // SyntaxError: Unexpected token ':'
};

Gefährlicher ist es, wenn der Code manchmal gültige Syntax ist, aber nicht das, was Sie beabsichtigen.

// For some reason, you have a variable called `let`
var let = [1, 2, 3];

function setIndex(index, value) {
  if (index >= 0) {
    // Intend to assign to the array `let`, but instead creates an extra variable!
    let[index] = value;
  }
}

setIndex(0, [1, 2]);
console.log(let); // [1, 2, 3]

// This is not an object literal, but a block statement,
// where `foo` is a label and `1` is an expression statement.
// This often happens in the console
{ foo: 1 };

Um diese Probleme zu vermeiden, können Sie Klammern verwenden, sodass das Statement eindeutig ein Expression Statement ist.

(function foo() {
  console.log("foo");
})();

Sie können fast den gesamten Einsatz von Kontrollflussanweisungen durch Expression Statements vermeiden. Zum Beispiel kann if...else durch ternäre Operatoren und logische Operatoren ersetzt werden. Iterative Anweisungen wie for oder for...of können durch Array-Methoden ersetzt werden.

// Using control flow statements
function range(start, end) {
  if (start > end) {
    [start, end] = [end, start];
  }
  const result = [];
  for (let i = start; i < end; i++) {
    result.push(i);
  }
  return result;
}

// Using expression statements
function range2(start, end) {
  start > end && ([start, end] = [end, start]);
  return Array.from({ length: end - start }, (_, i) => start + i);
}

• Anweisungen und Deklarationen
• Ausdrücke und Operatoren