语法：

  ''<b id="Statement">Statement</b>'' :
    ''{{toanchor|Block}}''
    ''{{toanchor|VariableStatement}}''
    ''{{toanchor|EmptyStatement}}''
    ''{{toanchor|ExpressionStatement}}''
    ''{{toanchor|IfStatement}}''
    ''{{toanchor|IterationStatement}}''
    ''{{toanchor|ContinueStatement}}''
    ''{{toanchor|BreakStatement}}''
    ''{{toanchor|ReturnStatement}}''
    ''{{toanchor|WithStatement}}''
    ''{{toanchor|LabelledStatement}}''
    ''{{toanchor|SwitchStatement}}''
    ''{{toanchor|ThrowStatement}}''
    ''{{toanchor|TryStatement}}''
    ''{{toanchor|DebuggerStatement}}''

语义：

一个 ' 可以是 ' 的一部分，这个 ' 自身也可以是 ' 的一部分，以此类推。当描述个别语句时引入标签的这种方式统称为 “当前标签组”。一个 ' 介绍了一个标签到一个 标签组，此外没有其他语义。一个 ' 或 ' 的标签组最初包含单个 empty 元素。任何其他语句的标签组最初是空的。

{{anchor|x12.1}}块 {{v8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L1705|}}
{{anchor|x12.2}}变量语句 {{v8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L1764|}}
- {{anchor|x12.2.1}}严格模式的限制
{{anchor|x12.3}}空语句 {{v8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L1381|}}
{{anchor|x12.4}}表达式语句 {{v8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L2126|}}
{{anchor|x12.5}}if 语句 {{v8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L2195|}}
{{anchor|x12.6}}迭代语句
{{anchor|x12.7}}continue 语句 {{v8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L2217|}}
{{anchor|x12.8}}break 语句 {{v8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L2248}}
{{anchor|x12.9}}return 语句 {{v8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L2285|}}
{{anchor|x12.10}}{{anchor|with-statement}}with 语句 {{v8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L2334|}}
- {{anchor|x12.10.1}}严格模式的限制
{{anchor|x12.11}}switch 语句 {{v8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L2397|}}
{{anchor|x12.12}}标签语句 {{v8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L2126|}}
{{anchor|x12.13}}throw 语句 {{v8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L2425|}}
{{anchor|x12.14}}try 语句 {{v8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L2444|}}
- {{anchor|x12.14.1}}严格模式的限制 {{v8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L2490|}}
{{anchor|x12.15}}debugger 语句 {{v8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L3467|}}

块

语法：

  ''<b id="Block">Block</b>'' :
    '''{''' ''{{toanchor|StatementList}}''<sub>opt</sub> '''}'''

  ''<b id="StatementList">StatementList</b>'' :
    ''{{toanchor|Statement}}''
    ''{{toanchor|StatementList}}'' ''{{toanchor|Statement}}''

语义：

产生式 ' : { } 按照下面的过程执行 :

返回 (normal, empty, empty)。

产生式 ' : { ' } 按照下面的过程执行 :

返回解释执行 ' 的结果。

产生式 ' : ' 按照下面的过程执行 :

令 <var>s</var> 为解释执行 ' 的结果。
如果有一个异常被抛出，返回 (throw, <var>V</var>, empty)，这里的 <var>V</var> 是异常。( 仿佛没有抛出异常一样继续运行。)
返回 <var>s</var>。

产生式 ' : 按照下面的过程执行 :

令 <var>sl</var> 为解释执行 ' 的结果。
如果 <var>sl</var> 是个非常规完结，返回 <var>sl</var>。
令 <var>s</var> 为解释执行 ' 的结果。
如果有一个异常被抛出，返回 (throw, <var>V</var>, empty)，这里的 <var>V</var> 是异常。 ( 仿佛没有抛出异常一样继续运行。)
如果 <var>s</var>.value 是 empty ，令 <var>V</var> = <var>sl</var>.value, 否则令 <var>V</var> = <var>s</var>.value。
返回 (<var>s</var>.type, <var>V</var>, <var>s</var>.target)。

变量语句

