ECMAScript5学习笔记-第11章 表达式

11.表达式

11.1  主值表达式  语法：PrimaryExpression : this；执行为当前执行环境的ThisBinding

　　　　　　　　　　　　　　　　　　　　　　 Identifier ；执行遵循 标识符解析 的标识符查找。标识符执行的结果总是一个 Reference 类型的值。

　　　　　　　　　　　　　　　　　　　　　　 Literal；

　　　　　　　　　　　　　　　　　　　　　　 ArrayLiteral；一个零个或者多个表达式的序列，其中每一个表示一个数组元素，并且用方括号括起来

当元素列表中的一个逗号没有被 AssignmentExpression 优先处理（如，一个逗号在另一个逗号之前。）的情况下，缺失的数组元素仍然会对数组长度有贡献，并且增加后续元素的索引值。省略数组元素是没有定义的。假如元素在数组末尾被省略，那么元素不会贡献数组长度。

　　　　　　　　　　　　　　　　　　　　　　 ObjectLiteral ( Expression )：对象初始化是一个以直接量的方式描述对象的初始化过程的表达式。它是用花括号括起来的由零或者多对属性名 / 关联值组成的列表，值不需要是直接量，每次对象初始化被执行到时他们会执行一次

 

11.4.6  一元+-运算符

　　一元+-运算符会将其操作数转换为类型

1. 令 expr 为解释执行 UnaryExpression 的结果 .
2. 返回 ToNumber(GetValue(expr)).

11.4.8 按位非运算符 ~unaryExpression

1. 令 expr 为解释执行 UnaryExpression 的结果 .
2. 令 oldValue 为 ToInt32(GetValue(expr)).
3. 返回 oldValue 按位取反的结果。结果为 32 位有符号整数。

11.4.9  逻辑非运算符  ！UnaryExpression

1. 令 expr 为解释执行 UnaryExpression 的结果 .
2. 令 oldValue 为 ToBoolean(GetValue(expr)).
3. 如果 oldValue 为 true ，返回 false.
4. 返回 true.

11.5  乘法运算符

　　语法：MultiplicativeExpression : UnaryExpression ；MultiplicativeExpression * UnaryExpression； MultiplicativeExpression / UnaryExpression ;MultiplicativeExpression % UnaryExpression

1. 令 left 为解释执行 MultiplicativeExpression 的结果 .
2. 令 leftValue 为 GetValue(left).
3. 令 right 为解释执行 UnaryExpression 的结果 .
4. 令 rightValue 为 GetValue(right).
5. 令 leftNum 为 ToNumber(leftValue).
6. 令 rightNum 为 ToNumber(rightValue).
7. 返回将特定运算符 (*, /, or %) 作用于 leftNum 和 rightNum 的结果

11.5.1  使用*运算符

*运算符表示乘法，产生操作数的乘积。乘法运算满足交换律。因为精度问题，乘法不总是满足结合律。

 浮点数的乘法遵循IEEE 754二进制双精度幅度浮点算法规则：

• 若两个操作数之一为NaN，结果为NaN。
• 假如两个操作数的正负号相同，结果就是正的，如果不同就是负的。
• 无穷大被零乘结果是NaN。
• 无穷大被无穷大乘结果就是无穷大。符号按照前面说过的规则决定。
• 无穷大被有穷的非零值乘结果是带正负号的无穷大。符号仍然按照前面说过的规则决定。
• 其它情况下，既没有无穷大也没有NaN参与运算，结果计算出来后会按照IEEE 754 round-to-nearest模式取到最接近的能表示的数。如果值过大不能表示，则结果为相应的正负无穷大。如果值过小不能表示，则结果为相应的正负零。ECMAScript要求支持IEEE 754规定的渐进下溢。

11.5.2  使用/运算符

/运算符表示除法，产生操作数的商。左操作数是被除数，右操作数是除数。ECMAScript不支持整数除法。所有除法运算的操作数和结果都是双精度浮点数。浮点数的除法遵循IEEE 754二进制双精度幅度浮点算法规则：

