操作符

#赋值运算符(Assignment operators)

#比较运算符(comparison operators)

#算数运算符(Arithmetic operators)

#位运算符(Bitwise operators)

#逻辑运算符(Logical operators)

#字符串运算符(String operators)

除了比较操作符，它可以在字符串值中使用，连接操作符（+）连接两个字符串值相连接，返回另一个字符串，它是两个操作数串的结合。

console.log("my " + "string"); // console logs the string "my string".

注意

在iOS平台，连接操作符（+）目前仅支持字符串的连接，即+操作符前后都必须是字符串类型。

#条件（三元）运算符(Conditional operator)

条件运算符是 uts 中唯一需要三个操作数的运算符。运算的结果根据给定条件在两个值中取其一。语法为：

条件 ? 值1 : 值2

const status = age >= 18 ? "adult" : "minor";

#操作符列表

• +
  • 相加运算符 (+) 用于对两个操作数进行相加运算。
• +=
  • 加法赋值操作符 (+=) 将右操作数的值添加到变量，并将结果分配给该变量。两个操作数的类型确定加法赋值运算符的行为。
• =
  • 简单赋值操作符 (=) 用于为变量赋值。赋值表达式本身的值为要赋值的值。
• &
  • 按位与运算符 (&) 在两个操作数对应的二进位都为 1 时，该位的结果值才为 1，否则为 0。
• &=
  • 按位与赋值运算符（＆=）表示两个操作数的二进制，对它们进行按位 AND 运算并将结果分配给变量。
• ~
  • 按位非运算符（~），反转操作数的位。
• |
  • 按位或运算符（|），如果两位之一为 1 则设置每位为 1。
• |=
  • 按位或赋值操作符 (|=) 使用二进制表示操作数，进行一次按位或操作并赋值。
• ^
  • 按位异或运算符（^），如果两位只有一位为 1 则设置每位为 1。
• ^=
  • 按位异或赋值操作符 (^=) 使用二进制表示操作数，进行一次按位异或操作并赋值。
• ?
• --
  • 自减运算符 (--) 将它的操作数减一，然后返回操作数。
• /
  • 除法运算符 (/) 计算了两个操作数的商，左边的数是被除数，右边的是除数。
• /=
• ==
• >
  • 当左边操作数大于右边的时候，大于 (>) 运算符返回true，否则返回false。
• >=
  • 当左边操作数大于等于右边的时候，大于等于 (>=) 运算符返回true，否则返回false。
• ++
  • 自增运算符 (++) 将其操作数递增（加 1）并返回一个值。
• !=
• <<
  • 左移操作符 (<<) 将第一个操作数向左移动指定位数，左边超出的位数将会被清除，右边将会补零。
• <<=
  • 左移赋值运算符 (<<=) 将变量向左移动指定数量的位，并将结果赋值给变量。
• <
  • 当左边操作数小于右边的时候，小于 (<) 运算符返回true，否则返回false。
• <=
  • 当左边操作数小于等于右边的时候，小于等于 (>=) 运算符返回true，否则返回false。
• &&
  • 逻辑与
• &&=
• !
• ??=
• ||
  • 逻辑或。
• ||=
  • 逻辑或赋值（x ||= y）运算仅在 x 为虚值时赋值。
• *
  • 乘法运算符 (*) 计算操作数的乘积。
• *=
• ??
• ?.
  • 可选链运算符（?.）允许读取位于连接对象链深处的属性的值，而不必明确验证链中的每个引用是否有效。?. 运算符的功能类似于 . 链式运算符，不同之处在于，在引用为空 (nullish ) (null) 的情况下不会引起错误。
• %
  • 当一个操作数除以第二个操作数时，取余运算符（％）返回剩余的余数。它与被除数的符号保持一致。
• %=
• >>
  • 右移操作符 (>>) 是将一个操作数按指定移动的位数向右移动，右边移出位被丢弃，左边移出的空位补符号位（最左边那位）。
• >>=
  • 右移赋值运算符 (>>=) 将变量向右移动指定数量的位，并将结果赋值给变量。
• ===
  • 当两边操作数指向同一个对象时，引用相等 (===) 运算符返回true。对于运行时表示为原生类型的值（例如 Int），引用相等 (===)等价于相等（==）。
• !==
  • 当两边操作数不指向同一个对象时，引用不等 (!==) 运算符返回true。
• -
• -=
• >>>
  • 无符号右移运算符（>>>）（零填充右移）将第一个操作数向右移动指定（二进制）位数。
• >>>=

#算数运算符的跨数字类型注意

uts 中算数运算符在大部分场景下和 ts 中的行为一致，但是在有字面量或者是平台专有数字类型参与运算时，不同平台可能会有不同的表现。 算数运算符 + - * / % 行为一致，下表以 + 和 / 为例列出了各种场景下的详细差异。

• 其中 number 是指 number 类型的变量，字面量是指数字字面量，变量是指平台专有数字类型的变量
• 运算符 / 在 字面量 / 字面量场景下, 结果为 number.

#比较运算符的跨数字类型注意

uts 中比较运算符在大部分场景下和 ts 中的行为一致，但是在有字面量或者是平台专有数字类型参与比较操作时，不同平台可能会有不同的表现。

#比较运算符 > >= < <=

