.JS File Format – Statements

Overall grammar

Statement:
    BlockStatement          EmptyStatement       ExpressionStatement
    VariableStatement       IfStatement          BreakableStatement
    ContinueStatement       BreakStatement       ReturnStatement
    WithStatement           LabelledStatement    ThrowStatement
    TryStatement            DebuggerStatement

BreakableStatement:
    IterationStatement      SwitchStatement

Declaration:
    HoistableDeclaration    ClassDeclaration     LexicalDeclaration

HoistableDeclaration:
    FunctionDeclaration     GeneratorDeclaration
    AsyncFunctionDeclaration     AsyncGeneratorDeclaration

Function and class declarations are on their own pages: Functions and Classes. Variable declarations are on Variables and scope.

Blocks and simple statements

An expression statement may not start with {, function, class, async function or let [, as these would be ambiguous. To use one as an expression, put it in parentheses.

if

IfStatement:
    if ( Expression ) Statement else Statement
    if ( Expression ) Statement

The test goes through ToBoolean. An else belongs to the nearest if that lacks one. A function declaration cannot be a clause in strict code; in sloppy code, Annex B allows it.

Loops

In a for head, init may be an expression, or a var, let or const declaration. A let is copied for each iteration.

for (const [key, value] of new Map([['a', 1]])) {
  console.log(key, value);
}
for (let of of [1, 2]) { }    // a variable named "of" is allowed

switch

SwitchStatement:
    switch ( Expression ) CaseBlock
CaseBlock:
    { [CaseClauses] }
    { [CaseClauses] DefaultClause [CaseClauses] }
CaseClause:
    case Expression : [StatementList]
DefaultClause:
    default : [StatementList]

switch (value) {
  case 1:
  case 2:
    handleLow();
    break;
  case getSpecial():
    handleSpecial();
    break;
  default:
    handleOther();
}

• Each case expression is compared with ===, evaluated in order. It need not be a constant.
• Control falls through to the next clause unless break or some other jump occurs.
• default runs if no case matches, and may be anywhere in the block.
• The whole case block is one scope, so a let or const under one case is in scope in the others, and may be in its dead zone there. Add braces to give a clause its own scope.

Labels and jumps

LabelledStatement:
    LabelIdentifier : LabelledItem
ContinueStatement:
    continue ;
    continue [no LineTerminator here] LabelIdentifier ;
BreakStatement:
    break ;
    break [no LineTerminator here] LabelIdentifier ;
ReturnStatement:
    return ;
    return [no LineTerminator here] Expression ;

outer:
for (const row of grid) {
  for (const cell of row) {
    if (cell.done) continue outer;
    if (cell.bad) break outer;
  }
}

• break with no label leaves the nearest loop or switch.
• continue with no label starts the next iteration of the nearest loop. A labelled continue must name a loop.
• A labelled break may leave any labelled statement, including a block.
• return is allowed only in function bodies. Its value is undefined if none is given.

throw and try

ThrowStatement:
    throw [no LineTerminator here] Expression ;
TryStatement:
    try Block Catch
    try Block Finally
    try Block Catch Finally
Catch:
    catch ( CatchParameter ) Block
    catch Block
CatchParameter:
    BindingIdentifier
    BindingPattern

try {
  risky();
} catch (error) {                // the binding may be left out (ES2019)
  if (!(error instanceof TypeError)) throw error;
} finally {
  cleanUp();                     // always runs
}

• Any value can be thrown, not just an Error.
• A finally block runs however the try ends. A jump or a throw in finally replaces the original result, so a return there overrides one from try.
• The catch parameter may be a destructuring pattern, and its binding is scoped to the clause.

with

WithStatement:
    with ( Expression ) Statement

with puts an object on the scope chain for its body, so unqualified names look up properties first. It is a syntax error in strict code, and is therefore not allowed in modules or classes. Symbol.unscopables hides names from it.

using declarations

The current draft (expected in ES2027) adds declarations that release a resource when the scope ends. A using declaration is like a const with clean-up attached.

UsingDeclaration:
    using [no LineTerminator here] BindingList ;
AwaitUsingDeclaration:
    await [no LineTerminator here] using [no LineTerminator here] BindingList ;

async function work() {
  using file = openFile();          // file[Symbol.dispose]() on exit
  await using db = await connect(); // await db[Symbol.asyncDispose]() on exit
  return file.read();
}

• The binding must be a simple identifier, not a pattern.
• The value must be an object with the method, or null or undefined, which are skipped.
• await using calls Symbol.asyncDispose and falls back to Symbol.dispose. It needs an async context.
• Not allowed at the top level of a script, nor directly in a case clause. Allowed at a module’s top level.
• A for head can use them: for (using x of list). The spec’s grammar has a lookahead so that for (using of list) keeps its old meaning.
• If a disposer throws while another error is in flight, a SuppressedError holds both.