• 若两个操作数之一为NaN，结果为NaN。
• 假如两个操作数的正负号相同，结果就是正的，如果不同就是负的。
• 无穷大被零除结果是NaN。
• 无穷大被无穷大除结果是NaN。
• 无穷大被零除结果是无穷大。符号按照前面说过的规则决定。
• 无穷大被非零有穷的值除结果是有正负号的无穷大。符号按照前面说过的规则决定。
• 有穷的非零值被无穷大除结果是零。符号按照前面说过的规则决定。
• 零被零除结果是NaN；零被其它有穷数除结果是零，符号按照前面说过的规则决定。
• 有穷的非零值被零除结果是有正负号的无穷大。符号按照前面说过的规则决定。
• 其它情况下，既没有无穷大也没有NaN参与运算，结果计算出来后会按照IEEE 754 round-to-nearest模式取到最接近的能表示的数。如果值过大不能表示，则结果为相应的正负无穷大。如果值过小不能表示，则结果为相应的正负零。ECMAScript要求支持IEEE 754规定的渐进下溢

11.5.3  使用%运算符

 %运算符产生其运算符在除法中的余数。左操作数是被除数，右操作数是除数。

 在C和C++中，余数运算符只接受整数为操作数；在ECMAScript，它还接受浮点操作数。

 浮点数使用%运算符的余数运算与IEEE 754所定义的"remainder"运算不完全相同。IEEE 754 “remainder”运算做邻近取整除法的余数计算，而不是舍尾除法，这样它的行为跟通常意义上的整数余数运算符行为不一致。而ECMAScript语言定义浮点操作%为与Java取余运算符一致；可以参照C库中的函数fmod。

 ECMAScript浮点数的取余法遵循IEEE 754二进制双精度幅度浮点算法规则：

• 若两个操作数之一为NaN，结果为NaN。
• 结果的符号等于被除数。
• 若被除数是无穷大或者除数是零，或者两者皆是，结果就是NaN。
• 若被除数有穷而除数为无穷大，结果为被除数。
• 若被除数为零且除数非零且有穷，结果与被除数相同。
• 其它情况下，既没有0，无穷大也没有NaN参与运算，从被除数n和除数d得到浮点数余数r以数学关系式 r = n − (d × q) 定义，其中q是个整数，在n/d为负时为负，在n/d为正时为正，它应该在不超过n和d的商的前提下尽可能大。结果计算出来后会按照IEEE 754 round-to-nearest模式取到最接近的能表示的数

11.6  加法运算发

　　11.6.1 加号运算符：

 产生式 AdditiveExpression : AdditiveExpression + MultiplicativeExpression 按照下面的过程执行 :

1. 令 lref 为解释执行 AdditiveExpression 的结果 .
2. 令 lval 为 GetValue(lref).
3. 令 rref 为解释执行 MultiplicativeExpression 的结果 .
4. 令 rval 为 GetValue(rref).
5. 令 lprim 为 ToPrimitive(lval).
6. 令 rprim 为 ToPrimitive(rval).
7. 如果 Type(lprim) 为 String 或者 Type(rprim) 为 String，则： 返回由 ToString(lprim) 和 ToString(rprim) 连接而成的字符串
8. 返回将加法运算作用于 ToNumber(lprim) 和 ToNumber(rprim) 的结果

 在步骤5和6中的ToPrimitive调用没有提供hint，除了Date对象之外所有ECMAScript对象将缺少hint的情况当做Number处理；Date对象将缺少hint的情况当做hint为字符串。宿主对象可能将缺少hint的情况当做别的处理。

　　11.6.2  减号运算符

产生式 AdditiveExpression : AdditiveExpression - MultiplicativeExpression 按照下面的过程执行 :