比较运算符 > >= < <= 行为一致，下表以 > 为例列出了各种场景下的详细差异。

• 其中 number 是指 number 类型的变量，字面量是指数字字面量，变量是指平台专有数字类型的变量

#比较运算符 == != === !==

#展开语法...

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) 看起来和展开语法完全相同，不同点在于，剩余参数用于解构数组和对象。

从某种意义上说，剩余语法与展开语法是相反的：展开语法将数组展开为其中的各个元素，而剩余语法则是将多个元素收集起来并“凝聚”为单个元素。请参考：剩余参数。

#类型断言as

类型可能不明确、不唯一时，可以使用类型断言操作符 as 来为值指定类型。

常见于 any 类型的明确、字面量的明确，也可以用于可为空 |null 类型的明确。

const a: any = 'a'
a as string // as之后a就可以当做string直接使用了

const a: string | null = 'a'
a as string // 正常

当一个字面量可能成为多种类型时，可以通过as来明确具体类型。

// 数字字面量可以被指定为任何相容的数字类型
1.0 as Double
1.0 as number

// 对象字面量也可以as为USTJSONObject或某个type
{"id":1} as UTSJSONObject

type t = {
	id:number
}
{"id":1} as t

只允许将类型as为具体或更不具体的类型，不能强制转换两个不可能兼容的类型：

const a: string = 'a'

a as any // 正确
a as string // 正确
a as number // 错误

USTJSONObject和type不相容，无法互相as。应该在初始的字面量或JSON.parse环节就决定好类型。

类型断言会在运行时进行，如果无法强制转换，类型断言运算符as会引发异常：

const a: string | null = 'a'
a as string // 正常

a = null
a as string ｜ null // 正常
a as string // 异常

当 as 操作符的左侧为对象字面量时，编译器会进行特殊处理：自动创建类型对应的实例。

{ name: 'Tom', printName: function () { } } as Person

另外：当 as 用在模块导入时，它和类型断言无关，其功能为指定别名。

#typeof实例类型获取

使用 typeof 运算符获取一个实例对象的类型，返回表示类型的字符串。

特别说明：
HBuilderX3.9.0统一为以上规范，在HBuilderX3.9.0之前版本平台专有数字类型变量使用typeof操作符获取的值为"number"

为了与web保持一致，typeof除了布尔、数字、字符串、函数外，全部返回object。如需判断object范围内的具体类型，需另见instanceof

用法示例：

let a = 10.0  //自动推断为number类型
let b: Double = 3.14
let c: Int = 2

typeof a == "number" //true
typeof b == "Double" //true 
typeof c == "Int" //true

// string
let str = "hello uts"
typeof str == "string" //true

//boolean
let ret = true 
typeof ret == "boolean" //true

//function
function fn(obj: string) {
  if (obj instanceof String) {
    // ...
  }
}

typeof fn == "function" //true
typeof Math.sign == "function" //true

//object
let obj = {
	"x": 1,
	"y": 2
}

typeof obj == "object" // true

typeof null == "object" //true
typeof [1, 2, 3] == "object" //true

注意
typeof 运算符的参数只能是实例对象，不能是类型，如下操作是错误用法：

type MyType = {
    name:string
}
typeof MyType   //报错  

typeof 运算返回值一定是字符串，不会返回 TypeScript 类型，这与TypeScript存在差异：

type MyType = {
    name:string
}
let my:MyType = {name:"abc"}
type NewType = typeof my;   //报错

特殊情况
在Android平台，将 number 类型赋值给 any 类型变量时，会根据数值将类型转变为实际平台专有数字类型，使用 typeof 获取此 any 类型变量将会返回实际平台专有数字类型。

let a = 10.0    //自动推断为number类型
let b: Double = 3.14
let c: any = a
let d: any = b

typeof a == "number" //true
typeof b == "Double" //true 
typeof d == "Double" //true

// 在 iOS 平台上
typeof c == "number" //true

// 在Android平台上变量c会根据数据实际数值转换为平台专有数字类型Double  
typeof c == "number" //false 真实返回的是 "Double"

在Android平台，如果类型（或class）存在伴生对象（companion object）时，可以使用typeof运算符，返回的值为object，但不推荐这么使用

typeof Double   //在Android平台Double有伴生对象可以正常运行，实际值为object；在iOS平台报错

#instanceof实例类型判断

使用 instanceof 运算符执行运行时检查，以标识对象是否符合给定类型。

对于 Boolean, Number, String 类型的实例判断，请使用 typeof .

function fn(obj: any) {
  if (obj instanceof Date) {
    // ...
  }
}

包含泛型的类型，不能缺省泛型信息。如不需要判断具体的泛型类型，可以使用 unknown 表示任意泛型类型：

function fn(obj: any) {
  if (obj instanceof Map<unknown, unknown>) {
    // ...
  }
}

已经可以明确判断类型兼容性时无需使用 instanceof 在运行时进行判断，编译阶段会检查出这种情况会报错或者警告：

function fn(obj: Date) {
  if (obj instanceof Date) {
    // ...
  }
}

对于数字类型，instanceof 细化了判断逻辑，除了能判断是否是 number, 还能判断是否是 Int Float Double Int64 Long ... 等所有平台专有数字类型。

let a: Double = 3.14
let b: Int = 2

a instanceof Double //true
b instanceof Int //true