语法：

    ''<b id="VariableStatement">VariableStatement</b>'' :
        '''var''' ''{{toanchor|VariableDeclarationList}}'' ''';'''

    ''<b id="VariableDeclarationList">VariableDeclarationList</b>'' :
        ''{{toanchor|VariableDeclaration}}''
        ''{{toanchor|VariableDeclarationList}}'' ''',''' ''{{toanchor|VariableDeclaration}}''

    ''<b id="VariableDeclarationListNoIn">VariableDeclarationListNoIn</b>'' :
        ''{{toanchor|VariableDeclarationNoIn}}''
        ''{{toanchor|VariableDeclarationListNoIn}}'' ''',''' ''{{toanchor|VariableDeclarationNoIn}}''

    ''<b id="VariableDeclaration">VariableDeclaration</b>'' :
        ''[[ES5/lexical#Identifier|Identifier]]'' ''{{toanchor|Initialiser}}''{{opt}}

    ''<b id="VariableDeclarationNoIn">VariableDeclarationNoIn</b>'' :
        ''[[ES5/lexical#Identifier|Identifier]]'' ''{{toanchor|InitialiserNoIn}}''{{opt}}

    ''<b id="Initialiser">Initialiser</b>'' :
        '''=''' ''[[ES5/expressions#AssignmentExpression|AssignmentExpression]]''

    ''<b id="InitialiserNoIn">InitialiserNoIn</b>'' :
        '''=''' ''[[ES5/expressions#AssignmentExpressionNoIn|AssignmentExpressionNoIn]]''

一个变量语句声明依 10.5 中定义创建的变量。当创建变量时初始化为 undefined。当 ' 被执行时变量关联的 ' 会被分配 AssignmentExpression 的值，而不是在变量创建时。

语义：

产生式 ' : var ' ; 按照下面的过程执行 :

解释执行 '。
返回 (normal, empty, empty)。

产生式 ' : ' 按照下面的过程执行 :

解释执行 '。

产生式 ' : ' , ' 按照下面的过程执行 :

解释执行 '。
解释执行 '。

产生式 ' : Identifier 按照下面的过程执行 :

返回一个包含跟 Identifier 完全相同的字符序列的字符串值。

产生式 ' : Identifier ' 按照下面的过程执行 :

令 <var>lhs</var> 为解释执行 Identifier 的结果，如 11.1.2 所述。
令 <var>rhs</var> 为解释执行 ' 的结果。
令 <var>value</var> 为 GetValue(<var>rhs</var>)。
调用 PutValue(<var>lhs</var>, <var>value</var>)。
返回一个包含跟 Identifier 完全相同的字符序列的字符串值。

如果 ' 嵌套在 with 语句里并且 ' 里的标识符与 with 语句的对象式环境记录项关联的绑定对象的一个属性名相同，则第 4 步将给这个属性分配值，而不是为 Identifier 的 VariableEnvironment 绑定分配值。

产生式 ' : = AssignmentExpression 按照下面的过程执行 :

返回解释执行 AssignmentExpression 的结果。

产生式 ', ', ' 解释执行的方式与产生式 ', '，' 相同，除了他们包含的 ', ', ', AssignmentExpressionNoIn 会分别替代 ', ', ', AssignmentExpression 来解释执行。

严格模式的限制

如果一个 ' 或 ' 出现在严格模式代码里并且其 Identifier 是 "eval" 或 "arguments"，那么这是个 SyntaxError。

空语句

语法 :

  ''<b id="EmptyStatement">EmptyStatement</b>'' :
    ''';'''

语义：

产生式 ' : ; 按照下面的过程执行 :

返回 (normal, empty, empty)。

表达式语句

语法：

  ''<b id="ExpressionStatement">ExpressionStatement</b>'' :
    &#x5b;[[ES5/notation#lookahead-not-in|lookahead ?]] {'''{''', '''function'''}] ''[[ES5/expressions#Expression|Expression]]'' ''';'''

语义：

产生式 ' : [lookahead ? {{, function}] Expression ; 按照下面的过程执行 :

令 <var>exprRef</var> 为解释执行 Expression 的结果。
返回 (<var>normal</var>, GetValue(<var>exprRef</var>), empty)。

if 语句

语法：

  ''<b id="IfStatement">IfStatement</b>'' :
    '''if (''' ''[[ES5/expressions#Expression|Expression]]'' ''')''' ''{{toanchor|Statement}}'' '''else''' ''{{toanchor|Statement}}''
    '''if (''' ''[[ES5/expressions#Expression|Expression]]'' ''')''' ''{{toanchor|Statement}}''

每个 else 选择与它相关联的 if 是不确定的，应与此 else 最近的并且原本没有与其对应的 else 的可能的 if 对应。

语义：

产生式 ' : if ( Expression ) ' else ' 按照下面的过程执行 :

令 <var>exprRef</var> 为解释执行 Expression 的结果 .
如果 ToBoolean(GetValue(<var>exprRef</var>)) 为 true ，则
1. 返回解释执行第一个 ' 的结果。
否则,
1. 返回解释执行第二个 ' 的结果。

产生式 ' : if ( Expression ) ' 按照下面的过程执行 :

令 <var>exprRef</var> 为解释执行 Expression 的结果。
如果 ToBoolean(GetValue (<var>exprRef</var>)) 为 false 则返回 (normal, empty, empty).
返回解释执行 ' 的结果。

迭代语句

语法：

  ''<b id="IterationStatement">IterationStatement</b>'' :
    '''do''' ''{{toanchor|Statement}}'' '''while (''' ''[[ES5/expressions#Expression|Expression]]'' ''') ;''' 
    '''while (''' ''[[ES5/expressions#Expression|Expression]]'' ''')''' ''{{toanchor|Statement}}''
    '''for (''' ''[[ES5/expressions#ExpressionNoIn|ExpressionNoIn]]''{{opt}} ''';''' ''[[ES5/expressions#Expression|Expression]]''{{opt}} ''';''' ''[[ES5/expressions#Expression|Expression]]''{{opt}} ''')''' ''{{toanchor|Statement}}''
    '''for ( var''' ''{{toanchor|VariableDeclarationListNoIn}}'' ''';''' ''[[ES5/expressions#Expression|Expression]]''{{opt}} ''';''' ''[[ES5/expressions#Expression|Expression]]''{{opt}} ''')''' ''{{toanchor|Statement}}''
    '''for (''' ''[[ES5/expressions#LeftHandSideExpression|LeftHandSideExpression]]'' '''in''' ''[[ES5/expressions#Expression|Expression]]'' ''')''' ''{{toanchor|Statement}}''
    '''for ( var''' ''{{toanchor|VariableDeclarationNoIn}}'' '''in''' ''[[ES5/expressions#Expression|Expression]]'' ''')''' ''{{toanchor|Statement}}''

do-while 语句

产生式 do ' while ( Expression ) ; 按照下面的过程执行 :

令 <var>V</var> = empty。
令 <var>iterating</var> 为 true。
只要 <var>iterating</var> 为 true，就重复
1. 令 <var>stmt</var> 为解释执行 ' 的结果。
2. 如果 <var>stmt</var>.value 不是 empty，令 <var>V</var> = <var>stmt</var>.value。
3. 如果 <var>stmt</var>.type 不是 continue || <var>stmt</var>.target 不在当前标签组，则
  1. 如果 <var>stmt</var>.type 是 break 并且 <var>stmt</var>.target 在当前标签组内，返回 (normal, <var>V</var>, empty)。
  2. 如果 <var>stmt</var> 是个非常规完结，返回 <var>stmt</var>。
4. 令 <var>exprRef</var> 为解释执行 Expression 的结果。
5. 如果 ToBoolean(GetValue(<var>exprRef</var>)) 是 false，设定 <var>iterating</var> 为 false。
返回 (normal, <var>V</var>, empty)。

while 语句

产生式 ' : while ( Expression ) ' 按照下面的过程执行 :

令 <var>V</var> = empty。
重复
1. 令 <var>exprRef</var> 为解释执行 Expression 的结果。
2. 如果 ToBoolean(GetValue(<var>exprRef</var>)) 是 false，返回 (normal, <var>V</var>, empty)。
3. 令 <var>stmt</var> 为解释执行 ' 的结果。
4. 如果 <var>stmt</var>.value 不是 empty，令 <var>V</var> = <var>stmt</var>.value。
5. 如果 <var>stmt</var>.type 不是 continue || <var>stmt</var>.target 不在当前标签组内，则
  1. 如果 <var>stmt</var>.type 是 break 并且 <var>stmt</var>.target 在当前标签组内，则
    1. 返回 (normal, <var>V</var>, empty)。
  2. 如果 <var>stmt</var> 是一个非常规完结，返回 <var>stmt</var>。

for 语句

产生式 ' : for ( ExpressionNoIn_opt ; Expression_opt ; Expression_opt ) ' 按照下面的过程执行 :

如果 ExpressionNoIn 存在，则
1. 令 <var>exprRef</var> 为解释执行 ExpressionNoIn 的结果。
2. 调用 GetValue(<var>exprRef</var>)。（不会用到此值。)
令 <var>V</var> = empty。
重复
1. 如果第一个 Expression 存在，则
  1. 令 <var>testExprRef</var> 为解释执行第一个 Expression 的结果。
  2. 如果 ToBoolean(GetValue(<var>testExprRef</var>)) 是 false，返回 (normal, <var>V</var>, empty)。
2. 令 <var>stmt</var> 为解释执行 ' 的结果。
3. 如果 <var>stmt</var>.value 不是 empty，令 <var>V</var> = <var>stmt</var>.value。
4. 如果 <var>stmt</var>.type 是 break 并且 <var>stmt</var>.target 在当前标签组内，返回 (normal, <var>V</var>, empty)。
5. 如果 <var>stmt</var>.type 不是 continue || <var>stmt</var>.target 不在当前标签组内，则
  1. 如果 <var>stmt</var> 是个非常规完结，返回 <var>stmt</var>。
6. 如果第二个 Expression 存在，则
  1. 令 <var>incExprRef</var> 为解释执行第二个 Expression 的结果。
  2. 调用 GetValue(<var>incExprRef</var>)。（不会用到此值。）

产生式 ' : for ( var ' ; Expression_opt ; Expression_opt ) ' 按照下面的过程执行 :

解释执行 '。
令 <var>V</var> = empty。
重复
1. 如果第一个 Expression 存在，则
  1. 令 <var>testExprRef</var> 为解释执行第一个 Expression 的结果 .
  2. 如果 ToBoolean(GetValue(<var>testExprRef</var>)) 是 false，则返回 (normal, <var>V</var>, empty)。
2. 令 <var>stmt</var> 为解释执行 ' 的结果。
3. 如果 <var>stmt</var>.value 不是 empty，令 <var>V</var> = <var>stmt</var>.value。
4. 如果 <var>stmt</var>.type 是 break 并且 <var>stmt</var>.target 在当前标签组内，返回 (normal, <var>V</var>, empty)。
5. 如果 <var>stmt</var>.type 不是 continue || <var>stmt</var>.target 不在当前标签组内，则
  1. 如果 <var>stmt</var> 是个非常规完结，返回 <var>stmt</var>。
6. 如果第二个 Expression 存在，则
  1. 令 <var>incExprRef</var> 为解释执行第二个 Expression 的结果。
  2. 调用 GetValue(<var>incExprRef</var>)。（不会用到此值。）

for-in 语句

产生式 ' : for ( LeftHandSideExpression in Expression ) ' 按照下面的过程执行 :

令 <var>exprRef</var> 为解释执行 Expression 的结果。
令 <var>experValue</var> 为 GetValue(<var>exprRef</var>)。
如果 <var>experValue</var> 是 null 或 undefined，返回 (normal, empty, empty)。
令 <var>obj</var> 为 ToObject(<var>experValue</var>)。
令 <var>V</var> = empty。
重复
1. 令 <var>P</var> 为 <var>obj</var> 的下一个 [[Enumerable]] 特性为 true 的属性的名。如果不存在这样的属性，返回 (normal, <var>V</var>, empty)。
2. 令 <var>lhsRef</var> 为解释执行 LeftHandSideExpression 的结果（它可能解释执行多次）。
3. 调用 PutValue(<var>lhsRef</var>, <var>P</var>)。
4. 令 <var>stmt</var> 为解释执行 ' 的结果。
5. 如果 <var>stmt</var>.value 不是 empty，令 <var>V</var> = <var>stmt</var>.value。
6. 如果 <var>stmt</var>.type 是 break 并且 <var>stmt</var>.target 在当前标签组内，返回 (normal, <var>V</var>, empty)。
7. 如果 <var>stmt</var>.type 不是 continue || <var>stmt</var>.target 不在当前标签组内，则
  1. 如果 <var>stmt</var> 是非常规完结，返回 <var>stmt</var>。

产生式 ' : for ( var ' in Expression ) ' 按照下面的过程执行 :

令 <var>varName</var> 为解释执行 ' 的结果。
令 <var>exprRef</var> 为解释执行 Expression 的结果。
令 <var>experValue</var> 为 GetValue(<var>exprRef</var>)。
如果 <var>experValue</var> 是 null 或 undefined，返回 (normal, empty, empty)。
令 <var>obj</var> 为 ToObject(<var>experValue</var>)。
令 <var>V</var> = empty。
重复
1. 令 <var>P</var> 为 <var>obj</var> 的下一个 [[Enumerable]] 特性为 true 的属性的名。如果不存在这样的属性，返回 (normal, <var>V</var>, empty)。
2. 令 <var>varRef</var> 为解释执行 <var>varName</var> 的结果，仿佛它是个标示符引用（11.1.2）。它可能解释执行多次。
3. 调用 PutValue(<var>varRef</var>, <var>P</var>)。
4. 令 <var>stmt</var> 为解释执行 ' 的结果。
5. 如果 <var>stmt</var>.value 不是 empty，令 <var>V</var> = <var>stmt</var>.value。
6. 如果 <var>stmt</var>.type 是 break 并且 <var>stmt</var>.target 在当前标签组内，返回 (normal, <var>V</var>, empty)。
7. 如果 <var>stmt</var>.type 不是 continue || <var>stmt</var>.target 不在当前标签组内，则
  1. 如果 <var>stmt</var> 是非常规完结，返回 <var>stmt</var>。

枚举的属性（第一个算法中的 第6.1步、第二个算法中的 第7.1步）的机制和顺序并没有指定。在枚举过程中枚举的对象属性可能被删除。如果在枚举过程中，删除了还没有被访问到的属性，那么它将不会被访问到。如果在枚举过程中添加新属性到列举的对象，新增加的属性也无法保证被当前执行中的枚举访问到。在任何枚举中对同一个属性名称的访问不得超过一次。

从对象中枚举属性时也包括对象的原型链。但如果一个原型中的属性是“被遮住的”（原型链中靠前的对象有同样的属性名）就不会枚举。当一个原型对象的属性被原型链中靠前的对象属性遮住时就不考虑它的[[Enumerable]]特性。

continue 语句

语法：

  ''<b id="ContinueStatement">ContinueStatement</b>'' :
    '''continue ;'''
    '''continue''' [[ES5/notation#restricted-production|[no ''LineTerminator'' here]]] ''[[ES5/lexical#Identifier|Identifier]]'' ''';'''

语义：

如果以下任意一个为真，那么程序被认为是语法错误的：

程序包含一个不带可选的 Identifier 的 continue 语句，没有直接或间接（不跨越函数边界）的嵌套在 ' 里。
程序包含一个有可选的 Identifier 的 continue 语句，这个 Identifier 没有出现在 ' 中闭合标签组里（不跨越函数边界）。

一个没有 Identifier 的 ' 按照下面的过程执行 :

返回 (continue, empty, empty)。

一个有可选的 Identifier 的 ' 按照下面的过程执行 :

返回 (continue, empty, Identifier)。

break 语句

语法：

  ''<b id="BreakStatement">BreakStatement</b>'' :
    '''break ;'''
    '''break''' [[ES5/notation#restricted-production|[no ''LineTerminator'' here]]] ''[[ES5/lexical#Identifier|Identifier]]'' ''';'''

语义：

如果以下任意一个为真，那么程序被认为是语法错误的：

程序包含一个不带可选的 Identifier 的 break 语句，没有直接或间接（不跨越函数边界）的嵌套在 ' 或 ' 里。
程序包含一个有可选的 Identifier 的 break 语句，这个 Identifier 没有出现在 ' 中闭合标签组里（不跨越函数边界）。

一个没有 Identifier 的 ' 按照下面的过程执行 :

返回 (break, empty, empty)。

一个有可选的 Identifier 的 ' 按照下面的过程执行 :

返回 (break, empty, Identifier)。

return 语句

语法：

  ''<b id="ReturnStatement">ReturnStatement</b>'' :
    '''return ;'''
    '''return''' [[ES5/notation#restricted-production|[no ''LineTerminator'' here]]] ''[[ES5/expressions#Expression|Expression]]'' ''';'''

语义：

在一个 ECMAScript 程序中包含的 return 语句没有在 FunctionBody 里面，那么就是语法错误的。一个 return 语句导致函数停止执行，并返回一个值给调用者。如果省略 Expression，返回值是 undefined。否则，返回值是 Expression 的值。

产生式 ' : return [no] Expression_opt ; 按照下面的过程执行 :

如果 Expression 不存在，返回 (return, undefined, empty)。
令 <var>exprRef</var> 为解释执行 Expression 的结果。
返回 (return, GetValue(<var>exprRef</var>), empty)。

with 语句

语法：

  ''<b id="WithStatement">WithStatement</b>'' :
    '''with (''' ''[[ES5/expressions#Expression|Expression]]'' ''')''' ''{{toanchor|Statement}}''

with 语句为计算对象给当前执行上下文的词法环境添加一个对象环境记录项。然后，用这个增强的词法环境执行一个语句。最后，恢复到原来的词法环境。

语义 :

产生式 ' : with ( Expression ) ' 按照下面的过程执行 :

令 <var>val</var> 为解释执行 Expression 的结果。
令 <var>obj</var> 为 ToObject(GetValue(<var>val</var>))。
令 <var>oldEnv</var> 为运行中的执行上下文的词法环境组件。
令 <var>newEnv</var> 为以 <var>obj</var> 和 <var>oldEnv</var> 为参数调用 NewObjectEnvironment 的结果。
设定 <var>newEnv</var> 的 <var>provideThis</var> 标志为 true。
设定运行中的执行上下文的词法环境组件为 <var>newEnv</var>。
令 <var>C</var> 为解释执行 ' 的结果，但如果解释执行是由异常抛出，则令 <var>C</var> 为 (throw, <var>V</var>, empty)，这里的 <var>V</var> 是异常。（现在继续执行，仿佛没有抛出异常。)
设定运行中的执行上下文的词法环境组件为 <var>oldEnv</var>。
返回 <var>C</var>。

严格模式的限制

严格模式代码中不能包含 '。出现 ' 的上下文被当作一个 SyntaxError。

switch 语句

语法：

  ''<b id="SwitchStatement">SwitchStatement</b>'' :
    '''switch (''' ''[[ES5/expressions#Expression|Expression]]'' ''')''' ''{{toanchor|CaseBlock}}''

  ''<b id="CaseBlock">CaseBlock</b>'' :
    '''{''' ''{{toanchor|CaseClauses}}''{{opt}} '''}''' 
    '''{''' ''{{toanchor|CaseClauses}}''{{opt}} ''{{toanchor|DefaultClause}}'' ''{{toanchor|CaseClauses}}''{{opt}} '''}'''

  ''<b id="CaseClauses">CaseClauses</b>'' :
    ''{{toanchor|CaseClause}}''
    ''{{toanchor|CaseClauses}}'' ''{{toanchor|CaseClause}}''

  ''<b id="CaseClause">CaseClause</b>'' :
    '''case''' ''[[ES5/expressions#Expression|Expression]]'' ''':''' ''{{toanchor|StatementList}}''{{opt}}

  ''<b id="DefaultClause">DefaultClause</b>'' :
    '''default :''' ''{{toanchor|StatementList}}''{{opt}}

语义：

产生式 ' : switch ( Expression ) ' 按照下面的过程执行 :

令 <var>exprRef</var> 为解释执行 Expression 的结果。
令 <var>R</var> 为以 GetValue(<var>exprRef</var>) 作为参数解释执行 ' 的结果。
如果 <var>R</var>.type 是 break 并且 <var>R</var>.target 在当前标签组内，返回 (normal, <var>R</var>.value, empty)。
返回 <var>R</var>。

产生式 ' : { '_opt } 以一个给定输入参数 <var>input</var>, 按照下面的过程执行 :

令 <var>V</var> = empty。
令 <var>A</var> 为以源代码中顺序排列的 ' 列表。
令 <var>searching</var> 为 true。
只要 <var>searching</var> 为 true，就重复
1. 令 <var>C</var> 为 <var>A</var> 里的下一个 '。如果没有 ' 了，返回 (normal, <var>V</var>, empty)。
2. 令 <var>clauseSelector</var> 为解释执行 <var>C</var> 的结果。
3. 如果 <var>input</var> 和 <var>clauseSelector</var> 是 === 操作符定义的相等，则
  1. 设定 <var>searching</var> 为 false。
  2. 如果 <var>C</var> 有一个 ', 则
    1. 令 <var>R</var> 为解释执行 <var>C</var> 的 ' 的结果。
    2. 如果 <var>R</var> 是个非常规完结，则返回 <var>R</var>。
    3. 令 <var>V</var> = <var>R</var>.value
重复
1. 令 <var>C</var> 为 <var>A</var> 里的下一个 '。如果没有 ' 了，返回 (normal, <var>V</var>, empty)。
2. 如果 <var>C</var> 有一个 '，则
  1. 令 <var>R</var> 为解释执行 <var>C</var> 的 ' 的结果。
  2. 如果 <var>R</var>.value 不是 empty，则令 <var>V</var> = <var>R</var>.value。
  3. 如果 <var>R</var> 是个非常规完结，则返回 (<var>R</var>.type, <var>V</var>, <var>R</var>.target)。

产生式 ' : { '_opt ' '_opt } 以一个给定输入参数 <var>input</var>，按照下面的过程执行 :

令 <var>V</var> = empty。
令 <var>A</var> 为第一个 ' 中以源代码中顺序排列的 ' 列表。
令 <var>B</var> 为第二个 ' 中以源代码中顺序排列的 ' 列表。
令 <var>found</var> 为 false。
重复，使 <var>C</var> 为 <var>A</var> 中的依次每个 '。
1. 如果 <var>found</var> 是 false，则
  1. 令 <var>clauseSelector</var> 为解释执行 <var>C</var> 的结果 .
  2. 如果 <var>input</var> 和 <var>clauseSelector</var> 是 === 操作符定义的相等，则设定 <var>found</var> 为 true。
2. 如果 <var>found</var> 是 true，则
  1. 如果 <var>C</var> 有一个 '，则
    1. 令 <var>R</var> 为解释执行 <var>C</var> 的 ' 的结果。
    2. 如果 <var>R</var>.value 不是 empty，则令 <var>V</var> = <var>R</var>.value。
    3. <var>R</var> 是个非常规完结，则返回 (<var>R</var>.type, <var>V</var>, <var>R</var>.target)。
令 <var>foundInB</var> 为 false。
如果 <var>found</var> 是 false，则
1. 只要 <var>foundInB</var> 为 false 并且所有 <var>B</var> 中的元素都没有被处理，就重复
  1. 令 <var>C</var> 为 <var>B</var> 里的下一个 '。
  2. 令 <var>clauseSelector</var> 为解释执行 <var>C</var> 的结果。
  3. 如果 <var>input</var> 和 <var>clauseSelector</var> 是 === 操作符定义的相等，则
    1. 设定 <var>foundInB</var> 为 true。
    2. 如果 <var>C</var> 有一个 '，则
      1. 令 <var>R</var> 为解释执行 <var>C</var> 的 ' 的结果。
      2. 如果 <var>R</var>.value 不是 empty，则令 <var>V</var> = <var>R</var>.value。
      3. <var>R</var> 是个非常规完结，则返回 (<var>R</var>.type, <var>V</var>, <var>R</var>.target)。
如果 <var>foundInB</var> 是 false 并且 ' 有个 '，则
1. 令 <var>R</var> 为解释执行 ' 的 ' 的结果。
2. 如果 <var>R</var>.value 不是 empty，则令 <var>V</var> = <var>R</var>.value。
3. 如果 <var>R</var> 是个非常规完结，则返回 (<var>R</var>.type, <var>V</var>, <var>R</var>.target)。
重复（注 : 如果已执行步骤 7.a.i, 此循环不从 B 的开头开始。）
1. 令 <var>C</var> 为 <var>B</var> 的下一个 '。如果没有 ' 了，返回 (normal, <var>V</var>, empty)。
2. 如果 <var>C</var> 有个 '，则
  1. 令 <var>R</var> 为解释执行 <var>C</var> 的 ' 的结果。
  2. 如果 <var>R</var>.value 不是 empty，则令 <var>V</var> = <var>R</var>.value。
  3. 如果 <var>R</var> 是个非常规完结，则返回 (<var>R</var>.type, <var>V</var>, <var>R</var>.target)。

产生式 ' : case Expression : '_opt 按照下面的过程执行 :

令 <var>exprRef</var> 为解释执行 Expression 的结果。
返回 GetValue(<var>exprRef</var>)。

标签语句

语法：

  ''<b id="LabelledStatement">LabelledStatement</b>'' :
    ''[[ES5/lexical#Identifier|Identifier]]'' ''':''' ''{{toanchor|Statement}}''

语义：

一个 ' 可以由一个标签作为前缀。标签语句仅与标签化的 break 和 continue 语句一起使用。ECMAScript 没有 goto 语句。

如果一个 ECMAScript 程序包含有相同 Identifier 作为标签的 ' 闭合的 '，那么认为它是是语法错误的。这不适用于直接或间接嵌套在标签语句里面的 FunctionDeclaration 的函数体里出现标签的情况。

产生式 Identifier : ' 的解释执行方式是，先添加 Identifier 到 ' 的标签组，再解释执行 '。如果 ' 自身有一个非空标签组，这些标签还是会添加到解释执行前的 ' 的标签组里。如果 ' 的解释执行结果是 (break, <var>V</var>, <var>L</var>)，这里的 <var>L</var> 等于 Identifier，则产生式的结果是 (normal, <var>V</var>, empty)。

在解释执行 ' 之前，认为包含的 ' 拥有一个空标签组，除非它是 ' 或 '，这种情况下认为它拥有一个包含单个元素 empty 的标签组。

throw 语句

语法：

  ''<b id="ThrowStatement">ThrowStatement</b>'' :
    '''throw''' [[ES5/notation#restricted-production|[no ''LineTerminator'' here]]] ''[[ES5/expressions#Expression|Expression]]'' ''';'''

语义：

产生式 ' : throw [no] Expression ; 按照下面的过程执行 :

令 <var>exprRef</var> 为解释执行 Expression 的结果。
返回 (throw, GetValue(<var>exprRef</var>), empty)。

try 语句

语法：

  ''<b id="TryStatement">TryStatement</b>'' :
    '''try''' ''{{toanchor|Block}}'' ''{{toanchor|Catch}}''
    '''try''' ''{{toanchor|Block}}'' ''{{toanchor|Finally}}''
    '''try''' ''{{toanchor|Block}}'' ''{{toanchor|Catch}}'' ''{{toanchor|Finally}}''

  ''<b id="Catch">Catch</b>'' :
    '''catch (''' ''[[ES5/lexical#Identifier|Identifier]]'' ''')''' ''{{toanchor|Block}}''

  ''<b id="Finally">Finally</b>'' :
    '''finally''' ''{{toanchor|Block}}''

try 语句包裹一个可以出现特殊状况，如果运行时错误或 throw 语句的代码块。catch 子句提供了异常处理代码。如果 catch 子句捕获到一个异常，这个异常会绑定到它的 Identifier 上。

语义：

产生式 ' : try ' ' 按照下面的过程执行 :

令 <var>B</var> 为解释执行 ' 的结果。
如果 <var>B</var>.type 不是 throw，返回 <var>B</var>。
返回一参数 <var>B</var> 解释执行 ' 的结果。

产生式 ' : try ' ' 按照下面的过程执行 :

令 <var>B</var> 为解释执行 ' 的结果。
令 <var>F</var> 为解释执行 ' 的结果。
如果 <var>F</var>.type 是 normal，返回 <var>B</var>。
返回 <var>F</var>。

产生式 ' : try ' ' ' 按照下面的过程执行 :

令 <var>B</var> 为解释执行 ' 的结果。
如果 <var>B</var>.type 是 throw，则
1. 令 <var>C</var> 为以参数 <var>B</var> 解释执行 ' 的结果。
否则，<var>B</var>.type 不是 throw，
1. 令 <var>C</var> 为 <var>B</var>。
令 <var>F</var> 为解释执行 ' 的结果。
如果 <var>F</var>.type 是 normal，返回 <var>C</var>。
返回 <var>F</var>。

产生式 ' : catch ( Identifier ) ' 按照下面的过程执行 :

令 <var>C</var> 为传给这个产生式的参数。
令 <var>oldEnv</var> 为运行中执行上下文的词法环境组件。
令 <var>catchEnv</var> 为以 <var>oldEnv</var> 为参数调用 NewDeclarativeEnvironment 的结果。
以 Identifier 字符串值为参数调用 <var>catchEnv</var> 的 CreateMutableBinding 具体方法。
以 Identifier、<var>C</var>、<var>false</var> 为参数调用 <var>catchEnv</var> 的 SetMutableBinding 具体方法。注：这种情况下最后一个参数无关紧要。
设定运行中执行上下文的词法环境组件为 <var>catchEnv</var>。
令 <var>B</var> 为解释执行 ' 的结果。
设定运行中执行上下文的词法环境组件为 <var>oldEnv</var>。
返回 <var>B</var>。

产生式 ' : finally ' 按照下面的过程执行 :

返回解释执行 ' 的结果。

严格模式的限制

如果一个有 ' 的 ' 出现在严格模式代码里，并且 ' 产生式的 Identifier 是 "eval" 或 "arguments"，那么这是个 SyntaxError。

debugger 语句

语法：

  ''<b id="DebuggerStatement">DebuggerStatement</b>'' :
    '''debugger ;'''

语义：

解释执行 ' 产生式可允许让一个实现在调试器下运行时设置断点。如果调试器不存在或是非激活状态，这个语句没有可观测效果。

产生式 ' : debugger ; 按照下面的过程执行 :

如果一个实现定义了可用的调试工具并且是开启的，则
1. 执行实现定义的调试动作。
2. 令 <var>result</var> 为实现定义的完结值。
否则
1. 令 <var>result</var> 为 (normal, empty, empty)。
返回 <var>result</var>。

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Statements.wiki

Statements.wiki

Table of Contents

块

变量语句

严格模式的限制

空语句

表达式语句

if 语句

迭代语句

do-while 语句

while 语句

for 语句

for-in 语句

continue 语句

break 语句

return 语句

with 语句

严格模式的限制

switch 语句

标签语句

throw 语句

try 语句

严格模式的限制

debugger 语句

Files

Statements.wiki

Latest commit

History

Statements.wiki

File metadata and controls

Table of Contents

块

变量语句

严格模式的限制

空语句

表达式语句

if 语句

迭代语句

do-while 语句

while 语句

for 语句

for-in 语句

continue 语句

break 语句

return 语句

with 语句

严格模式的限制

switch 语句

标签语句

throw 语句

try 语句

严格模式的限制

debugger 语句