1. 令 lref 为解释执行 AdditiveExpression 的结果 .
2. 令 lval 为 GetValue(lref).
3. 令 rref 为解释执行 MultiplicativeExpression 的结果 .
4. 令 rval 为 GetValue(rref).
5. 令 lnum 为 ToNumber(lval).
6. 令 rnum 为 ToNumber(rval).
7. 返回返回将减法运算作用于 ToNumber(lprim) 和 ToNumber(rprim) 的结果

　　11.6.3  加法用于数字

 +运算符作用于两个数字类型的操作数时表示加法，产生两个操作数之和。-运算符表示减法，产生两个数字之差。

 加法是满足交换律的运算，但是不总满足结合律。

 加法遵循IEEE 754二进制双精度幅度浮点算法规则：

• 两个正负号相反的无穷之和为NaN。
• 两个正负号相同的无穷大之和是具有相同正负的无穷大。
• 无穷大和有穷值之和等于操作数中的无穷大。
• 两个负零之和为-0。
• 两个正零，或者两个正负号相反的零之和为+0。
• 零与非零有穷值之和等于非零的那个操作数。
• 两个大小相等，符号相反的非零有穷值之和为+0。
• 其它情况下，既没有无穷大也没有NaN或者零参与运算，并且操作数要么大小不等，要么符号相同，结果计算出来后会按照IEEE 754 round-to-nearest模式取到最接近的能表示的数。如果值过大不能表示，则结果为相应的正负无穷大。如果值过小不能表示，则结果为相应的正负零。ECMAScript要求支持IEEE 754规定的渐进下溢。

 -运算符作用于两个数字类型时表示减法，产生两个操作数之差。左边操作数是被减数右边是减数。给定操作数a和b，总是有a–b产生与a + ( -b )产生相同结果。

 

11.7  位运算移位运算符

语法：ShiftExpression : AdditiveExpression ；ShiftExpression << AdditiveExpression ；ShiftExpression >> AdditiveExpression ；ShiftExpression >>> AdditiveExpression

11.7.1  左移运算符

 表示对左操作数做右操作数指定次数的按位左移操作。

 产生式 ShiftExpression : ShiftExpression << AdditiveExpression 按照下面的过程执行 :

1. 令 lref 为解释执行 ShiftExpression 的结果 .
2. 令 lval 为 GetValue(lref).
3. 令 rref 为解释执行 AdditiveExpression 的结果 .
4. 令 rval 为 GetValue(rref).
5. 令 lnum 为 ToInt32(lval).
6. 令 rnum 为 ToUint32(rval).
7. 令 shiftCount 为用掩码算出 rnum 的最后五个比特位 , 即计算 rnum & 0x1F 的结果。
8. 返回 lnum 左移 shiftCount 比特位的结果。结果是一个有符号 32 位整数。

11.7.2  带符号右移运算符

产生式 ShiftExpression : ShiftExpression >> AdditiveExpression 按照下面的过程执行 :

1. 令 lref 为解释执行 ShiftExpression 的结果 .
2. 令 lval 为 GetValue(lref).
3. 令 rref 为解释执行 AdditiveExpression 的结果 .
4. 令 rval 为 GetValue(rref).
5. 令 lnum 为 ToInt32(lval).
6. 令 rnum 为 ToUint32(rval).
7. 令 shiftCount 为用掩码算出 rnum 的最后五个比特位 , 即计算 rnum & 0x1F 的结果。
8. 返回 lnum 带符号扩展的右 移 shiftCount 比特位的结果 . The most significant bit is propagated. 结果是一个有符号 32 位整数。

11.7.3  无符号右移运算符

产生式 ShiftExpression : ShiftExpression >>> AdditiveExpression 按照下面的过程执行 :

1. 令 lref 为解释执行 ShiftExpression 的结果 .
2. 令 lval 为 GetValue(lref).
3. 令 rref 为解释执行 AdditiveExpression 的结果 .
4. 令 rval 为 GetValue(rref).
5. 令 lnum 为 ToUint32(lval).
6. 令 rnum 为 ToUint32(rval).
7. 令 shiftCount 为用掩码算出 rnum 的最后五个比特位 , 即计算 rnum & 0x1F 的结果。
8. 返回 lnum 做 0 填充右移 shiftCount 比特位的结果 . 缺少的比特位填 0。 结果是一个无符号 32 位整数 .

 11.8   比较运算符

