docs/uts/operator.md
| 名字 | 简写的操作符 | 含义 |
|---|---|---|
| 赋值(Assignment) | x = y | x = y |
| 加法赋值(Addition assignment) | x += y | x = x + y |
| 减法赋值(Subtraction assignment) | x -= y | x = x - y |
| 乘法赋值(Multiplication assignment) | x *= y | x = x * y |
| 除法赋值(Division assignment) | x /= y | x = x / y |
| 求余赋值(Remainder assignment) | x %= y | x = x % y |
| 左移位赋值(Left shift assignment) | x <<= y | x = x << y |
| 右移位赋值(Right shift assignment) | x >>= y | x = x >> y |
| 无符号右移位赋值(Unsigned right shift assignment) | x >>>= y | x = x >>> y |
| 按位与赋值(Bitwise AND assignment) | x &= y | x = x & y |
| 按位异或赋值(Bitwise XOR assignment) | x ^= y | x = x ^ y |
| 按位或赋值(Bitwise OR assignment) | x |= y | x = x | y |
| 运算符 | 描述 | 返回 true 的示例 |
|---|---|---|
| 等于 Equal (==) | 如果两边操作数相等时返回 true。 | var1==var2 |
| 不等于 Not equal (!=) | 如果两边操作数不相等时返回 true | var1!=var2 |
| 引用相等 Reference equal (===) | 比较对象类型时，两边操作数指向同一个对象返回 true。比较基础类型时各平台有差异，详情。 | var1===var2 |
| 引用不等 Reference not equal (!==) | 比较对象类型时，两边操作数不指向同一个对象时返回 true。比较基础类型时各平台有差异，详情。 | var1!==var2 |
| 大于 Greater than (>) | 左边的操作数大于右边的操作数返回 true | var1>var2 |
| 大于等于 Greater than or equal (>=) | 左边的操作数大于或等于右边的操作数返回 true | var1>=var2 |
| 小于 Less than (<) | 左边的操作数小于右边的操作数返回 true | var1<var2 |
| 小于等于 Less than or equal (<=) | 左边的操作数小于或等于右边的操作数返回 true | var1<=var2 |
| 运算符 | 范例 | 描述 |
|---|---|---|
| 求余(%) | 二元运算符. 返回相除之后的余数. | |
| 自增(++) | 一元运算符. 将操作数的值加一. 如果放在操作数前面 (++x), 则返回加一后的值; 如果放在操作数后面 (x++), 则返回操作数原值,然后再将操作数加一. | |
| 自减(--) | 一元运算符. 将操作数的值减一. 前后缀两种用法的返回值类似自增运算符. | |
| 加(+) | 二元运算符. 将两个数相加. | |
| 减(-) | 二元运算符. 将两个数相减. | |
| 乘(*) | 二元运算符. 将两个数相乘. | |
| 除(/) | 二元运算符. 将两个数相除. |
| Operator | Usage | Description |
|---|---|---|
| 按位与 AND | a & b | 在 a,b 的位表示中，每一个对应的位都为 1 则返回 1， 否则返回 0. |
| 按位或 OR | a | b | 在 a,b 的位表示中，每一个对应的位，只要有一个为 1 则返回 1， 否则返回 0. |
| 按位异或 XOR | a ^ b | 在 a,b 的位表示中，每一个对应的位，两个不相同则返回 1，相同则返回 0. |
| 按位非 NOT | ~ a | 反转被操作数的位。 |
| 左移 shift | a << b | 将 a 的二进制串向左移动 b 位,右边移入 0. |
| 算术右移 | a >> b | 把 a 的二进制表示向右移动 b 位，丢弃被移出的所有位.(译注:算术右移左边空出的位是根据最高位是 0 和 1 来进行填充的) |
| 无符号右移(左边空出位用 0 填充) | a >>> b | 把 a 的二进制表示向右移动 b 位，丢弃被移出的所有位，并把左边空出的位都填充为 0 |
| 运算符 | 范例 | 描述 |
|---|---|---|
| 逻辑与(&&) | condition1 && condition2 | (逻辑与) |
| 逻辑或(||) | condition1 || condition2 | (逻辑或) |
| 逻辑非(!) | !condition1 | (逻辑非) |
注意
逻辑运算符操作数的类型必须是 boolean，目前不支持将操作数自动转化为布尔类型。
除了比较操作符，它可以在字符串值中使用，连接操作符（+）连接两个字符串值相连接，返回另一个字符串，它是两个操作数串的结合。
console.log("my " + "string"); // console logs the string "my string".
注意
在iOS平台，连接操作符（+）目前仅支持字符串的连接，即+操作符前后都必须是字符串类型。
条件运算符是 uts 中唯一需要三个操作数的运算符。运算的结果根据给定条件在两个值中取其一。语法为：
条件 ? 值1 : 值2
const status = age >= 18 ? "adult" : "minor";
+
+=
=
&
&=
~
|
|=
^
^=
?--
/
/===>
>=
++
!=<<
<<=
<
<=
&&
&&=
!??=||
||=
*
*=???.
%
%=>>
>>=
===
!==
--=>>>
>>>=uts 中算数运算符在大部分场景下和 ts 中的行为一致，但是在有字面量或者是平台专有数字类型参与运算时，不同平台可能会有不同的表现。 算数运算符 + - * / % 行为一致，下表以 + 和 / 为例列出了各种场景下的详细差异。
| 场景 | 示例 | Kottlin 结果 | Swift 结果 |
|---|---|---|---|
| number + - * / % number | number + number | 结果为 number | 结果为 number |
| number + - * / % 字面量 #{rowspan=2} | number + 1 | 结果为 number | 结果为 number |
| number + 3.14 | 结果为 number | 结果为 number | |
| number + - * / % 变量 #{rowspan=4} | let a: Int = 1; number + a | 结果为 number | 结果为 number |
| let b: Double = 1; number + b | 结果为 number | 结果为 number | |
| let c: Long = 1; number + c | 结果为 number | Swift 中无 Long | |
| let d: Int64 = 1; number+ d | kottlin 中无 Int64 | 结果为 number | |
| 字面量 + - * / % number #{rowspan=2} | 1 + number | 结果为 number | 结果为 number |
| 3.14 + number | 结果为 number | 结果为 number | |
| 变量 + - * / % number #{rowspan=4} | let a: Int = 1; a + number | 结果为 number | 编译失败，需要用 (a as number) + number |
| let b: Double = 1; b + number | 结果为 number | 编译失败，需要用 (b as number) + number | |
| let c: Long = 1; c + number | 结果为 number | Swift 中无 Long | |
| let d: Int64 = 1; d + number | kottlin 中无 Int64 | 编译失败，需要用 (d as number) + number | |
| 字面量 + - * % 字面量 #{rowspan=3} | 1 + 1 | 结果为 2 Int | 结果为2 Int |
| 1 + 3.14 | 结果为4.14 Double | 结果为4.14 Double | |
| 1.0 + 3.14 | 结果为4.14 Double | 结果为4.14 Double | |
| 字面量 / 字面量 | 1 / 10 | 无明确类型时为 0.1 number，有类型时遵守类型约定 | 无明确类型时为 0.1 number，有类型时遵守类型约定 |
| 专有类型变量 / 字面量 #{rowspan=2} | let a: Int = 2; a / 10 | 结果为 0 Int | 结果为0 Int |
| let a: Int = 2; a / 10.0 | 结果为 0.2 Double | 编译失败，Int / Double 不合法 需使用 a / Int(10.0) | |
| 专有类型变量 + - * % 字面量 #{rowspan=2} | let a: Int = 2; a + 10 | 结果为 12 Int | 结果为12 Int |
| let a: Int = 2; a + 3.14 | 结果为 5.14 Double | 编译失败, 需要 a + Int(3.14) = 5 | |
| 相同的专有类型变量 + - * / % 操作 #{rowspan=2} | let a: Int = 1; let b: Int = 2; a + b | 结果为 3 Int | 结果为3 Int |
| let a: Double = 1.0; let b: Double = 2.0; a + b | 结果为 3.0 Double | 结果为 3.0 Double | |
| 不同的专有类型变量 + - * / % 操作 #{rowspan=2} | let a: Int = 1; let b: Float = 3.14.toFloat(); a + b | 结果为4.14, Float | 编译失败，不同类型变量不能操作 |
| let a: Float = 1.0.toFloat(); let b: Double = 3.14; a + b | 结果为4.14，Double | 编译失败，不同类型变量不能操作 |
number 和平台专有类型的 + - * / % 规则：
uts 中比较运算符在大部分场景下和 ts 中的行为一致，但是在有字面量或者是平台专有数字类型参与比较操作时，不同平台可能会有不同的表现。
比较运算符 > >= < <= 行为一致，下表以 > 为例列出了各种场景下的详细差异。
| 场景 | 示例 | Kottlin 结果 | Swift 结果 |
|---|---|---|---|
| number > number | number > number | 结果为 true or false | 结果为 true or false |
| number > 字面量 | number > 1 | 结果为 true or false | 结果为 true or false |
| number > 变量 | let a: Int = 1; number > a | 结果为 true or false | 结果为 true or false |
| 字面量 > number | 3.14 > number | 结果为 true or false | 结果为 true or false |
| 变量 > number | let a: Int = 1; a > number | 结果为 true or false | 结果为 true or false |
| 字面量 > 字面量 | 3.14 > 1 | 结果为 true | 结果为 true |
| 专有类型变量 > 字面量 | let a: Int = 2; a > 3.14 | 结果为 false | 结果为 false |
| 相同的专有类型变量比较 | let a: Int = 2; let b: Int = 1; a > b | 结果为 true | 结果为 true |
| 不同的专有类型变量比较 | let a: Int = 1; let b: Float = 3.14.toFloat(); a > b | 结果为false | 编译失败，不同类型变量不能比较 |
| 场景 | 示例 | Kottlin 结果 | Swift 结果 |
|---|---|---|---|
| number == number (!= === !== 行为相同) | number == number | 值相同就true | 值相同就true |
| number == 字面量 (!= === !== 行为相同) | number == 1 | 值相同就true | 值相同就true |
| number == 变量 (!= === !== 行为相同) | let a: Int = 1; number == a | 值相同就true | 值相同就true |
| 字面量 == number (!= === !== 行为相同) | 1 == number | 值相同就true | 值相同就true |
| 变量 == number (!= === !== 行为相同) | let a: Int = 1; a == number | 值相同就true | 值相同就true |
| 字面量 == 字面量 (!= 行为相同) | 1 == 1 （相同类型） | 值相同就true | 值相同就true |
| 1 == 3.14 (不同类型) | 编译失败，不支持比较 | 值相同就为true | |
| 字面量 === 字面量 (!== 行为相同) | 1 === 1 （相同类型） | 值相同就true | 编译失败，=== 和 !== 只能用于引用类型比较 |
| 1 === 3.14 (不同类型) | 编译失败，不支持比较 | 编译失败，=== 和 !== 只能用于引用类型比较 | |
| 专有类型变量 == 字面量 (!= 行为相同) | let a: Int = 2; a == 10 （相同类型） | 值相同就true | 值相同就true |
| let a: Int = 2; a == 3.14 （不同类型） | 编译失败，不支持比较 | 值相同就true | |
| 专有类型变量 === 字面量 (!== 行为相同) | let a: Int = 2; a === 10 （相同类型） | 值相同就true | 编译失败，=== 和 !== 只能用于引用类型比较 |
| let a: Int = 2; a === 3.14 （不同类型） | 编译失败，不支持比较 | 编译失败，=== 和 !== 只能用于引用类型比较 | |
| String == String (!= 行为相同) | "a" == "a" | 结果为 true | 结果为 true |
| String === String (!== 行为相同) | "a" === "a" | 结果为 true | 编译失败，不能比较 |
| Array == Array (!= 行为相同) | [1] == [1] | 结果为 false | 结果为 true,数组类型相同，元素相同就为true |
| Array === Array (!== 行为相同) | [1] === [1] | 结果为 false | 编译失败，不能比较 |
=== 和 !==，本意是内存地址相同，即不仅值相同，并且是同一份对象。
但不同平台的逻辑略有差异：
对于运行时表示为原生类型的值（例如 Int），引用相等 (===)等价于相等（==）。
<!-- TODO @yanyilin -->HBuilderX 3.9+
展开语法可以在函数调用/数组构造时，将数组表达式在语法层面展开。展开语法使用 ... 操作符表示。
没有展开语法的时候，只能组合使用 push, splice, concat 等方法，来将已有数组元素变成新数组的一部分。有了展开语法，通过字面量方式，构造新数组会变得更简单、更优雅：
const array1 = ['a', 'b']
const array2 = ['c', ...array1, 'd'] //把array1的内容组合赋值给array2
如果想将数组元素迭代为函数剩余参数，也可以使用 ... 操作符。
fn('a', ...['b', 'c'])
尤其是列表加载场景，从服务器取到一批新数组，就可以使用...快捷的追加到之前的data数组中。
假使uvue的data中定义了一个dataList数组，服务器返回了res，res.data是合法的数组，那么就可以把新数组快捷的追加到dataList数组中。
this.dataList.push(...res.data)
剩余语法 (Rest syntax) 看起来和展开语法完全相同，不同点在于，剩余参数用于解构数组和对象。
从某种意义上说，剩余语法与展开语法是相反的：展开语法将数组展开为其中的各个元素，而剩余语法则是将多个元素收集起来并“凝聚”为单个元素。请参考：剩余参数。