expression;

expression

An arbitraryexpression to be evaluated. There arecertain expressions that may be ambiguous with other statements and are thus forbidden.

Apart from thededicated statement syntaxes, you can also use almost anyexpression as a statement on its own. The expression statement syntax requires a semicolon at the end, but theautomatic semicolon insertion process may insert one for you if the lack of a semicolon results in invalid syntax.

Because the expression is evaluated and then discarded, the result of the expression is not available. Therefore, the expression must have some side effect for it to be useful. Expression statements are commonly:

• Function calls (console.log("Hello");,[1, 2, 3].forEach((i) => console.log(i));)
• Tagged template literals
• Assignment expressions, including compound assignments
• Increment and decrement operators
• delete
• import()
• yield andyield*

Others may also have side effects if they invokegetters or triggertype coercions.

In order for an expression to be used as a statement, it must not be ambiguous with other statement syntaxes. Therefore, the expression must not start with any of the following tokens:

• function: which would be afunction declaration orfunction* declaration, not afunction expression orfunction* expression
• async function: which would be anasync function declaration orasync function* declaration, not anasync function expression orasync function* expression
• class: which would be aclass declaration, not aclass expression
• let[: which would be alet declaration witharray destructuring, not aproperty accessor on a variable calledlet (let can only be an identifier innon-strict mode)
• {: which would be ablock statement, not anobject literal

Therefore, all of the following are invalid:

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 ':'};

More dangerously, sometimes the code happens to be valid syntax, but is not what you intend.

// 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 };

To avoid these problems, you can use parentheses, so that the statement is unambiguously an expression statement.

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

You can avoid almost all use of control flow statements using expression statements. For example,if...else can be replaced withternary operators andlogical operators. Iterative statements likefor orfor...of can be replaced witharray methods.

// Using control flow statementsfunction 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 statementsfunction range2(start, end) {  start > end && ([start, end] = [end, start]);  return Array.from({ length: end - start }, (_, i) => start + i);}

• Statements and declarations
• Expressions and operators