　　语法：

　　　　RelationalExpression :

　　　　ShiftExpression

　　　　RelationalExpression < ShiftExpression

　　　　RelationalExpression > ShiftExpression

　　　　RelationalExpression <= ShiftExpression

　　　　RelationalExpression >= ShiftExpression

　　　　RelationalExpression instanceof ShiftExpression

　　　　RelationalExpression in ShiftExpression

　　　　

　　　　RelationalExpressionNoIn :

　　　　ShiftExpression

　　　　RelationalExpressionNoIn < ShiftExpression

　　　　RelationalExpressionNoIn > ShiftExpression

　　　　RelationalExpressionNoIn <= ShiftExpression

　　　　RelationalExpressionNoIn >= ShiftExpression

　　　　RelationalExpressionNoIn instanceof ShiftExpression

11.8.5  抽象关系比较算法

　　　　比较x和y的值，会产生结果可为true ， false ， undefined

　　　　参数除了x和y还需要一个名为leftFirst的布尔值标记，解析顺序的控制。LeftFirst 标志是必须的，因为 ECMAScript 规定了表达式是从左到右顺序执行的。LeftFirst 的默认值是 true，这表明在相关的表达式中，参数 x 出现在参数 y 之前。如果 LeftFirst 值是 false，情况会相反，操作数的执行必须是先 y 后 x。

　　　　

11.8.6  instanceof运算符：

1. 令 lref 为解释执行 RelationalExpression 的结果 .
2. 令 lval 为 GetValue(lref).
3. 令 rref 为解释执行 ShiftExpression 的结果 .
4. 令 rval 为 GetValue(rref).
5. 如果 Type(rval) 不是 Object，抛出一个 TypeError 异常 .
6. 如果 rval 没有 [[HasInstance]] 内置方法，抛出一个 TypeError 异常 .
7. 返回以参数 lval. 调用 rval 的 [[HasInstance]] 内置方法的结果

 

11.8.7  in 运算符　　

1. 令 lref 为解释执行 RelationalExpression 的结果 .
2. 令 lval 为 GetValue(lref).
3. 令 rref 为解释执行 ShiftExpression 的结果 .
4. 令 rval 为 GetValue(rref).
5. 如果 Type(rval) 不是 Object ，抛出一个 TypeError 异常 .
6. 返回以参数 ToString(lval). 调用 rval 的 [[HasProperty]] 内置方法的结果

 

11.9   等值运算符

　　语法：

　　EqualityExpression :

　　RelationalExpression

　　EqualityExpression == RelationalExpression

　　EqualityExpression != RelationalExpression

　　EqualityExpression === RelationalExpression

　　EqualityExpression !== RelationalExpression

　　

　　EqualityExpressionNoIn :

　　RelationalExpressionNoIn

　　EqualityExpressionNoIn == RelationalExpressionNoIn

　　EqualityExpressionNoIn != RelationalExpressionNoIn

　　EqualityExpressionNoIn === RelationalExpressionNoIn

　　EqualityExpressionNoIn !== RelationalExpressionNoIn

 

11.9.3  抽象相等比较算法　　

　　比较运算x==y, 其中x和 y是值，产生true或者false。这样的比较按如下方式进行：

1. 若Type(x)与Type(y)相同， 则
   1. 若Type(x)为Undefined， 返回true。
   2. 若Type(x)为Null， 返回true。
   3. 若Type(x)为Number， 则
      1. 若x为NaN， 返回false。
      2. 若y为NaN， 返回false。
      3. 若x与y为相等数值， 返回true。
      4. 若x 为 +0 且 y为−0， 返回true。
      5. 若x 为 −0 且 y为+0， 返回true。
      6. 返回false。
   4. 若Type(x)为String, 则当x和y为完全相同的字符序列（长度相等且相同字符在相同位置）时返回true。 否则， 返回false。
   5. 若Type(x)为Boolean, 当x和y为同为true或者同为false时返回true。 否则， 返回false。
   6. 当x和y为引用同一对象时返回true。否则，返回false。
