+
如果二维码过期，请加微信号：liu762022369
diff --git a/translated/issues-8.html b/translated/issues-8.html
index 511872c4a1..2b9aa2db49 100755
--- a/translated/issues-8.html
+++ b/translated/issues-8.html
@@ -1,8 +1,8 @@
-The specification often uses a numbered list to specify steps in an algorithm. These algorithms are used to precisely specify the required semantics of ECMAScript language constructs. The algorithms are not intended to imply the use of any specific implementation technique. In practice, there may be more efficient algorithms available to implement a given feature.
-Algorithms may be explicitly parameterized, in which case the names and usage of the parameters must be provided as part of the algorithm's definition.
-Algorithm steps may be subdivided into sequential substeps. Substeps are indented and may themselves be further divided into indented substeps. Outline numbering conventions are used to identify substeps with the first level of substeps labelled with lower case alphabetic characters and the second level of substeps labelled with lower case roman numerals. If more than three levels are required these rules repeat with the fourth level using numeric labels. For example:
+此规范通常使用带编号的列表来指定算法的步骤。这些算法是用来精确地指定 ECMAScript 语言结构所需的语义。该算法无意暗示任何具体实现使用的技术。在实践中，也许可用更有效的算法实现一个给定功能。
+算法可能被显式参数化，在这种情况下，参数名和用法必须作为算法定义的一部分提供。
+算法步骤可以细分为多个连续的子步骤。子步骤需要用缩进表示，可以进一步被划分成缩进的子步骤。大纲编号约定用作标识子步骤，第一级子步骤使用小写字母字符标记，第二级小步骤用小写罗马数字标记。如果步骤超过三级，那么这些规则从第四级开始从数字重复进行标记。例如：
A step or substep may be written as an “if” predicate that conditions its substeps. In this case, the substeps are only applied if the predicate is true. If a step or substep begins with the word “else”, it is a predicate that is the negation of the preceding “if” predicate step at the same level.
-A step may specify the iterative application of its substeps.
-A step that begins with “Assert:” asserts an invariant condition of its algorithm. Such assertions are used to make explicit algorithmic invariants that would otherwise be implicit. Such assertions add no additional semantic requirements and hence need not be checked by an implementation. They are used simply to clarify algorithms.
-Algorithm steps may declare named aliases for any value using the form “Let _x_ be _someValue_”. These aliases are reference-like in that both _x_ and _someValue_ refer to the same underlying data and modifications to either are visible to both. Algorithm steps that want to avoid this reference-like behaviour should explicitly make a copy of the right-hand side: “Let _x_ be a copy of _someValue_” creates a shallow copy of _someValue_.
-Once declared, an alias may be referenced in any subsequent steps and must not be referenced from steps prior to the alias's declaration. Aliases may be modified using the form “Set _x_ to _someOtherValue_”.
+一个步骤或者子步骤也许会使用 “if” 去断言它的子步骤的条件。在这样的案例中，这些子步骤只能适用于 “if” 断言为真的情况。如果一个步骤或者子步骤以 “else” 开始，那么表示这是之前的 “if” 断言的同一级的否定断言。
+一个步骤也许会指定它的子步骤的迭代程序。
+一个以 “Assert:” 开头的步骤断言一个它的算法里不变的条件。这样的断言被用作使算法不变量显式地展示，否则它将是隐式的。这样的断言不增加额外的语义需求，因此实现不必检查。它们被使用只是为了使算法更清晰。
+对于任意形如 “Let _x_ be _someValue_” 的值，算法步骤也许会声明命名别名。这些别名都是类似类型的，即 x 和 someValue 指向同样的基础数据，对它们的修改是互相可见的。那些想避免这样的类似引用的算法步骤需要显式地复制一份右值：即 “Let_x_ be a copy of _someValue_” 创建了一个 _someValue_ 的浅复制。
+一旦声明完毕，别名可以在任何后续步骤中引用，而不能在别名声明前的步骤中使用。别名也许会通过形如 “Set _x_ to _someOtherValue_” 这样的形式被修改。
In order to facilitate their use in multiple parts of this specification, some algorithms, called abstract operations, are named and written in parameterized functional form so that they may be referenced by name from within other algorithms. Abstract operations are typically referenced using a functional application style such as OperationName(_arg1_, _arg2_). Some abstract operations are treated as polymorphically dispatched methods of class-like specification abstractions. Such method-like abstract operations are typically referenced using a method application style such as _someValue_.OperationName(_arg1_, _arg2_).
+为了便于它们在本规范的多个地方使用，一些算法，我们称之为抽象操作，以参数化函数形式命名和书写，以便它们能够在其它算法中通过名称来引用。抽象操作通常使用函数应用风格被引用，如 OperationName(_arg1_, _arg2_)。一些抽象操作被当作像类规范里抽象的多态发送一样。这样的类似类的方法抽象操作通常通过一个方法应用风格被引用，如 _someValue_.OperationName(_arg1_, _arg2_)。
A syntax-directed operation is a named operation whose definition consists of algorithms, each of which is associated with one or more productions from one of the ECMAScript grammars. A production that has multiple alternative definitions will typically have a distinct algorithm for each alternative. When an algorithm is associated with a grammar production, it may reference the terminal and nonterminal symbols of the production alternative as if they were parameters of the algorithm. When used in this manner, nonterminal symbols refer to the actual alternative definition that is matched when parsing the source text.
-When an algorithm is associated with a production alternative, the alternative is typically shown without any “[ ]” grammar annotations. Such annotations should only affect the syntactic recognition of the alternative and have no effect on the associated semantics for the alternative.
-Syntax-directed operations are invoked with a parse node and, optionally, other parameters by using the conventions on steps 1, 3, and 4 in the following algorithm:
+一个语法导向操作是一个具名操作，它的定义包含了一系列算法，每个算法与一个或者多个 ECMAScript 文法的产生式相关联。一个有多个可选定义的产生式通常对于每个可选部分都有一个独立的算法。当一个算法与一个文法产生式相关联的时候，它也许会引用这个产生式可选部分的终结符或者非终结符，就好像它们是这个算法的参数一样。当出现这种情况时，非终结符指向实际的源代码中与之匹配的可选部分的定义。
+当一个算法与一个产生式的可选部分关联的时候，这个可选部分通常不会带上 “[ ]” 文法注释。这样的注释只应该影响可选部分的语法识别，不应该对相关的可选部分的语义有影响。
+语法导向操作同一个解析节点一起被调用，还可以在以下算法步骤 1，3，4 中使用这个约定的其它参数:
Unless explicitly specified otherwise, all chain productions have an implicit definition for every operation that might be applied to that production's left-hand side nonterminal. The implicit definition simply reapplies the same operation with the same parameters, if any, to the chain production's sole right-hand side nonterminal and then returns the result. For example, assume that some algorithm has a step of the form: “Return the result of evaluating |Block|” and that there is a production:
+除非另有明确说明，否则，所有相关联的产生式对于每个也许会被应用到这个产生式左值的非终结符的操作都有一个隐式的定义。如果存在的话，这个隐式的定义简单地再次对同样的参数运用这个相同的定义，对于这些相关联的产生式唯一的右值非终结符，随后返回处理结果。例如，假设一些算法有如下形式的步骤： “Return the result of evaluating |Block|”，并且这里有一个产生式：
but the Evaluation operation does not associate an algorithm with that production. In that case, the Evaluation operation implicitly includes an association of the form:
-Runtime Semantics: Evaluation
+但是解析操作并没有关联这个产生式的算法。那么在这样的案例中，解析操作隐式地包含了下面形式的关联：
+运行时语义: 解析
Algorithms which specify semantics that must be called at runtime are called runtime semantics. Runtime semantics are defined by abstract operations or syntax-directed operations. Such algorithms always return a completion record.
+必须在运行时被调用的指定语义的算法就叫运行时语义。 运行时语义通过抽象操作或者指定语法操作来定义。这样的算法必须返回一个完成记录。
The algorithms of this specification often implicitly return Completion Records whose [[Type]] is ~normal~. Unless it is otherwise obvious from the context, an algorithm statement that returns a value that is not a Completion Record, such as:
+本规范的算法常常隐式地返回一个 [[Type]] 值为 ~normal~ 的 Completion Records。除非一个返回一个值的算法语句在上下文明显指定返回一个不是 Completion Record 的值。例如：
means the same thing as:
+与下面的是同一个含义：
However, if the value expression of a “return” statement is a Completion Record construction literal, the resulting Completion Record is returned. If the value expression is a call to an abstract operation, the “return” statement simply returns the Completion Record produced by the abstract operation.
-The abstract operation Completion(_completionRecord_) is used to emphasize that a previously computed Completion Record is being returned. The Completion abstract operation takes a single argument, _completionRecord_, and performs the following steps:
+然而，如果一个 “return” 语句的值表达式是一个 Completion Record 构造的字面量，那么 Completion Record 的结果将被返回。如果这个值表达式是一个对抽象操作的调用，那么 “return” 语句简单地返回这个抽象操作产生的 Completion Record。
+抽象操作 Completion(_completionRecord_) 被用作强调之前计算的 Completion Record 被返回。Completion 这个抽象操作接收一个参数，即 _completionRecord_，然后执行下面的步骤：
A “return” statement without a value in an algorithm step means the same thing as:
+一个在算法步骤中没有值的 “return” 语句与下面的是同样的意思：
Any reference to a Completion Record value that is in a context that does not explicitly require a complete Completion Record value is equivalent to an explicit reference to the [[Value]] field of the Completion Record value unless the Completion Record is an abrupt completion.
+对于任意的在一个上下文中没有显示地需要一个完整的 Completion Record 值的引用，等价于一个显式地对 Completion Record 的 [[Value]] 字段的引用，除非 Completion Record 是一个中断完成。
Algorithms steps that say to throw an exception, such as
+描述抛出一个异常的算法步骤，例如：
mean the same things as:
+与下面的是同一个含义：
Algorithms steps that say or are otherwise equivalent to:
+算法步骤说明或者等同于：
mean the same thing as:
+意思就是:
Algorithms steps that say or are otherwise equivalent to:
+算法步骤说明或者等同于：
mean the same thing as:
+与下面的是同一个含义：
Where _hygienicTemp_ is ephemeral and visible only in the steps pertaining to ReturnIfAbrupt.
-Algorithms steps that say or are otherwise equivalent to:
+这里的 _hygienicTemp_ 是临时的，并且只在 ReturnIfAbrupt 有关的步骤中中可见。
+算法步骤说明或者等同于：
mean the same thing as:
+与下面的是同一个含义：
Invocations of abstract operations and syntax-directed operations that are prefixed by `?` indicate that ReturnIfAbrupt should be applied to the resulting Completion Record. For example, the step:
+对抽象操作和以 `?` 为前缀的指定语法操作的调用暗示着 ReturnIfAbrupt 需要被应用到结果的 Completion Record 中。 例如，步骤：
is equivalent to the following step:
+等价于下面的步骤：
Similarly, for method application style, the step:
+相似的，对于程序方法的风格，步骤：
is equivalent to:
+等价于:
Similarly, prefix `!` is used to indicate that the following invocation of an abstract or syntax-directed operation will never return an abrupt completion and that the resulting Completion Record's [[Value]] field should be used in place of the return value of the operation. For example, the step:
+相似的，前缀 `!` 被用作暗示下列的对于抽象或者指定语法操作的调用将不会返回一个打断的完成值， 并且作为结果的 Completion Record 的 [[Value]] 字段应该被用作替换操作的返回值。 例如，步骤：
is equivalent to the following steps:
+等价于下面的步骤：
Syntax-directed operations for runtime semantics make use of this shorthand by placing `!` or `?` before the invocation of the operation:
+对于运行时语义的指定语法的操作通过在调用操作前替换 `!` 或者 `?` 来利用这个缩写。
Context-free grammars are not sufficiently powerful to express all the rules that define whether a stream of input elements form a valid ECMAScript |Script| or |Module| that may be evaluated. In some situations additional rules are needed that may be expressed using either ECMAScript algorithm conventions or prose requirements. Such rules are always associated with a production of a grammar and are called the static semantics of the production.
-Static Semantic Rules have names and typically are defined using an algorithm. Named Static Semantic Rules are associated with grammar productions and a production that has multiple alternative definitions will typically have for each alternative a distinct algorithm for each applicable named static semantic rule.
-Unless otherwise specified every grammar production alternative in this specification implicitly has a definition for a static semantic rule named Contains which takes an argument named _symbol_ whose value is a terminal or nonterminal of the grammar that includes the associated production. The default definition of Contains is:
+上下文无关文法不能足够好的去表达所有定义的规则，不管是一个输入元素的流形成的一个合法的将被解析的 ECMAScript |Script| 还是 |Module|。在一些情况中，需要额外的规则通过使用 ECMAScript 算法约定或者散文要求来展示。这样的规则总是与一个文法的产生式相关联，被称作产生式的静态语义。
+静态语义规则拥有名称，并且通常用一个算法来定义。具有名称的静态语义规则与文法产生式相关联，对于每个可采用的具有名称的静态语义规则， 一个包含多个可选部分定义的产生式通常会对每个可选部分定义一个独有的算法。
+除非在本规范中其它指定的文法产生式可选部分隐式地包含一个叫做 Contains 的接收一个值为包含相关产生式的文法的终结符或者非终结符的 _symbol_ 参数静态语义规则的定义。 默认的包含定义为：
The above definition is explicitly over-ridden for specific productions.
-A special kind of static semantic rule is an Early Error Rule. Early error rules define early error conditions (see clause
上面的定义是显式地重写了规范的产生式。
+一个特殊的静态语义规则是早期（提前）错误规则。早期错误规则定了早期错误条件（见
Mathematical operations such as addition, subtraction, negation, multiplication, division, and the mathematical functions defined later in this clause should always be understood as computing exact mathematical results on mathematical real numbers, which unless otherwise noted do not include infinities and do not include a negative zero that is distinguished from positive zero. Algorithms in this standard that model floating-point arithmetic include explicit steps, where necessary, to handle infinities and signed zero and to perform rounding. If a mathematical operation or function is applied to a floating-point number, it should be understood as being applied to the exact mathematical value represented by that floating-point number; such a floating-point number must be finite, and if it is *+0* or *-0* then the corresponding mathematical value is simply 0.
-The mathematical function
The mathematical function
The notation “
The mathematical function
除非其它地方特别注明不包括无限并且不包括负 0（为了与正 0 区分），数学操作，例如加，减，否定（逻辑非），乘，除以及随后在条款中定义的数学函数应总是被当作是对于数学中所有真实数字计算出来的准确的结果。本规范算法中的浮点运算包含显式地的步骤，它们对于处理无穷，有符号的0，以及舍入是必要的。如果一个数学操作或者函数被应用在一个浮点数上，那么它必须被当作应用到用浮点数表示的具体的数学值；这样的浮点数必须是有限的，并且如果它是 *+0* 或者 *-0* 的话，那么相应的数学值就是简简单单的 0。
+数学函数
数学函数
符号 “
数学函数