2. 若x为null且y为undefined， 返回true。
3. 若x为undefined且y为null， 返回true。
4. 若Type(x) 为 Number 且 Type(y)为String， 返回comparison x == ToNumber(y)的结果。
5. 若Type(x) 为 String 且 Type(y)为Number，
6. 返回比较ToNumber(x) == y的结果。
7. 若Type(x)为Boolean， 返回比较ToNumber(x) == y的结果。
8. 若Type(y)为Boolean， 返回比较x == ToNumber(y)的结果。
9. 若Type(x)为String或Number，且Type(y)为Object，返回比较x == ToPrimitive(y)的结果。
10. 若Type(x)为Object且Type(y)为String或Number， 返回比较ToPrimitive(x) == y的结果。
11. 返回false。

 

11.9.4  严格等于运算符：===　　

1. 令 lref 为解释执行 EqualityExpression 的结果 .
2. 令 lval 为 GetValue(lref).
3. 令 rref 为解释执行 RelationalExpression 的结果 .
4. 令 rval 为 GetValue(rref).
5. 返回做用严格相等比较算法于 rval === lval的结果

 

11.9.6  严格等于比较算法：

　　

比较 x===y，x 和 y 为值，需要产出 true 或 false。比较过程如下：

1. 如果 Type(x) 与 Type(y) 的结果不一致，返回 false，否则
2. 如果 Type(x) 结果为 Undefined，返回 true
3. 如果 Type(x) 结果为 Null，返回 true
4. 如果 Type(x) 结果为 Number，则
   1. 如果 x 为 NaN，返回 false
   2. 如果 y 为 NaN，返回 false
   3. 如果 x 与 y 为同一个数字，返回 true
   4. 如果 x 为 +0，y 为 -0，返回 true
   5. 如果 x 为 -0，y 为 +0，返回 true
   6. 返回 false
5. 如果 Type(x) 结果为 String，如果 x 与 y 为完全相同的字符序列（相同的长度和相同的字符对应相同的位置），返回 true，否则，返回 false
6. 如果 Type(x) 结果为 Boolean，如果 x 与 y 都为 true 或 false，则返回 true，否则，返回 false
7. 如果 x 和 y 引用到同一个 Object 对象，返回 true，否则，返回 false

 

11.13.1  简单赋值：　　

1. 令 lref 为解释执行 LeftH 和 SideExpression 的结果 .
2. 令 rref 为解释执行 AssignmentExpression 的结果 .
3. 令 rval 为 GetValue(rref).
4. 抛出一个 SyntaxError 异常，当以下条件都成立 :
   • Type(lref) 为 Reference
   • IsStrictReference(lref) 为 true
   • Type(GetBase(lref)) 为环境记录项
   • GetReferencedName(lref) 为 "eval" 或 "arguments"
5. 调用 PutValue(lref, rval).
6. 返回 rval.

 

11.13.2  组合赋值　　

1. 令 lref 为解释执行 LeftH 和 SideExpression 的结果 .
2. 令 lval 为 GetValue(lref).
3. 令 rref 为解释执行 AssignmentExpression 的结果 .
4. 令 rval 为 GetValue(rref).
5. 令 r 为作用运算符 @ 于 lval 和 rval 的结果。
6. 抛出一个 SyntaxError 异常，当以下条件全部成立：
   • Type(lref) 为 Reference
   • IsStrictReference(lref) 为 true
   • Type(GetBase(lref)) 为环境记录项
   • GetReferencedName(lref) 为 "eval" 或 "arguments"
7. 调用 PutValue(lref, r).
8. 返回 r.

 

转载于:https://www.cnblogs.com/Decmber/p/5702016.html