语言库

256 条译文已添加到语言库

笑话

小说

书籍

对话

台词

聊天

考试

游戏

电影

音乐

新闻

生活

电视剧

uniappx

2024年8月9日 02:43:55

函数（Function）
函数是编程语言常见的功能，它可以封装一批代码，对外接收参数，然后返回值。被封装的逻辑，可以被不同的其他代码调用，达到共同复用逻辑的目的。

函数用 function 关键字定义，后面跟着函数名和圆括号。

同时注意，定义函数涉及作用域。

定义函数
函数可以通过函数声明和匿名函数表达式两种方式进行定义。这两种方式在语法上有所不同，但都可以用来创建函数。

函数声明（Function Declaration）
一个函数定义（也称为函数声明，或函数语句）由一系列在 function 关键字后的内容组成，依次为：

函数的名称。
函数参数列表，包围在括号中并由逗号分隔。
函数返回值类型，除返回类型为 void 外，函数必须明确标明返回值类型。
定义函数的 uts 语句，用大括号 {} 括起来。
例如，以下的代码定义了一个简单的函数。函数名为 add，有2个参数 x 和 y，都是 string类型，函数的返回值类型也是 string。

函数的内容是将入参 x 和 y 相加，赋值给变量z，然后通过 return关键字返回z。

function add(x :string, y :string) :string {
    let z : string = x + " " + y
	return z;
}
复制代码
函数表达式（Function Expression）
虽然上面的函数声明在语法上是一个语句，但函数也可以由函数表达式创建。这样的函数可以是匿名的。

例如，函数 add 也可这样来定义：

const add = function (x: string, y: string): string {
    return x + " " + y
}
复制代码
箭头函数
箭头函数表达式（也称胖箭头函数）相比函数表达式具有较短的语法。箭头函数总是匿名的，也就是不需要函数名。

// 以下是不使用箭头函数的写法
const arr = ["Hydrogen", "Helium", "Lithium", "Beryllium"];
const a2 = arr.map(function (s): number {
    return s.length;
});
console.log(a2); // logs [ 8, 6, 7, 9 ]

// 以下是使用箭头函数的写法，逻辑是等价的
const a3 = arr.map((s): number => s.length);
console.log(a3); // logs [ 8, 6, 7, 9 ]
复制代码
无返回值的函数（void）
如果这个函数不需要返回值，可以省略返回值类型也可以使用 void 关键字进行显式声明，同时函数内部末尾也可以省略 return。

function add(x: string, y: string): void {
    let z: string = x + " " + y
    console.log(z)
    // return
}
复制代码
异步函数
使用 async 关键字来声明一个异步函数，异步函数返回一个 Promise 对象。

注意：在 iOS 平台 和 HBuilderX 3.93 以下的Android 平台，异步函数返回的不是 Promise 对象，请分别参考：安卓 异步函数、iOS 异步函数。

注意：异步函数在底层使用协程实现，异步函数内与异步函数外同时操作同一个对象时，由于其能并发执行，其操作顺序可能与预期不一致，会产生竞态条件与线程安全性问题。HBuilderX 3.98 版本的 uni-app x 中已进行优化，默认与框架运行在同一线程。

async function foo(): Promise<void> {
  // ...
}

foo().then(function() {
  console.log('done')
})
复制代码
async 函数可能包含 0 个或者多个 await await 表达式会暂停整个 async 函数的执行进程并出让其控制权，只有当其等待的基于 promise 的异步操作被兑现或被拒绝之后才会恢复进程。promise 的解决值会被当作该 await 表达式的返回值。使用 async / await 关键字就可以在异步代码中使用普通的 try / catch 代码块。

async function foo(): Promise<void> {
  try {
    await aPromise
  } catch (error) {
    console.log(error)
  }
}
复制代码
async 函数一定会返回一个 promise 对象。如果一个 async 函数的返回值看起来不是 promise，那么它将会被隐式地包装在一个 promise 中。

async function foo(): Promise<number> {
  return 1
}
复制代码
调用函数
定义一个函数并不会自动的执行它。定义了函数仅仅是赋予函数以名称并明确函数被调用时该做些什么。调用函数才会以给定的参数真正执行这些动作。

定义了函数 add 后，你可以如下这样调用它：

function add(x :string, y :string) :string {
    let z :string = x + " " + y
	return z;
}
add("hello", "world"); // 调用add函数
复制代码
上述语句通过提供参数 "hello" 和 "world" 来调用函数。

虽然调用了add函数，但并没有获取到返回值。如需要获取返回值，需要再赋值：

function add(x :string, y :string) :string {
	let z :string = x + " " + y
	return z;
}
let s :string = add("hello", "world");
console.log(s) // hello world
复制代码
函数作用域
在函数内定义的变量不能在函数之外的任何地方访问，因为变量仅仅在该函数的域的内部有定义。相对应的，一个函数可以访问定义在其范围内的任何变量和函数。

const hello :string = "hello";
const world :string = "world";

function add(): string {
	let s1 :string = "123";
    return hello + world; // 可以访问到 hello 和 world
}
复制代码
嵌套函数
你可以在一个函数里面嵌套另外一个函数。嵌套（内部）函数对其容器（外部）函数是私有的。它自身也形成了一个闭包。一个闭包是一个可以自己拥有独立的环境与变量的表达式（通常是函数）。

既然嵌套函数是一个闭包，就意味着一个嵌套函数可以”继承“容器函数的参数和变量。换句话说，内部函数包含外部函数的作用域。

可以总结如下：

内部函数只可以在外部函数中访问。
内部函数形成了一个闭包：它可以访问外部函数的参数和变量，但是外部函数却不能使用它的参数和变量。
举例：

function addSquares(a: number, b: number): number {
    function square(x: number): number {
        return x  x;
    }
    return square(a) + square(b);
}
addSquares(2, 3); // returns 13
addSquares(3, 4); // returns 25
addSquares(4, 5); // returns 41
复制代码
命名冲突
当同一个闭包作用域下两个参数或者变量同名时，就会产生命名冲突。更近的作用域有更高的优先权，所以最近的优先级最高，最远的优先级最低。这就是作用域链。链的第一个元素就是最里面的作用域，最后一个元素便是最外层的作用域。

举例：

function outside(): (x: number) => number {
    let x = 5;
    const inside = function (x: number): number {
        return x  2;
    };
    return inside;
}

outside()(10); // 返回值为 20 而不是 10
复制代码
命名冲突发生在 return x 上，inside 的参数 x 和 outside 变量 x 发生了冲突。这里的作用链域是 {inside, outside}。因此 inside 的 x 具有最高优先权，返回了 20（inside 的 x）而不是 10（outside 的 x）。

闭包
uts 允许函数嵌套，并且内部函数可以访问定义在外部函数中的所有变量和函数，以及外部函数能访问的所有变量和函数。

但是，外部函数却不能够访问定义在内部函数中的变量和函数。这给内部函数的变量提供了一定的安全性。

此外，由于内部函数可以访问外部函数的作用域，因此当内部函数生存周期大于外部函数时，外部函数中定义的变量和函数的生存周期将比内部函数执行时间长。当内部函数以某一种方式被任何一个外部函数作用域访问时，一个闭包就产生了。

举例：

const pet = function (name: string): () => string {
    //外部函数定义了一个变量"name"
    const getName = function (): string {
        //内部函数可以访问 外部函数定义的"name"
        return name;
    };
    //返回这个内部函数，从而将其暴露在外部函数作用域
    return getName;
};
const myPet = pet("Vivie");
myPet(); // 返回结果 "Vivie"
复制代码
作为值传递
使用函数表达式（Function Expression）的创建的函数可以作为值进行传递，使用函数声明（Function Declaration）创建的函数不能作为一个值进行传递。

function fn1() {

}

const fn2 = function () {

}

const fn3 = fn2 // 正确，值为函数表达式
const fn4 = fn1 // 错误，值为函数声明

console.log(fn1) // 错误，值为函数声明
console.log(fn2) // 正确，值为函数表达式
console.log(function () {

}) // 正确，值为函数声明
复制代码
函数类型
函数表达式也拥有类型，其类型表达式为 (参数名：参数类型)=>返回值类型，如：

const fn: (x: string) => void
复制代码
函数表达式必须与其类型定义中的参数类型、参数个数以及返回值类型严格匹配

fn = function (x: string) { } // 正确，类型匹配
fn = function (x: string, y: string) { } // 错误，参数类型不匹配
fn = function (x: string): string { return x } // 错误，返回类型不匹配
复制代码
默认参数
函数参数可以设默认值，当省略相应的参数时使用默认值。此时该参数也就成了可选参数。

function multiply(a:number, b:number = 1):number {
  return a*b;
}
multiply(5); // a为5，未传b的值，b默认为1，结果为5
复制代码
可以在常规的函数定义的场景下使用默认参数，例如：

function print(msg:string = "") {
  console.log(msg)
}
print(); // ""


class Persion {
	test(msg: string | null = null) { // 默认值可以为null

	}
}
复制代码
通过函数表达式定义的函数不支持使用默认参数

// 该变量会被编译成Swift或者Kottlin的闭包表达式，其不支持使用默认参数。
const test = function(msg: string | null) { }
复制代码
因为需要作为值进行传递，对象字面量中定义的方法会自动转换为函数表达式，所以也不支持默认参数

// 该属性会被编译成Swift或者Kottlin的闭包表达式，其不支持使用默认参数。
export  {
	data: {
		test(msg: string | null) {

		}
	}
}

复制代码
剩余参数
剩余参数语法允许我们将一个不定数量的参数表示为一个数组。

使用 ... 操作符定义函数的最后一个参数为剩余参数。

function fn(str: string, ...args: string[]) {
  console.log(str, args)
}
复制代码
在这种情况下可以传递可变数量的参数给函数：

fn('a') // 'a' []
fn('a', 'b', 'c') // 'a' ['b', 'c']
复制代码
也可以使用展开语法传递一个数组值给函数的剩余参数（转到 swift 时未支持）：

fn('a', ...['b', 'c']) // 'a' ['b', 'c']
复制代码
注意：在app-android平台，uvue 页面的 methods 中定义的方法不支持剩余参数。

调用限制
UTS 中不存在变量提升，在函数表达式中不可以访问未声明的变量或函数（包括自身）。

const fn = function () {
    console.log(fn) // 编译报错，此时 fn 还未声明
}
fn()
复制代码
function fn () {
    console.log(fn) // 编译报错，此时 fn 还未声明
}
fn()
复制代码
let fn: (() => void) | null = null
fn = function () {
    console.log(fn) // 此时 fn 可以正常访问
}
fn()

uniappx

2024年8月9日 02:43:38

条件
If 语句
当一个逻辑条件为真，用 if 语句执行一个语句。当这个条件为假，使用可选择的 else 从句来执行这个语句。if 语句如下所示：

if (condition1) {
    // statement1;
} else if (condition2) {
    // statement2;
} else if (conditionn1) {
    // statementn;
} else {
    // statementlast;
}
复制代码
注意：if 和 else if 中的条件表达式必须为布尔值

switch 语句
switch 语句允许一个程序求一个表达式的值并且尝试去匹配表达式的值到一个 case 标签。如果匹配成功，这个程序执行相关的语句。switch 语句如下所示：

switch (expression) {
   case label1:
      // statements1
      break;
   case label2:
      // statements2
      break;
   default:
      // statements_def
      break;
}
复制代码
程序首先查找一个与 expression 匹配的 case 语句，然后将控制权转移到该子句，执行相关的语句。如果没有匹配值， 程序会去找 default 语句，如果找到了，控制权转移到该子句，执行相关的语句。如果没有找到 default，程序会继续执行 switch 语句后面的语句。default 语句通常出现在 switch 语句里的最后面，当然这不是必须的。

可选的 break 语句与每个 case 语句相关联， 保证在匹配的语句被执行后程序可以跳出 switch 并且继续执行 switch 后面的语句。如果 break 被忽略，则程序将继续执行 switch 语句中的下一条语句。

三元表达式
uts 支持使用三元表达式（也称三目运算）。它使用一行简短的语句，替代多行的if、else语句。

三元表达式由 condition ? 真返回值 : 假返回值 ，这3部分组成。

第一部分是condition验证条件，返回一个布尔值。与 if 括号里的内容一样。

问号（?）后面是2个候选返回结果，2个候选用冒号（:）分割，形如 A : B。

如果验证条件为 true ，则问号后面的第一个表达式 A 将会执行；如果条件为 false ，则冒号后面的表达式 B 将会执行。

三元表达式最终会返回 A 或 B 中的某一个。

// 使用if的写法，要写多行
let score = 61
let res : string
if (score >= 60) {
	res = "及格"
}
else {
	res = "不及格"
}

// 使用三元运算符，逻辑与上面的if相同，但简化了代码行数
let score = 61
let res = (score>=60) ? "及格" : "不及格"

复制代码
其他例子：

function getFee(isMember: boolean): string {
    return isMember ? "$2.00" : "$10.00";
}

console.log(getFee(true));
// expected output: "$2.00"

console.log(getFee(false));
// expected output: "$10.00"

console.log(getFee(null));
// expected output: "$10.00"
复制代码
三元操作符是右结合的，也就是说你可以像这样把它链接起来， 和 if … else if … else if … else 链类似:

function example(): string {
    return condition1
        ? value1
        : condition2
        ? value2
        : condition3
        ? value3
        : value4;
}

// Equivalent to:

function example(): string {
    if (condition1) {
        return value1;
    } else if (condition2) {
        return value2;
    } else if (condition3) {
        return value3;
    } else {
        return value4;
    }
}
复制代码
循环
for
一个 for 循环会一直重复执行，直到指定的循环条件为 false。 一个 for 语句是这个样子的：

for ([initialExpression]; [condition]; [incrementExpression]) {
    statement;
}
复制代码
当一个 for 循环执行的时候，会发生以下过程：

如果有初始化表达式 initialExpression，它将被执行。这个表达式通常会初始化一个或多个循环计数器。
计算 condition 表达式的值。如果 condition 的值是 true，循环中的语句会被执行。如果 condition 的值是 false，for 循环终止。如果 condition 表达式整个都被省略掉了，3. condition 的值会被认为是 true。
循环中的 statement 被执行。如果需要执行多条语句，可以使用块（{ ... }）来包裹这些语句。
如果有更新表达式 incrementExpression，执行更新表达式。
回到步骤 2。
举例：

for (let i = 0; i < 10; i++) {
    //...
}
复制代码
部分对象，还支持forEach方法，可以更简单的遍历。详见：

数组的forEach

set的forEach

注意：数组遍历不推荐使用 for in 语句，因为在 ts 中 for in 遍历的是数组的下标，而在 Swift 和 Kottlin 中遍历的是数组的元素，存在行为不一致。

while
一个 while 语句只要指定的条件求值为真（true）就会一直执行它的语句块。一个 while 语句看起来像这样：

while (condition) {
    statement;
}
复制代码
如果这个条件变为假，循环里的 statement 将会停止执行并把控制权交回给 while 语句后面的代码。

条件检测会在每次 statement 执行之前发生。如果条件返回为真， statement 会被执行并紧接着再次测试条件。如果条件返回为假，执行将停止并把控制权交回给 while 后面的语句。

要执行多条语句（语句块），要使用语句块 ({ ... }) 包括起来。

举例：

let n = 0;
let x = 0;
while (n < 3) {
    n++;
    x += n;
}
复制代码
do...while
do...while 语句一直重复直到指定的条件求值得到假值（false）。 一个 do...while 语句看起来像这样：

do {
    statement;
} while (condition);
复制代码
statement 在检查条件之前会执行一次。要执行多条语句（语句块），要使用块语句（{ ... }）包括起来。 如果 condition 为真（true），statement 将再次执行。 在每个执行的结尾会进行条件的检查。当 condition 为假（false），执行会停止并且把控制权交回给 do...while 后面的语句。

举例：

let i = 0;
do {
    i += 1;
} while (i < 10);
复制代码
break
使用 break 语句来终止循环。在for、do、while等各种循环中，以及在switch中，都可以使用break跳出循环或switch的选择。

举例：

for (let i = 0; i < 10; i++) {
    if (i > 5) {
        console.log(i)
        break;
        // 如果这里有代码的话，也不会执行，因为break执行时已经跳出了for循环。
    }
}
// break后，跳出for循环，开始向下执行这里的代码。

// 输出 6

// 下面的示例和上面是类似的。
let x = 0;
while (true) {
    x++;
    if (x > 5) {
        break;
    }
}
复制代码
continue
使用 continue 语句来终止当前循环，但与 break 不同， continue 只是终止了这次循环，还会在下一次迭代时继续执行循环。continue 可以在for、do、while等各种循环中使用。

举例：

for (let i = 0; i < 10; i++) {
    if (i > 5) {
        console.log(i)
        continue; // continue 后，本次循环结束，i+1后开始下一次循环。
        // 这里的代码不会被执行，因为上一行 continue 了
    }
}
// 输出 6、7、8、9

// 下面的示例和上面是类似的。
let x = 0;
while (true) {
    x++;
    if (x > 5) {
        continue;
    }
}
复制代码
异常
你可以用 throw 语句抛出一个异常并且用 try...catch 语句捕获处理它。

使用 throw 表达式来抛出异常：

throw new Error("Hi There!");
复制代码
使用 try……catch 表达式来捕获异常：


try {
    // 一些代码
} catch (e: Error) {
    // 处理程序
} finally {
    // 可选的 finally 块
}

复制代码
注意：在 iOS 平台由于 Swift 的特殊语法，无法直接使用 try...catch, 在 iOS 平台上使用 try 的语法详见

uniappx

2024年8月9日 02:43:14

操作符
赋值运算符(Assignment operators)
名字	简写的操作符	含义
赋值(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
比较运算符(comparison operators)
运算符	描述	返回 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
算数运算符(Arithmetic operators)
运算符	范例	描述
求余(%)		二元运算符. 返回相除之后的余数.
自增(++)		一元运算符. 将操作数的值加一. 如果放在操作数前面 (++x), 则返回加一后的值; 如果放在操作数后面 (x++), 则返回操作数原值,然后再将操作数加一.
自减(--)		一元运算符. 将操作数的值减一. 前后缀两种用法的返回值类似自增运算符.
加(+)		二元运算符. 将两个数相加.
减(-)		二元运算符. 将两个数相减.
乘()		二元运算符. 将两个数相乘.
除(/)		二元运算符. 将两个数相除.
位运算符(Bitwise operators)
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
bug&tips

位运算符 暂时不支持 小括号运算提级


let a = 64|(1<<8)

复制代码
期望的是先进行小括号内的左移操作

类似场景，需要拆分一个中间变量来处理

let temp = 1 << 8
let a = 64 | temp

复制代码
这个问题后续会修复

逻辑运算符(Logical operators)
运算符	范例	描述
逻辑与(&&)	condition1 && condition2	(逻辑与)
逻辑或(||)	condition1 || condition2	(逻辑或)
逻辑非(!)	!condition1	(逻辑非)
注意

逻辑运算符操作数的类型必须是 boolean，目前不支持将操作数自动转化为布尔类型。

字符串运算符(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。不同平台有差距，见下
!==
当两边操作数不指向同一个对象时，引用不等 (!==) 运算符返回true。
-
-=
>>>
无符号右移运算符（>>>）（零填充右移）将第一个操作数向右移动指定（二进制）位数。
>>>=
算数运算符的跨数字类型注意
uts 中算数运算符在大部分场景下和 ts 中的行为一致，但是在有字面量或者是平台专有数字类型参与运算时，不同平台可能会有不同的表现。 算数运算符 + -  / % 行为一致，下表以 + 和 / 为例列出了各种场景下的详细差异。

其中 number 是指 number 类型的变量，字面量是指数字字面量，变量是指平台专有数字类型的变量
运算符 / 在 字面量 / 字面量场景下, 结果为 number.
场景	示例	Kottlin 结果	Swift 结果
number + -  / % number	number + number	结果为 number	结果为 number
number + -  / % 字面量	number + 1	结果为 number	结果为 number
number + 3.14	结果为 number	结果为 number
number + -  / % 变量	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	1 + number	结果为 number	结果为 number
3.14 + number	结果为 number	结果为 number
变量 + -  / % number	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
字面量 + -  % 字面量	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，有类型时遵守类型约定
专有类型变量 / 字面量	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)
专有类型变量 + -  % 字面量	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
相同的专有类型变量 + -  / % 操作	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
不同的专有类型变量 + -  / % 操作	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 和平台专有类型的 + -  / % 规则：

number 在左侧，平台专有类型在右侧，可以进行 + -  / % 操作，其结果是 number. (安卓平台支持所有的专有类型，iOS平台目前支持 Int Double Float Float64 Float32 类型)
平台专有类型在左侧，number在右侧，可以进行 + -  / % 操作，其结果是 number. (安卓平台支持所有的专有类型，iOS平台需要将左侧的专有类型变量 as 成 number)
已知Bug

Android平台 uni-app项目的uts插件中，字面量整数相除时真机运行返回类型为number，云端打包返回类型为Int。如let a = 1/10，真机运行时为值为0.1，云端打包后值为0。此问题在uni-app x项目中不存在。
iOS平台 number 和专有类型的 + -  / 操作目前只支持 Int Double Float Float64 Float32 类型，其余专有类型将在后续版本补齐。
iOS平台 number 和专有类型的 % 操作目前只支持 Int 类型，其余专有类型的支持将在后续版本补齐。
比较运算符的跨数字类型注意
uts 中比较运算符在大部分场景下和 ts 中的行为一致，但是在有字面量或者是平台专有数字类型参与比较操作时，不同平台可能会有不同的表现。

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

其中 number 是指 number 类型的变量，字面量是指数字字面量，变量是指平台专有数字类型的变量
场景	示例	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	编译失败，不能比较
=== 和 !==，本意是内存地址相同，即不仅值相同，并且是同一份对象。

但不同平台的逻辑略有差异：

js中可以比较基础类型。swift中不可以比较基础类型，只能比较对象类型
js中比较相同字面量会返回true，比如1===1。但kotlin由于编译优化，可能会把两个字面量映射为同一内存地址，但也可能没有触发编译优化。如果没有优化为同一内存地址，那么kotlin上1===1就会返回false。而swift不允许比较字面量。
对于运行时表示为原生类型的值（例如 Int），引用相等 (===)等价于相等（==）。

展开语法...
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
复制代码
number数据类型与平台专有数字类型不应该直接使用as转换：

number转平台专有数字类型应该使用 Number对象 的 toXXX 方法转换
let a:number = 1;

let i:Int = a.toInt()				// 正确
let i:Int = a as Int				// 错误

let f:Float = a.toFloat()		// 正确
let f:Float = a as Float		// 错误

let d:Double = a.toDouble()	// 正确
let d:Double = a as Double	// 错误

//系统API需要平台专有数字类型，也应该使用 toXXX 方法转换平台专有数字类型
systemAPI(a.toDouble())			// 正确
systemAPI(a as Double)			// 错误
复制代码
平台专有数字类型应该使用 Number.from() 方法转换
let i:Int = 1;
let d:Double = 1.0;

let n:number = Number.from(i)	// 正确
let n:number = i as number		// 错误

let n:number = Number.from(d)	// 正确
let n:number = d as number		// 错误
复制代码
虽然在某些情况下使用 as 转换也可以正常工作，但为了保证各平台兼容性推荐使用上述方法转换

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

const a: string = 'a'

a as any // 正确
a as string // 正确
a as number // 错误
复制代码
USTJSONObject和type不相容，无法互相as。应该在初始的字面量或JSON.parse环节就决定好类型。

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

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

a = null
a as string // 异常
复制代码
以上代码中当值为 null 的时，强制转换为 string 会引发异常。为了让这样的代码用于可空值，请在类型断言的右侧使用可空类型：

a as string ｜ null // 正常
复制代码
当 as 操作符的左侧为对象字面量时，编译器会进行特殊处理：自动创建类型对应的实例。

{ name: 'Tom', printName: function () { } } as Person
复制代码
另外：当 as 用在模块导入时，它和类型断言无关，其功能为指定别名。

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

类型	结果
null	"object"
boolean	"boolean"
number	"number"
string	"string"
function	"function"
平台专有数字类型: Int, Float, Double, Long ...	"Int","Float","Double","Long" ...
平台专有字符串类型: Char ...	"Char" ...
其他任何对象(包含但不限于：Date, Array, Map, UTSJSONObject)	"object"
any	实际类型
为了与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 类型变量将会返回实际平台专有数字类型。 同样，将 number 类型保存在 UTSJSONObject 中，通过下标 [""] 获取对应的属性值类型为 any，使用 typeof 获取此属性值类型也将返回实际平台专有数字类型。

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	编译报错，不支持
平台专有数字类型: Int, Float, Double, Long ...	true or false
typeof 结果为 "object" 的类型(包含但不限于：Date, Array, Map, UTSJSONObject, 自定义类型)	true or false
特别说明： HBuilderX3.9.0 使用 instaceof 对 Boolean, Number, String 类型的实例进行判断会编译报错，请使用 typeof 。在HBuilderX3.9.0之前版本可正常使用 instaceof 对上述类型的判断。

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

复制代码
await
3.93+ (Android) await 操作符用于等待一个 Promise 兑现并获取它兑现之后的值。它只能在异步函数中使用。

在 HBuilderX 3.93 以下的版本或者编译为swift时，await 不能与 Promise 一同使用，此时请分别参考：安卓 异步函数、iOS 异步函数。

async function test(): Promise<string> {
  return await Promise.resolve('hello world');

uniappx

2024年8月9日 02:40:55

字面量
字面量是js的传统概念（MDN的字面量文档）

字面量，即按字面意思给出的固定的值，而不是变量。

比如 5、"abc"、true，都是字面量。

字面量分：布尔字面量、数字字面量、字符串字面量、数组字面量、对象字面量、正则字面量。

举例：

let a = 1 // 这里的 1 ，就是字面量


function test(score): boolean {
	return (score>=60) 
}
test(61) // 这里的 61，就是字面量

let name = "zhangsan" // 字符串"zhangsan"是字面量

let nameArray = ["zhangsan","lisi"] // 数组是字面量

// 对象字面量
let user = {
	name: "zhangsan",
	age: 12
}

const re = /ab+c/  // 正则字面量

console.log("zhangsan".length) // 字面量会被自动推导类型，然后调用类型的方法和属性

复制代码
平时js开发者很少会关心字面量的概念，但因为 uts 中涉及字面量自动类型推导，如果不学习，很难搞清楚这些字面量被自动推导成什么类型。

比如let a = 1/10，a会被自动推导成什么类型？是Int、double、还是number？值是0还是0.1？

下面我们来详细介绍每种字面量。

布尔字面量
布尔类型有两种字面量：true 和 false。

Boolean字面量的自动类型推导简单而统一，全平台必然被自动推导为布尔类型。

数字字面量
数字字面量包括多种基数的整数字面量和以 10 为基数的浮点数字面量

整数字面量
整数可以用十进制（基数为 10）、十六进制（基数为 16）、二进制（基数为 2）表示。

十进制整数字面量由一串数字序列组成，且没有前缀 0。如：0, 117, -345

十六进制整数以 0x（或 0X）开头，可以包含数字（0-9）和字母 a~f 或 A~F。如：0x1123, 0x00111 , -0xF1A7

二进制整数以 0b（或 0B）开头，只能包含数字 0 和 1。如：0b11, 0b0011 , -0b11

浮点数字面量
浮点数字面值可以有以下的组成部分：

一个十进制整数，可以带正负号（即前缀“+”或“ - ”），
小数点（“.”），
小数部分（由一串十进制数表示），
指数部分。
指数部分以“e”或“E”开头，后面跟着一个整数，可以有正负号（即前缀“+”或“-”）。浮点数字面量至少有一位数字，而且必须带小数点或者“e”（大写“E”也可）。

简言之，其语法是：

[(+|-)][digits][.digits][(E|e)[(+|-)]digits]
复制代码
例如：

3.14
-.2345789 // -0.23456789
-3.12e+12  // -3.1210^12
.1e-23    // 0.110^(-23)=10^(-24)=1e-24
复制代码
数字字面量的类型推导，详见

字符串字面量
字符串字面量是由双引号（"）对或单引号（'）括起来的零个或多个字符。字符串被限定在同种引号之间；也即，必须是成对单引号或成对双引号。下面的例子都是字符串字面值：

"foo"
'bar'
"1234"
"one line \n another line"
"John's cat"
复制代码
你可以在字符串字面值上使用字符串对象的所有方法，你也能用对字符串字面值使用类似 String.length 的属性：

console.log("John's cat".length)
// 将打印字符串中的字符个数（包括空格）
// 结果为：10
复制代码
模板字符串
模板字面量 是允许嵌入表达式的字符串字面量。你可以使用多行字符串和字符串插值功能。也被称为“模板字符串”。

// Basic literal string creation
`In uts '\n' is a line-feed.`

// Multiline strings
`In uts this is
 not legal.`

// String interpolation
var name = "Bob", time = "today";
`Hello ${name}, how are you ${time}?`
复制代码
注意

目前 Android、iOS 平台不支持标签函数的用法

转义特殊字符
字符	意思
\b	退格符
\f	换页符
\n	换行符
\r	回车符
\t	制表符
\'	单引号
\"	双引号
\\	反斜杠字符
数组字面量
数组字面值是一个封闭在方括号对 ([]) 中的包含有零个或多个表达式的列表，其中每个表达式代表数组的一个元素。当你使用数组字面值创建一个数组时，该数组将会以指定的值作为其元素进行初始化，而其长度被设定为元素的个数。

下面的示例用 3 个元素生成数组coffees，它的长度是 3。

const coffees = ["French Roast", "Colombian", "Kona"]
复制代码
数组字面值同时也是数组对象。

对象字面量
在JS中，对象字面值是封闭在花括号对{}中的一个对象的零个或多个“属性名—值”对的（元素）列表。

在uts中，对象字面量赋值给变量，默认会被推导为UTSJSONObject类型。

// 创建对象
let userA = {
	name: "zhangsan",
	age: 12
}
console.log(userA)
复制代码
对上述的userA进行typeof，得到的是object。进行 instanceof UTSJSONObject，得到的是true。也就是等同于：

// 创建对象
let userA:UTSJSONObject = {
	name: "zhangsan",
	age: 12
}
console.log(userA)
复制代码
注意花括号还有一个使用场景，被用于type时，是定义了一个自定义类型。下面的代码通过type关键字定义了一个 User类型，该自定义类型有2个属性，string类型的name和number类型的age。

type User = {
	name:string
	age:number
}
复制代码
RegExp字面量
正则表达式是字符被斜线围成的表达式。下面是一个正则表达式文字的一个例子。

const re = /ab+c/
复制代码
字面量类型
HBuilderX 3.91+ 支持使用数值字面量和字符串字面量用作类型注解，也支持联用多个相同类型的字面量以及 null 关键字。这些字面量类型仅用于方便编辑器的提示和校验，编译到目标语言后相当于 Number 或 String 类型。

type Str1 = 'a'
type Str2 = 'a' | null
type Str3 = 'a' | 'b'
type Str4 = 'a' | 'b' | null
type Num1 = 1
type Num2 = 1 | null
type Num3 = 1 | 2
type Num4 = 1 | 2 | null

uniappx

2024年8月9日 01:33:26

类型
强类型语言的特点，是数据类型要求严格。它带来2个好处：

高性能：明确的类型有更大的优化空间，在Android等OS上可以节省内存、提高运算速度；web端由于仍编译为js，不具有类型性能优化。
安全的代码：强类型代码编写虽然没有弱类型自由，但类型检查、非空检查...等各种检查可以提高代码的健壮性。
如果您是js开发者，那么需要一定的学习过程来掌握 UTS 的类型系统。总体原则是你将牺牲一些代码的灵活性，来换取代码的健壮性和高性能。

所谓 类型，即 type，用于对有相同特征的变量或值进行归类。

比如 "abc"和"你好"，都属于字符串string，所有string类型有相同的方法、属性，比如.length属性获取字符串长度。

UTS 的类型有：

基础类型：boolean、number、string、any、null，都是小写。前3个typeof返回类型名称，null的typeof是object，any的typeof是运行时值的类型。
对象类型：Date、Array、Map、Set、UTSJSONObject，首字母大写。typeof返回"object"，判断准确类型需使用 instanceof
使用 type 来自定义类型
特殊类型：function、class、error。
平台专有类型：BigInt、Int、Float、Double、NSString、kotlin.Array...
除了特殊类型，其他类型都可以在变量后面通过:加类型名称来给这个变量声明类型。

详细的类型判断详见操作符文档：typeof和instanceof

除了上述运行时类型，uts还有开发时类型的概念，指为了在开发期间ide可以更好的进行代码提示和校验，但在编译后这些类型会被擦除，变成运行时类型。详见开发时类型 和 类型擦除

布尔值（boolean）
布尔是简单的基础类型，只有2个值：true 和 false。

let a:boolean = true // 定义类型并赋值字面量
let b = false // 未显式声明类型，但根据字面量可自动推导为布尔类型
let c:boolean // 定义类型但定义时未赋值
c = true // 后续为变量赋值字面量
复制代码
注意：

在js里，true == 1、 false == 0。但在其他强类型语言里，1和0是数字类型，无法和布尔类型相比较。
注意 boolean 不要简写成 bool
数字（number）
在 ts 中，数字不区分整型和浮点，就是一个 number。但在 kotlin 和 swift 中，数字需要是一个确定类型，比如 Int、Float、Double，没有泛数字。

UTS 在iOS和Android平台上新增了 number 类型，拉齐了web端的实现，方便开发者写全端兼容代码，也降低web开发者使用 uts 的门槛。

number 是一个泛数字类型，包括整数或浮点数，包括正数负数。例如： 正整数 42 或者 浮点数 3.14159 或者 负数 -1 。

let a:number = 42       //a为number类型
let b:number = 3.14159  //b为number类型
let c = 42              //注意：目前版本推导c为Int类型，新版本将调整c为number类型
let d = 3.14159         //注意：目前版本推导d为float类型，新版本将调整d为number类型
复制代码
编译到kotlin平台时，number 利用 kotlin的 Number抽象类实现
编译到swift平台时，number 利用 NSNumber 实现
平台专有数字类型
除了 number 类型，UTS 在 不同平台，也可以使用 kotlin 、 swift 、浏览器的专有数字类型。

日常开发使用 number 类型就可以。但是也有需要平台专有数字类型的场景：

在 kotlin 和 swift 中，调用系统API或三方SDK的入参或返回值的类型，强制约定了平台专有数字类型。比如入参要求传入 Int，那么传入 number 会报错。比如方法返回了一个 Int，使用 number 类型的变量去接收，也会报错。
number 作为泛数字，性能还是弱于Int。在普通计算中无法体现出差异，但在千万次运算后，累计会产生毫秒级速度差异。
请注意： number本身的使用很简单，但混入了平台专有数字类型后，会引出很多细节需要学习。

如果您不调用原生API，初学uts时建议跳过本节，直接往下看string类型。
如果您是插件作者，那请务必仔细阅读本章节。
Kotlin 专有数字类型
类型名称	长度	最小值	最大值	描述
Byte	8bit	-128	127	整型
UByte	8bit	0	255	整型
Short	16bit	-32768	32767	整型
UShort	16bit	0	65535	整型
Int	32bit	-2147483648	2147483647	整型
UInt	32bit	0	4294967295	整型
Long	64bit	-9223372036854775808	9223372036854775807	整型
ULong	64bit	0	9223372036854775807  2 + 1	整型
Float	32bit	1.4E-45F	3.4028235E38	浮点型
Double	64bit	4.9E-324	1.7976931348623157E308	浮点型
特别说明1:
基本数据类型会有jvm编译魔法加持，kotlin 会把 Int / Double 等非空类型编译为 基本数据类型，Int? / Double? 等可为空的类型编译为 Integer等包装类型，享受不到编译优化加持。

如果涉及大量运算，建议开发者不要使用 number、Int? ，要明确使用 Int等类型 详情

特别说明2:
Byte 类型在 kotlin 中使用场景较为广泛，除表示数字，还常见于 kotlin.ByteArray 形式表示 文件，网络数据 等字节流。

下面列出了 kotlin.ByteArray的常用转换代码:

import Charsets from 'kotlin.text.Charsets'
// 将ByteArray 以 ascii 编码转换为字符串
let str =  byteArrayOf(65,66,67).toString(Charsets.ISO88591)

const str: string = 'hello world!'
// 字符串以UTF-8编码转换为 ByteArray
const bytes: ByteArray = str.toByteArray(Charsets.UTF8)

复制代码
更多kotlin.ByteArray的用法参考文档

Swift 专有的数字类型
类型名称	长度	最小值	最大值	描述
Int8	8bit	-128	127	整型
UInt8	8bit	0	255	整型
Int16	16bit	-32768	32767	整型
UInt16	16bit	0	65535	整型
Int32	32bit	-2147483648	2147483647	整型
UInt32	32bit	0	4294967295	整型
Int64	64bit	-9223372036854775808	9223372036854775807	整型
UInt64	64bit	0	9223372036854775807  2 + 1	整型
Int	64bit	-9223372036854775808	9223372036854775807	整型(64位平台下)
UInt	64bit	0	9223372036854775807  2 + 1	整型(64位平台下)
Int	32bit	-2147483648	2147483647	整型(32位平台下)
UInt	32bit	0	4294967295	整型(32位平台下)
Float	32bit	1.1754944E-38	3.4028235E38	单精度浮点型
Float16	16bit	6.104e-05	65504.0	半精度浮点型(仅iOS14.0及以上系统支持)
Float32	32bit	1.1754944E-38	3.4028235E38	单精度浮点型，等同Float
Float64	64bit	2.2250738585072014E-308	1.7976931348623157E308	双精度浮点型，等同Double
Double	64bit	2.2250738585072014E-308	1.7976931348623157E308	双精度浮点型
注意：

Swift 中 Int 类型是根据平台动态的，在 32 位设备下等同于 Int32, 在64位设备下等同于 Int64。因此建议整型使用 Int, 除非必要，且在保证不会溢出的场景下才使用 Int32、Int64。
同样，Swift 中的 UInt 类型也是根据平台动态的，在 32 位设备下等同于 UInt32, 在64位设备下等同于 UInt64。建议使用 UInt，非必要不使用 UInt32、UInt64。
Float16 在 iOS14.0 及以上系统上才能使用，使用时注意做系统版本号判断。参考
Float32 是 Float 的类型别名, 两者等价。
Float64 是 Double 的类型别名, 两者等价。
js专有的数字类型
js的专用数字类型是BigInt。详见

专有数字类型的定义方式
使用下面的方法，虽然可能会被编辑器报语法错误（后续HBuilderX会修复这类误报），但编译到 kotlin 和 swift 运行是正常的。

声明特定的平台数字类型
平台专有数字类型，均为首字母大写，注意与 number 首字母小写是不同的

// #ifdef APP
 //注意 Int 是首字母大写
let a:Int = 3
let b:Int = 4
// Double
let c:Double  = a  1.0 / b
//Float
let d2 = (100 as Number).toFloat()
// 变量范围为 -128至+127 如果超出此范围会报错
let e:Byte = 127
// #endif
复制代码
注意iOS和Android的专有数字类型不能在web端和小程序端使用，如工程需兼容非App端，要把这些代码放入条件编译中；
iOS和Android都有的类型，比如Int，编译后可跨2个平台；但如果使用了某平台专有的数字类型，比如swift的Int8，则此代码不能编译到Android，工程如需支持Android，则把这些代码写在条件编译中。
// #ifdef APP-IOS
let d:Int8 = 1 // Int8是swift平台专有类型
// #endif
复制代码
这些专有类型定义后，可以使用kotlin和swift为其提供的各种方法，具体参考kotlin和swift的文档。

字面量类型自动推导
具体值，比如42、"abc"，称之为字面量

字面量可以直接用于赋值、传参，比如 let a = 42，就是把42这个数字字面量赋值给了a。

不管是 ts 、kotlin 还是 swift，都具备字面量自动推导类型的能力，为 a 自动推导合适的类型。

在HBuilderX 3.9版之前，在未显式声明类型的情况下使用数字字面量赋值、传参，由平台语言自动推导为相应的类型

但不同平台，推导结果不一样。

ts 中，a 被推导为 number
kotlin 中，a 被推导为 Int
swift 中，a 被推导为 Int
上述只是一个简单的示例，再看一个复杂的例子，let a = 1/10。

a 会被自动推导成什么类型？是Int、double、还是number？值是0还是0.1？在不同平台的差异更大。

在web端，a 的类型是 number，值是0.1，但在 kotlin 中，类型是 Int，值是0。

HBuilderX 3.9起，uts 提供了2条新的字面量类型推导规则：

规则1. 在定义变量时，若没有显式声明变量类型，通过数字字面量以及数字字面量组成的运算表达式来给变量赋值，此时变量类型默认推导为 number类型
举例说明：

HBuilderX3.9前，运行到App，由kotlin和swift编译器推导
let a = 1  // 类型为Int
let b = 1/10 // 类型为Int，值为0
复制代码
HBuilderX3.9起，运行到App，未显式声明类型的变量，需根据数字字面量推导变量类型，此时由 uts 编译器推导，变量类型默认为 number
let a = 1  // 类型为number
let b = 1/10 // 类型为number，值为0.1
复制代码
如您已经显式声明变量类型，无需自动推导，则不受上述规则变化影响。不管HBuilderX 3.9之前还是之后，以下代码都是一样的

let a:Int = 1  // 类型为Int
复制代码
let a = 1，a从Int变成number，这是一个无法向下兼容的更新，请开发者注意调整。

但let b:Int = 1/10 会在 HBuilderX 3.9+起报错，原因见下面第二条规则。

再澄清下规则1：

如果定义变量时已经显式声明了类型，和规则1无关
如果不是定义变量，和规则1无关
也就是如下代码中，60这个字面量的处理，和规则1无关，不会把这个60改为number类型

function test(score: Int): boolean {
	return (score>=60)
}
test(60) // 这个60可以正常传入，无论HBuilderX 3.9之前还是之后
复制代码
规则2. 纯数字字面量的除法，其结果会变成number
在HBuilderX 3.9以前，字面量除法也由kotlin和swift自动推导，kotlin下存在一个问题，看如下代码：

function test(score: number): boolean {
	return (score>=60)
}
test(1/10) // 报错，类型不匹配。需要number而传入Int
复制代码
这个问题看着有点诡异，其实是由于kotlin推导字面量时，把1/10推导成了Int，且值为0。然后把Int类型的数字传给需要number入参的函数test时，就会报类型不匹配。

为了解决这个问题，从HBuilderX 3.9起引入了一条字面量除法规则：纯数字字面量的除法，结果一定是number。

引入这个规则后，上述代码就可以正常运行了。

这里的纯数字字面量的除法，指除法表达式中除了数字和运算符，不包括任何其他东西：

比如变量：let a:Int=1;let b:Int= a/1
比如使用 as 断言：(1 as Int)/10 以上除法表达式，都不是“纯数字字面量的除法”，都不会被推导为number。
但是这条规则，也会导致一个向下兼容问题。

下面的代码在HBuilderX 3.9之前是可以正常运行的，但在3.9起会报错，因为1.0/10被转为了number类型，传入需要Double的函数时就会类型不匹配。

function test(score: Double): boolean {
	return (score>=60.0)
}
test(1.0/10)
复制代码
在HBuilderX 3.9后，为了正确传入Double，要注意跳过规则2。避免纯数字字面量除法，所以正确的写法是：

function test(score: Double): boolean {
	return (score>=60.0)
}
test((1.0 as Double)/10) //表达式中任意一个数字as一下，都不会走规则2
复制代码
也就是，在纯字面量除法时，原生和js冲突了。uts选择了遵守js开发者的习惯，而原生开发者使用平台专有类型时则需注意使用as来规避。

各种数字类型之间的转换
对number类型的数字，使用to方法转换为平台专有类型。

而Number.from()方法传入一个平台专有类型的数字，则可以转换为number。

kotlin
所有的 number 都支持下列方法进行转换（部分类库API使用java编写，其要求的java类型与下列kotlin类型完全一致，可以直接使用

toByte(): Byte
toShort(): Short
toInt(): Int
toLong(): Long
toFloat(): Float
toDouble(): Double
另外 number 还具备下列函数进行整型的无符号转换，这部分API 在jvm上没有对应的原始数据类型，主要的使用场景是 色值处理等专业计算场景的多平台拉齐

toUByte(): UByte
toUShort(): UShort
toUInt(): UInt
toULong(): ULong
let a:number = 3
a.toInt() // 转换为 Int 类型。注意和parseInt、Math.floor的区别。
a.toFloat() // 转换为 Float 类型，后续也将支持 new Float(a) 方式转换
a.toDouble() // 转换为 Double 类型，后续也将支持 new Double(a) 方式转换

// 转换为 Byte 类型，超出-128至+127会溢出，结果为：-31
let b = (225 as Number).toByte()

//平台专有类型之间，也可以使用to方法转换
let i:Int = 1
i.toDouble() // 转换为 Double 类型
复制代码
把 kotlin 专有数字类型，转换为number，使用Number.from()方法

let a: Int = 1
let a1 = Number.from(a) // Int转number

let b: Float = 3.14.toFloat()
let b1 = Number.from(b)

let c: Double = 3.1414926
let c1 = Number.from(c)

let e: Long = 2147483649
let e1 = Number.from(e)
复制代码
swift
swift与kotlin类似。使用to方法和Number.from方法互相转换。

// number转成平台特有类型
let a:number = 3
a.toInt() // 转换为 Int 类型
a.toFloat() // 转换为 float 类型
a.toInt64() // 转换为 Int64 类型

// 平台特有类型转成number
let f: Float = 5.0
let n = Number(f)
let i = Number.from(3.14)
let j = Number.from(f)

let d: Int64 = 12306
let d1 = Number.from(d)

// 特定类型转成其他的特定类型
let a:Int = 3
let b = new Double(a) // 将整型变量 a 转换为 Double 类型
复制代码
number的边界说明
在不同平台上，数值的范围限制不同，超出限制会导致相应的错误或异常
编译至 JavaScript 平台时，数值范围为 ±1.7976931348623157e+308，超出范围会返回 Infinity 或 -Infinity。
编译至 Kotlin 平台时，整型的数值范围为 -9223372036854775808 到 9223372036854775807，超出范围会报错：The value is out of range‌。浮点型的数值范围为 ±1.7976931348623157e+308，超出范围会返回 Infinity 或 -Infinity。平台专有数字类型范围 详见。
编译至 Swift 平台时，整型的数值范围为 -9223372036854775808 到 9223372036854775807，浮点型的数值范围为 ±1.7976931348623157e+308，超出范围会报错：integer literal overflows when stored into 'NSNumber'。平台专有数字类型范围 详见
运算和比较
既然数字类型有很多，就涉及跨类型的数字之间的运算和比较的问题。

跨类型数字的运算，比如加减乘除取余，是什么样的？Int+number可以吗？详见 算数运算符

跨类型数字的比较，大于小于等于不等于的规则是什么样的？详见 比较运算符

更多API
Number内置对象还有很多API，详见

字符串（string）
字符串是一串表示文本值的字符序列，例如："hello world"。

string在多平台均可良好兼容。

let s1:string = "abc"  //显式声明string类型并赋值
let s2 = "abc" // 根据字符串字面量"abc"，自动推导为string类型
let s3:string
s3 = "abc"
复制代码
平台专有字符串类型
iOS 的 NSString
app-ios平台上原生有 NSString ，某些系统API或者三方库API可能使用NSString类型的字符串参数或者返回值。

定义NSString

let nstr = NSString(string="123") // 类型为NSString
复制代码
可按照下面的方法在 string 和 NSString 之间转换：

string 转 NSString
let str = "abcd" // 类型为string
// 方式一：
let nstr1 = NSString(string=str)  // 类型为NSString
// 方式二：
let nstr2 = str as NSString  // 类型为NSString
复制代码
NSString 转 string
let nstr3 = NSString(string="123") // 类型为NSString
// 方式一：
let str4 = String(nstr3)  // 类型为string
// 方式二：
let str5 = nstr3 as string  // 类型为string
复制代码
边界情况说明：

在不同平台上，字符串的长度限制不同，超出限制会导致相应的错误或异常
编译至 JavaScript 平台时，最大长度取决于 JavaScript 引擎，例如在 V8 中，最大长度为 2^30 - 25，超出限制会报错：Invalid string length；在 JSCore 中，最大长度为 2^31 - 1，超出限制会报错：Out of memory ERROR。
编译至 Kotlin 平台时，最大长度受系统内存的限制，超出限制会报错：java.lang.OutOfMemoryError: char[] of length xxx would overflow。
编译至 Swift 平台时，最大长度也受系统内存的限制，超出限制目前没有返回信息。
Android 中的 Char 和 CharArray
app-android平台存在一种 kotlin.Char 类型 文档地址 ，与UTS中长度为1的字符串比较类似。

为了更好的平台兼容性，开发者在UTS中应该尽量避免使用 kotlin.Char 类型，当原生API 要求kotlin.Char 类型或 kotlin.CharArray类型时，可以通过下面的代码进行转换：

string 转 kotlin.CharArray
let kotlinCharArray = "hello".toCharArray()
console.log("CharArray",kotlinCharArray);
复制代码
截取 string 中的kotlin.Char
let singleChar = "hello".toCharArray()[0]
console.log("singleChar",singleChar);
复制代码
当我们需要从kotlin.CharArray中还原字符串时，可以使用下面的代码

let arrayMock = Array<kotlin.Char>()

arrayMock.add("h".toCharArray()[0])
arrayMock.add("e".toCharArray()[0])
arrayMock.add("l".toCharArray()[0])
arrayMock.add("l".toCharArray()[0])
arrayMock.add("o".toCharArray()[0])

console.log(arrayMock.joinToString(""));

复制代码
any类型
有时会遇到在编程阶段还不清楚类型的变量。这些值可能来自于动态的内容，比如来自用户输入或第三方代码库。

这种情况下，我们不希望类型检查器对这些值进行检查而是直接让它们通过编译阶段的检查。那么我们可以使用 any 类型来标记这些变量：

let notSure: any = 4;
notSure = "maybe a string instead";
notSure = false; // okay, definitely a boolean
复制代码
当你只知道一部分数据的类型时，any类型也是有用的。 比如，你有一个数组，它包含了不同的类型的数据：

let list: any[] = [1, true, "free"];
list[1] = 100;
复制代码
注意

在 TS 中可以将 null 赋值给 any 类型的变量，但是在 Swift 和 Kottlin 中，any 类型属于非空类型，也就是不能将 null 赋值给 any 类型的变量。因此 在 UTS 中 也不能将 null 赋值给 any 类型，以免编译失败。
4.18版本起uts在编译到js时，any类型会包含null类型。
null类型
一个表明 null 值的特殊关键字。

uts 的类型系统可以消除来自代码空引用的危险。

许多编程语言中最常见的陷阱之一，就是访问空引用的成员会导致空引用异常。在 Java 中，这等同于 NullPointerException 或简称 NPE。

在 uts 中，类型系统能够区分一个引用可以容纳 null （可空引用）还是不能容纳（非空引用）。 例如，string 类型的常规变量不能容纳 null：

let a: string = "abc" // 默认情况下，常规初始化意味着非空
a = null // 编译错误
复制代码
定义可为null
如果要允许为空，可以声明一个变量为可空字符串（写作 string | null）

let b: string | null = "abc" // 可以设置为空
b = null // ok
复制代码
但这不代表 uts 在App端支持广泛的联合类型，实际上可为空才能这么写。而 let b : string | number 仅能在编译为js时使用，因为kotlin和swift都不支持联合类型。

现在，如果你调用 a 的方法或者访问它的属性，它保证不会导致 NPE，这样你就可以放心地使用：

const l = a.length //返回3
复制代码
但是如果你想访问 b 的同一个属性，那是不安全的，并且编译器会报告一个错误：

const l = b.length // 错误：变量“b”可能为空
复制代码
我们要庆幸编译器的报错，因为如果编译器放过后，在线上运行时万一真的为空，那会导致崩溃。

除了变量，类型的属性也可以为null。此时可以和变量一样使用 | null，还可以用?:来代表可选

type obj = {
	id : number,
	name : string,
	age : number | null,
	sex ?: boolean
}
复制代码
方法参数的可为空，也就是可选参数，其实意思是该参数有默认值，你可以不填，不填就使用默认值，具体见function

安全的访问null
定义可为空后，如何安全访问？

1. 代码中判空后再使用
如果你的代码已经判空，则编译器不会再告警。你可以显式检测 b 是否为 null，在不为 null 的情况下调用 b 的属性和方法。

if (b != null) {
  console.log(b.length) //返回3
}
复制代码
编译器会跟踪所执行检测的信息，并允许你在 if 内部调用 length。

2. 不判空，使用?.进行安全调用
访问可空变量的属性的第二种选择是使用安全调用操作符 ?.

const a = "uts"
const b: string | null = null
console.log(a.length) // a是明确的string类型，它的属性可以直接调用，无需安全调用
console.log(b?.length) // b可能为null，null没有length属性，在没有判空时，.操作符前面必须加?标记
复制代码
如果 b 非空，就返回 b.length，否则返回 null，b?.length这个表达式的类型是 number | null。

安全调用在链式调用中很有用。例如，一个员工 Bob 可能会（或者不会）分配给一个部门。 可能有另外一个员工是该部门的负责人。获取 Bob 所在部门负责人（如果有的话）的名字，写作：

bob?.department?.head?.name
复制代码
如果任意一个属性（环节）为 null，这个链式调用就会返回 null。

空值合并
空值合并运算符（??）是一个逻辑运算符，当左侧的操作数为 null 时，返回其右侧操作数，否则返回左侧操作数。

const foo = null ?? 'default string';
console.log(foo);
// Expected output: "default string"

const baz = 0 ?? 42;
console.log(baz);
// Expected output: 0
复制代码
非空断言
非空断言运算符（!）将任何值转换为非空类型。可以写 b! ，这会返回一个非空的 b 值（例如：在我们示例中的 string）或者如果 b 为 null，就会抛出一个异常。

const l = b!.length
复制代码
vue data中null的用法
很多时候，data的数据需要通过script获取，而 uts 编译为非js时不支持 undefined，初始化时就只能赋null。一旦定义可为null后，调用时就需要用?.操作可选属性。

<script lang=uts>
	type PersonType = {
		id: number,
	  name: string,
		age: number
	}
	export default {
		data() {
			return {
				person: null as PersonType | null,
			}
		},
		onLoad() {
			this.person = JSON.parse<PersonType>(`{
				"id": 1,
				"name": "zhangsan",
				"age": 18
			}`)
			console.log(this.person?.name);
		}
	}
</script>
复制代码
undefined
此类型仅在目标语言为js时支持

undefined是弱类型语言的特色，在js环境下，undefined == null的结果是true。

在kotlin和swift环境下，是没有undefined的，空就是null。

当需要跨平台判空时，可以利用js下undefined == null的特性，用 == null来跨平台的判断一个值是不是空值。

let a: number | undefined = undefined
let b: number | undefined = 1
console.log(a == null) // true
console.log(b == null) // false
复制代码
日期（Date）
日期对象表示日期，包括年月日时分秒等各种日期。

它的类型名称是首字母大写:Date。但通过new Date()赋值时，可以省略:Date。

const myDate = new Date() // 通过new Date赋值时，可以省略:Date
const myDate1:Date = new Date()
console.log(myDate instanceof Date) // Date用typeof会返回object，需使用instanceof判断
const year:number = myDate.getFullYear()
复制代码
在js中，Date其实是内置对象，typeof一个日期，返回的是object。

Date对象还有很多方法属性，详见

与平台日期对象的转换
如果需要将Date 与java平台自带的java.util.Date转换，建议使用时间戳作为关键参数进行转换处理：

Date 转 java.util.Date
import JavaDate from 'java.util.Date' ;

let utsDate = new Date("1998-02-02 01:03:01")
let javaDate = new JavaDate(utsDate.getTime().toLong())
复制代码
java.util.Date 转 Date
import JavaDate from 'java.util.Date' ;

let javaDate =  new JavaDate(1709208329000)
let utsDate = new Date(javaDate.getTime())
复制代码
数组（Array）
Array，即数组，支持在单个变量名下存储多个元素，并具有执行常见数组操作的成员。

js和swift的Array，是可变长的泛型Array。

而在kotlin中，其自带的Array是不可变长的，即数组的length是固定的。只有ArrayList是可变长的。

为了拉齐实现，UTS补充了新的Array，替代kotlin的Array。它继承自kotlin的ArrayList，所以可以变长。

如果开发者需要使用原始的kotlin的不可变长的Array，需使用 kotlin.Array。

需要使用平台专有数组类型的场景，也是如下2种情况：

某些系统API或三方原生SDK的入参或返回值强制指定了kotlin的原生数组类型。
uts新增的可动态变长的Array，在性能上不如固定length、不可变长的原始kotlin.Array。但也只有在巨大量的运算中才能体现出毫秒级的差异。
定义数组
UTS 中 Array 有多种创建方式，这些方式是等价的：

字面量创建
let a1 = [1,2,3];//支持
let a2 = [1,'2',3];//支持

// 需要注意的是，字面量创建的数组，不支持出现空的缺省元素
let a3 = [1,,2,3];//不支持
复制代码
如果想定义一个空数组，则不能依赖编译器的自动推导，需显式声明空数组的类型。见下

使用:Array<>定义数组项的类型
const a1:Array<string> = ["uni-app", "uniCloud", "HBuilder"] //表示数组内容都是string。如不能确定可以写Array<any>
let a2:Array<number> = []; //定义一个数字类型的空数组
复制代码
使用[]定义数组项的类型
const a1: string[] = ['a', 'b', 'c']; //表示数组内容都是string
复制代码
创建数组对象
let a1 = new Array(1,2,3);//支持
let a2 = new Array(1,'2',3);//安卓平台支持, iOS 平台不支持，在 iOS 中创建 Any[] 数组请直接使用数组字面量，如 let a2 = [1. '2', 3]
let a3 = Array(1,2,3);//支持
let a4 = Array(1,'2','3');//安卓平台支持, iOS 平台不支持，在 iOS 中创建 Any[] 数组请直接使用数组字面量，如 let a4 = [1,'2','3']
复制代码
uvue的data定义数组
export default {
	data() {
		return {
			listdata: [] as Array<UTSJSONObject>,
		}
	}
}
复制代码
字面量创建的数组，在uts的老版本上，kotlin自动推导数组类型时，可能会推导成intArray，而不是uts的array。建议显式声明类型。

typeof 一个 array 得到的是 object。需使用 Array.isArray 或 instanceof 来判断数组类型。

let a1 = [1,2,3]
console.log(Array.isArray(a1)) // 返回true
console.log(a1 instanceof Array) // 返回true
复制代码
注意：uts 不支持以 Array(arrayLength) 指定数组长度的方式创建一个数组。

// 下面的写法中，a1 将是一个当前 length 为1, 元素是 100 的整型数组。而不是 length 为 100 ，由 100 个空槽组成的数组。
const a1: Array(100); // [100], 当前数组长度为1

复制代码
遍历数组对象
使用foreach来实现数组的遍历

const array1: string[] = ['a', 'b', 'c'];
array1.forEach((element:string, index:number) => {
	console.log(element)
    console.log(array1[index]) //与上一行代码等价
});
// 打印结果是 a a b b c c
复制代码
平台专有数组类型
kotlin专有数组类型
专有数组类型清单

kotlin.collections.List
kotlin.Array
kotlin.IntArray
kotlin.FloatArray
kotlin.ByteArray
kotlin.LongArray
kotlin.CharArray
...
专有数组类型定义方式

// kotlin.collections.List
let kotlinList= mutableListOf("hello","world")
// kotlin.Array
let kotlinArray = arrayOf("hello","world")
复制代码
专有数组类型 转 Array
统一使用 Array.fromNative 将专有数据类型转换为 Array,下面列出了常见的场景：


	// kotlin.collections.List 转换 Array
	let kotlinList = mutableListOf("hello","world")
	let utsArr1 = Array.fromNative(kotlinList)

	// kotlin.Array 转换 Array
	let kotlinArray = arrayOf("hello","world")
	let utsArr2 = Array.fromNative(kotlinArray)

	//ByteArray 即 java 中的 byte[]   需要HBuilderX 3.9.0 之后版本
	let b1 = byteArrayOf(-1,2,0,3,4,5)
	let c1 = Array.fromNative(b1)

	//LongArray 即 java 中的 long[]  需要HBuilderX 3.9.0 之后版本
	let b2 = longArrayOf(-1,2,0,3,4,5)
	let c2 = Array.fromNative(b2)

	//ShortArray 即 java 中的 short[] 需要HBuilderX 3.9.0 之后版本
	let b3 = shortArrayOf(-1,2,0,3,4,5)
	let c3 = Array.fromNative(b3)

	//IntArray 即 java 中的 int[]
	let b4 = intArrayOf(-1,2,0,3,4,5)
	let c4 = Array.fromNative(b4)

	// kotlin.CharArray 即 java 中的 char[]
	let b5 = charArrayOf(Char(66),Char(66),Char(81))
	let c5 = Array.fromNative(b5)


复制代码
举个例子。如下代码向系统查询了有多少应用可以响应 launcher行为 ，返回的 resolveInfo 是一个 List<ResolveInfo>。

let packageManager = UTSAndroid.getUniActivity()!.getPackageManager();
let intent = new Intent(Intent.ACTIONMAIN);
intent.addCategory(Intent.CATEGORYLAUNCHER);
// 查询当前设备上安装了几个launcher
let resolveInfo = packageManager.queryIntentActivities(intent,0);
复制代码
可以将其先转换为UTS的Array对象再进行其他处理和操作

let launcherList = Array.fromNative(resolveInfo)
console.log(clothing.length);
复制代码
Array 转 专有数组类型
let utsArr= ["hello","world"] //类型为Array

// Array 转换 kotlin.collections.List
let kotlinList = utsArr.toKotlinList()

// Array 转换 kotlin.Array
let kotlinArray = utsArr.toTypedArray()

// 部分java编写的api 要求 FloatArray / IntArray,可以通过下面的方法进行转换

let a:Int[] = [1,2,3,4]
let b = a.toKotlinList().toIntArray()
console.log("b",b[2])

// int[][] 二维数组，可以采用下面的写法
let a = [[2].toKotlinList().toIntArray(),[23].toKotlinList().toIntArray(),[22].toKotlinList().toIntArray()]
let b = a.toKotlinList().toTypedArray()

// Array<Number> 转 java float[]的示例
let a = new Array<Number>(10)
// b是 List<Float>
let b = a.toKotlinList().map(function(it):Float{
	return it.toFloat()
})
// c是 float[]
let c = b.toTypedArray()
// d 是 FloatArray
let d = b.toFloatArray()


复制代码
iOS 平台专有数组类型
UTS 中的 Array 对应到 Swift 中就是 Array, 方法是通用的，无需转换。一般情况下，使用 Array 即可。

但是，某些系统或者三方库 API 可能会要求 OC 的 NSArray、NSMutableArray 类型的数组，这个时候就需要进行转换。

专有数组类型清单

NSArray
NSMutableArray
专有数组类型定义方式

创建 NSArray

NSArray 是 OC 中的不可变数组，顾名思义，数组创建完成之后就不可以再添加或者删除元素。因此，创建 NSArray 对象时就应该完成数组的初始化。可以通过以下方式创建 NSArray:

	// 方式一： 创建一个空数组，注意数组创建后就不可改变，不能再添加或者删除元素，应避免使用该方式。
	let a: NSArray = NSArray()

	// 方式二： 用一个数组创建一个 NSArray, 推荐使用。同样，创建完成后数组不可变。
	let b: NSArray = NSArray(array=[1, 2, 3, 4]) // 等价于 any[]，注意：不是等价于 number[]

	// 方式三: 用一个元素定义 NSArray, 不推荐使用
	let c: NSArray = NSArray(object=1)

	// 方式四：用不定长元素定义 NSArray, 可以使用
	let d: NSArray = NSArray(objects=1, "2", false, "ok")

复制代码
创建 NSMutableArray

NSMutableArray 是 OC 中的可变数组，其是 NSArray 的子类，可变数组创建后可以增加或者删除元素。NSArray 的所有创建方式也都适用于 NSMutableArray

// 方式一： 创建一个空数组，其类型等价于 any[]
let a: NSMutableArray = NSMutableArray()
a.add(1) 	//添加一个元素
a.add("22") //添加一个元素
a.add(false) //添加一个元素
a.remove(1) //移除一个元素
a.removeObject(at=2) //移除一个指定下标的元素
a.removeAllObjects() //移除全部元素
a.removeLastObject() //移除最后一个元素

// 方式二： 用一个数组创建一个 NSMutableArray, 推荐使用。
let b: NSMutableArray = NSMutableArray(array=[1, 2, 3, 4]) // 等价于 any[]，注意：不是等价于 number[]

// 方式三: 用一个元素定义 NSMutableArray
let c: NSMutableArray = NSMutableArray(object=1)

// 方式四：用不定长元素定义 NSMutableArray
let d: NSMutableArray = NSMutableArray(objects=1, "2", false, "ok")

复制代码
专有数组类型 转 Array

// 将 NSArray 转成 Array
let a: NSArray = NSArray(array=[1, 2, 3, 4]) // 等价于 any[]，注意：不是等价于 number[]
let a1 = Array(a)

// 将 NSMutableArray 转成 Array
let b: NSMutableArray = NSMutableArray(array=[1, 2, 3, 4]) // 等价于 any[]，注意：不是等价于 number[]
let b1 = Array(b)

复制代码
Array 转 专有数组类型
// 定义一个 Array
let a = [1, 2, 3] //类型为number[]

// Array 转换成 NSArray
// 方式一：
let a1: NSArray = NSArray(array= a)

// 方式二：
let a2 = a as NSArray

// Array 转换成 NSMutableArray
let a3: NSMutableArray = NSMutableArray(array= a)

复制代码
注意：

无论是 NSArray 还是 NSMutableArray 对象创建后都等价于 any[] 类型的数组，此时 Swift 不再有类型推导，可以往可变数组中添加任意类型的非空元素。
NSArray 和 NSMutableArray 类型的数组不接受空值 null, 任何情况下不要往这两种类型中注入 null。 否则，在运行时可能会引起应用闪退。
Array 类型不能通过 as 方式转换成 NSMutableArray 类型。 但是可以通过 as 方式 转换成 NSArray 类型。
Swift 中的 Array 是值类型，其和 TS 中 Array 的一点区别是 可以通 == 判断两个数组是否相等，只要两个数组的类型和元素一样，判等的结果就是 true。
更多API
Array作为内置对象，还有更多API，详见

Map
Map 是一种 key value 形式的数据类型。

与二维数组相比，Map的key不能重复，并且读写的方式是get()、set()。与UTSJSONObject相比，Map的性能更高，但对数据格式有要求。

定义
//定义一个map1，key为string类型，value也是string类型
const map1: Map<string,string> = new Map();
map1.set('key1', "abc");
console.log(map1.get('key1')) //返回 abc

//定义一个map1，key为number类型，value是Map类型
const map2: Map<number,Map<string,string>> = new Map();
map2.set(1, map1); //把map1作为value传进来
console.log(map2.get(1)); //返回map1
console.log(map2.get(1)?.get("key1")); //返回 abc。因为名为1的key不一定存在，map2.get(1)可能为null，此时需使用 ?. 才能链式调用
复制代码
//通过元素是键值对的数组来创建 Map

const myMap = new Map<number,string>([
  [1, "one"],
  [2, "two"],
  [3, "three"],
]);

复制代码
注意在HBuilderX中console.log一个Map时，返回内容格式如下：

[Object] Map(3) {"sex":0,"name":"zhangsan","age":12}  at pages/index/index.uvue:60
复制代码
开头的[Object]代表其typeof的类型，Map代表它的实际类型，(3)是map的size，{...} 是Map的内容。

还可以把一个UTSJSONObject转为Map

let userA = {
	name: "zhangsan",
	age: 12,
	sex: 0
} // userA 被推导为UTSJSONObject
let userMap = userA.toMap() //UTSJSONObject有toMap方法
复制代码
验证类型
console.log(typeof map1); //返回 object
console.log(map1 instanceof Map); //返回 true
复制代码
更多API
Map对象还有很多API，delete、clear等，详见

UTSJSONObject
json 在 js 中并非一个独立的类型，对一个 json 对象 typeof 返回的是 object。

json 在 js 中用起来很自由，但在强类型语言中，不管kotlin、swift、dart...，都没有这么灵活，例如：

json对象里的每个属性，都需要定义类型
每个可为空的属性，都需要加?.，才能安全读写
一般其他强类型语言的用法，是把json数据内容，转为class、interface或type。然后就可以使用.来访问了。

在 uts 中使用 JSON，有3种方式：

把 json数据转 type，变成一个自定义类型。这不是本章节的内容，详见 type
uts 新增了 UTSJSONObject 对象，可以把 json数据通过字面量赋值 或 JSON.parse()方式，赋值给 uts 内置的 UTSJSONObject 对象。
由于 UTSJSONObject有toMap()方法，所以也可以转为Map后使用json数据。
UTSJSONObject，是一个类型，可以在变量的冒号后面使用，本节的重点就是介绍UTSJSONObject。

对象和数组
首先，我们需要区分JSON对象，和由JSON对象组成的数组。

这是一个 UTSJSONObject 对象。jo 对象有2个属性，x和y，都是数字类型（类型没有声明是因为根据字面量自动推导了）

let jo: UTSJSONObject = {
	"x": 1,
	"y": 2
}
复制代码
这是一个 UTSJSONObject 数组。其数组项里有2个 UTSJSONObject 对象，每个对象都有x和y这2个属性。注意=左边有[]来表示这是一个数组类型。

let jr: UTSJSONObject[] = [
	{"x": 1,"y": 2},
	{"x": 2,"y": 1}
]
复制代码
在 js 中，可以定义一个变量，随意接受对象字面量或数组字面量。但在 UTS 里不行。如果数据内容是数组字面量，就不能定义为 UTSJSONObject。

也就是下面的代码是错误的，不能把数组赋值给对象。在接收网络传输的json数据时，非常需要注意这个类型匹配问题。类型不匹配会造成代码错误和应用崩溃。

let jo: UTSJSONObject = [{
	"x": 1,
	"y": 2
}] //错误，类型不匹配，数组不能赋值给对象
let jo: UTSJSONObject[] = [{
	"x": 1,
	"y": 2
}] //正确，数组赋值给数组
let jo: Array<UTSJSONObject> = [{
	"x": 1,
	"y": 2
}] //正确，数组赋值给数组
let jo = [{
	"x": 1,
	"y": 2
}] //正确，自动推断为 UTSJSONObject 数组
复制代码
定义 UTSJSONObject
可以通过对象字面量的方式定义一个 UTSJSONObject 对象，编译器会根据字面量自动推导类型，此时无需显式声明:UTSJSONObject。

let jo = {
	x: 1,
	y: 2
}

let jo2 = {
	"a-b": 1, // 如果属性名包括-，则必须两侧加引号包围
	"y": 2
}
复制代码
关于属性名是否需要使用引号包围的规则：

如果是对象字面量赋值，普通属性名称无需使用引号包围，但使用也没问题
如果是对象字面量赋值，且属性名包括特殊符号，如：-，则必须两侧加引号包围。
如果是JSON.parse()方法入参需要的字符串，则属性名必须使用双引号包围（web端规则也是如此）
如果开发者不想搞明白这些细节，可以简单粗暴的都给属性名都加上引号。

尽管在 kotlin 中属性名称包含$和等也需要转义，但是 UTS 中是无需特殊处理的，编译器会自动转换。

对于纯字面量，jo 后面的 :UTSJSONObject 可以省略，这些类型比较简单，可以自动推导类型。包括下面的多层嵌套，类型也不会推导出错。

let rect = {
	"x": 20,
	"y": 12,
	"size": {
		"width": 80,
		"height": 80
	}
}
console.log(rect)
复制代码
也就是对于形如{x:something}的对象字面量，如果赋值时不指定类型，在 uts 中会被自动推导为 UTSJSONObject。如果你需要转 type，则需显式声明。

除了字面量定义UTSJSONObject对象，经常用到的是通过 JSON.parse()，把一个 JSON 字符串转成UTSJSONObject对象。

uts 内置了大写的 JSON 对象，有parse()、stringify()等方法。注意JSON和UTSJSONObject不是一个对象。大写 JSON 内置对象，web端也是存在的。而 UTSJSONObject 是 uts 新增的。

let s = `{"result":true, "count":42}` // 常见场景中，这个字符串更多来自于网络或其他应用传输。注意属性名称必须使用引号包围
let jo = JSON.parse(s) // 这个代码适用于HBuilderX 3.9以前
复制代码
在 HBuilderX 3.9以前，JSON.parse()返回的UTSJSONObject。但因为有时网络或其他应用传入的 JSON 数据根节点是数组，而不是对象，会导致崩溃。

所以从 HBuilderX 3.9起，JSON.parse()返回的类型改为any，即可能返回对象、也可能返回数组。这样就需要开发者自行再as一下来指定具体类型了。

新的写法是这样：

let s = `{"result":true, "count":42}` // 常见场景中，这个字符串更多来自于网络或其他应用传输。
let jo = JSON.parse(s) as UTSJSONObject

let sr = `[{"x":1, "y":2},{"x":3, "y":4}]` // 常见场景中，这个字符串更多来自于网络或其他应用传输。
let jr = JSON.parse(s) as UTSJSONObject[]
复制代码
当然，还有更简短的写法，使用HBuilderX 3.9新增的JSON的parseObject()和parseArray()方法：

let s = `{"result":true, "count":42}` // 常见场景中，这个字符串更多来自于网络或其他应用传输。
let jo = JSON.parseObject(s)

let sr = `[{"x":1, "y":2},{"x":3, "y":4}]` // 常见场景中，这个字符串更多来自于网络或其他应用传输。
let jr = JSON.parseArray(s)
复制代码
全局对象JSON，除了parse()、parseObject()、parseArray()外，还有stringify()来把json转为字符串。详见

对象字面量在js平台推导的特殊之处
js平台同时存在object和UTSJSONObject，且UTSJSONObject继承自object。而kotlin和swift没有object。

在编译为kotlin和swift时，未指定type的对象字面量必然会被推导为UTSJSONObject。

而编译为js时，处理对象字面量时会根据上下文预期的对象字面量的类型来决定是转为UTSJSONObject还是object或其他。

在无法推导对象字面量预期的类型、类型为any或者类型兼容UTSJSONObject时，对象字面量会转为UTSJSONObject。其他则会推导为object或其他需要的类型。

例如：


type Person = {
  age: number
}
function test(p: Person) {
  console.log(p)
}
test({age: 1}) // 此处的对象字面量会被转成类型Person的实例，而不是UTSJSONObject

let a = {
  age: 1
} // a为UTSJSONObject类型
let b: Person = {
  age: 1
} // b为Person的实例
let c = {
  age: 1
} as Person // c为Person的实例
复制代码
在js平台，使用三方js包还需注意，如果没有三方包的类型信息，所有三方包的导出都会按照any处理。

以lodash这个npm库为例，它并没有兼容UTSJSONObject这个类型，内部会根据入参的原型链判断是不是object。下述代码在存在@types/lodash时和不存在@types/lodash时表现有差异。

import { merge } from 'lodash'
merge(
  {a: 1},
  {b: 2}
)
复制代码
存在@types/lodash时，因为可根据上下文准确推导，merge的参数类型并非any或者兼容UTSJSONObject的类型，所以两个对象字面量均不会被转为UTSJSONObject。

当不存在@types/lodash时，merge方法为any类型，其参数也是any类型，两个对象字面量均会被转为UTSJSONObject。

如果希望某个对象字面量不会被转为UTSJSONObject，那么不要使用自动推断，而是显式为其指定类型，写法如下：

两个对象字面量均不会被转为UTSJSONObject，注意Record<string, any>写法仅web端支持

import { merge } from 'lodash'
merge(
  {a: 1} as Record<string, any>,
  {b: 2} as Record<string, any>
)
复制代码
在js平台，UTSJSONObject和object在日常使用时差别不大，但有如下几点差别：

UTSJSONObject多了一批通过keypath操作数据的方法 见下
UTSJSONObject继承自object，原型链位置不同
instanceof返回值不同
验证类型
let jo = {
	x: 1,
	y: 2
}
console.log(typeof jo); //返回 object
console.log(jo instanceof UTSJSONObject); //返回 true
复制代码
访问 UTSJSONObject 中的属性数据
let rect = {
	x: 20,
	y: 12,
	size: {
		width: 80,
		height: 80
	}
}
复制代码
以上述 rect 为例，访问 UTSJSONObject 中的数据，有如下3种方式：

1. . 操作符
即 `rect.x`、`rect.size.width`。

这种写法比较简单，和js习惯一致，但在 UTS 中限制较多。它的使用有如下前提：
- 仅限于web和Android，在iOS上swift不支持`.`操作符。
- 在Android上也只支持字面量定义json（因为类型可推导）。如果是`JSON.parse()`转换 或者 动态赋值的，则不能使用。
复制代码
2. [""] 下标
即 `rect["x"]`。

这是一种通用的方式，不管通过字面量定义的 UTSJSONObject，还是通过 `JSON.parse()`，不管是 web、Android、iOS 哪个平台，都可以使用下标方式访问 UTSJSONObject 属性。

但下标返回的数据，类型是any，想继续使用需要`as`为具体类型。

尤其是有子对象时，需要 `as` 后才能继续访问下一层数据。
复制代码
let rect = {
	x: 20,
	y: 12,
	size: {
		width: 80,
		height: 80
	},
	border: [
		{color:"red",witdh:1},
		{color:"white",witdh:1},
		{color:"red",witdh:1},
		{color:"white",witdh:1}
	]
}

console.log(rect.x) //20 但iOS无法使用.操作符
console.log(rect["x"]) //20 但类型其实未知，如果继续操作则需要as

console.log(rect.size.width) //80 但iOS无法使用.操作符
console.log((rect["size"] as UTSJSONObject)["width"]) //80 使用as后需要整体用()括起来再继续使用下标[]

// 如果存在嵌套，那么需要先把第一层转成 UTSJSONObject 或数组，之后再用下标访问下一层

console.log(rect.border[0].color); //报错，一旦使用了下标访问数组，后面就无法使用.操作符了
console.log(rect.border[0]["color"]); // red 但iOS无法使用.操作符
console.log((rect["border"] as UTSJSONObject[])[0]["color"]); // red

复制代码
如果是 JSON.parse 解析的数据，只能通过下标访问，无法使用.操作符。因为.操作符的成立建立在编译器可确定类型的前提，字面量直接赋值可识别类型，JSON.parse无法识别类型。

let listData = JSON.parse(`{"result":true, "count":42}`) as UTSJSONObject
let listArr = JSON.parse(`[{ id: 1, title: "第一组" },{ id: 2, title: "第二组" }]`) as UTSJSONObject[]
console.log(listData["count"]); //42
console.log(listArr[0]["title"]); //第一组
复制代码
多层级下标访问时需要使用 as 转换为 UTSJSONObject 或 UTSJSONObject[]

var j = {
	"subobj":{
		"abc": 1
	}
}
console.log((j['subobj'] as UTSJSONObject)['abc']);
复制代码
3. 通过 keyPath 访问 UTSJSONObject 数据
HBuilderX 3.9+，UTSJSONObject 提供了另外一种属性访问方式: keyPath。如果你了解 XPath、JSONPath 的话，这个概念类似。

keypath是把.操作符作为一个字符串传入了UTSJSONObject的一个方法中，比如utsObj.getString("address.detailInfo.street")

相对于受限制.和需要经常as的下标，更推荐使用keyPath方式来操作UTSJSONObject。

以下面的 UTSJSONObject 为例

let utsObj = {
	"username": "zhangsan",
	"age": 12,
	"isStudent":false,
	"address": {
		"countyCode": "86",
		"province": "beijing",
		"detailInfo": {
			"street": "the wall street",
			"buildingNo": "5"
		}
	}
}
复制代码
我们可以通过 getString/getNumber/getBoolean/getJSON/getAny 等函数获得指定类型的属性，如果属性不存在，则返回null

console.log(utsObj.getString("username")) // 打印结果:zhangsan
console.log(utsObj.getNumber("age")) // 打印结果:12
console.log(utsObj.getJSON("address")) // 打印结果:[object]
console.log(utsObj.getBoolean("isStudent")) // 打印结果:false
console.log(utsObj.getString("一个不存在属性")) // 打印结果:null
复制代码
需要特别注意的是：属性名 和 属性类型，都要正确，否则不会返回对应的属性结果

console.log(utsObj.getNumber("age")) // 打印结果:12
console.log(utsObj.getNumber("agee")) // 名字不对，打印结果:null
console.log(utsObj.getString("age")) // 类型不对，打印结果:null
复制代码
keypath的一大优势就是可以深入数据层级，如下：

console.log(utsObj.getString("address.detailInfo.street")) // 结果：the wall street
复制代码
如果数据里包括数组、多维数组，也可以穿透下去获取数据，如下：

let obj = {
	"data": [{
			"a": "1"
		}, {
			"a": 2
		},
		[{
			"b": true
		}, {
			"b": "test"
		}],
		[1, 2, 3]
	]
}

console.log(obj.getString('data[0].a')) // 打印结果:1
console.log(obj.getNumber('data[1].a')) // 打印结果:2
console.log(obj.getBoolean('data[2][0].b')) // 打印结果:true
console.log(obj.getJSON('data[2][1]')) // 打印结果:{"b":"test"}
console.log(obj.getArray('data[3]')) // 打印结果:[1, 2, 3]
console.log(obj.getAny('data[1].a')) // 打印结果:2

复制代码
在所有的getXXX函数中 getAny 是一个特殊的存在，它可以获取属性，而不要求限制类型，他的返回值是 any 类型。

需要注意的是 在强类型语言中使用 any 是一件危险的事情，如果你需要使用getAny请确保你已经充分了解了可能遇到的问题。

// 如果我们不确定属性类型，可以使用`getAny`来进行获取
console.log(utsObj.getAny("age") as Number)
// 如果我们不确定属性类型，可以使用`getAny`来进行获取
console.log(utsObj.getAny("address") as UTSJSONObject)
复制代码
除了直接使用UTSJSONObject外，在 uts 中使用json数据还有2种方式：

UTSJSONObject.toMap() 转为Map对象 见上
把json字符串或对象字面量通过type转为自定义类型，这是ts里经常使用的方式 见下
特别注意: UTSJSONObject 暂不支持通过 delete 删除属性 目前仅在 iOS 平台上，通过将属性值设为 null（例如：student["age"] = null ）可以将该属性删除。

更多API
UTSJSONObject对象还有很多API，详见

type自定义类型
type是关键字，用于给一个类型起别名，方便在其他地方使用。

下面是一个简单的示例，给number类型起个别名tn，在定义变量i时，可以用:tn。

type tn = number
let i:tn = 0  // 等同于 let i:number = 0
复制代码
注意：基本类型的type重命名，在uvue中只支持写在script的export default {}外。

上述简单的例子在实际开发中没有意义。

在 ts 中常见的用途是给联合类型命名，方便后续简化使用。但 uts 在app端不支持联合类型，在 uts 中用的比较多的场景是：

给函数类型定义别名，以便在共享给其他模块使用。
用于json对象的定义，在编译为kotlin和swift时，会编译为class。
本章节重点讲解如何把json数据转为type。

把json对象转为type
在 uts 中，type最常见的用途是把json数据转为自定义类型。也就是为json数据提供了一个类型描述。这样json数据就可以继续使用.操作符了。

type PersonType = {
	id : number,
	name : string,
	age : number
}
复制代码
上述代码，定义了一个 PersonType 类型。变量一旦被赋予PersonType类型，就意味着变量是一个对象，包含3个属性，number类型的id属性、string类型的name属性、number类型的age属性。

然后我们给变量person赋予上面定义的PersonType类型：

let person : PersonType = { id: 1, name: "zhangsan", age: 18 }
console.log(person.name) //返回zhangsan
复制代码
可以看到，变量person，和js里使用json没有任何区别了。支持.操作符，无需下标，可跨平台。

与UTSJSONObject相比，虽然多了一个type定义的过程，但使用体验更流畅，也可以在ide中自由的.，并且得到良好的提示。

所以在ts开发中，很多开发者就会把缺少类型的json数据变成一个type或interface，继续像js里那样使用这个json数据。

但在uts中，由于interface的概念在kotlin和swift有其他用途，所以uts中推荐开发者把json转成一个type，而不是interface。

把json数组转为type
上面的例子中，数据是json对象，下面再来定义一个json数组。

let personList = [
	{ id: 1, name: "zhangsan", age: 18 },
	{ id: 2, name: "lisi", age: 16 },
] as PersonType[]
console.log(personList[0].name); //返回zhangsan
复制代码
把一个json数组 as 成自定义类型的数组，就可以像在js中那样随便使用json数据了。

null的处理
但是需要注意，json数据可能不规范，有些属性缺失，此时就需要在定义type时设可为空：

type PersonType = {
	id : number,
	name : string,
	age : number | null, //属性可为null
	enable ?: boolean // 属性可为null
}

let personList = [
	{ id: 1, name: "zhangsan", age: 18 },
	{ id: 2, name: "lisi" }, // age数据为空
] as PersonType[]

console.log(personList[1].age); //null
复制代码
嵌套
json对象往往有嵌套，即子对象。比如

{
	"id": 1,
	"name": "zhangsan",
	"age": 18,
	"address": {
		"city": "beijing",
		"street": "dazhongsi road"
	}
}
复制代码
如果要给Person类型再加一个子对象 address，下面又有2个属性 city、street，该怎么写呢？ 因为冒号已经用于类型定义，子对象就没有声明类型的地方了。

type PersonType = {
	id: number,
	name: string,
	age: number,
		address: { // 错误，这里的address需要单独声明类型
		city : string,
		street : string
	}
}
复制代码
要解决这个问题，需要把 address 作为一个单独的类型来定义。

type PersonAddressType = {
	city: string,
	street: string
}
type PersonType = {
	id: number,
	name: string,
	age: number,
	address: PersonAddressType // 把address定义为PersonAddress类型
}
复制代码
这里还要注意代码的执行顺序，执行 address: PersonAddress 时，这个类型必须已经被定义过。所以要被引用的类型必须定义在前面，后面才能使用这个类型。

那么嵌套的完整写法例子：

type PersonAddressType = {
	city: string,
	street: string
}
type PersonType = {
	id: number,
	name: string,
	age: number,
	address: PersonAddressType // 把address定义为PersonAddress类型
}
let person = {
	id: 1,
	name: "zhangsan",
	age: 18,
	address: {
		city: "beijing",
		street: "dazhongsi road"
	}
} as PersonType
console.log(person.address.city) //beijing
复制代码
注意，在HBuilderX 3.9以前，有子对象的对象字面量或UTSJSONObject，无法直接被 as 为有嵌套的type，也需要对子对象进行 as 。

let person = {
	id: 1,
	name: "zhangsan",
	age: 18,
	address: {
		city: "beijing",
		street: "dazhongsi road"
	} as PersonAddressType // HBuilderX 3.9前需对子对象单独 as
} as PersonType
复制代码
通过JSON.parse转type
HBuilderX 3.9+，支持JSON.parse传入泛型，把一段字符串解析为type。

type PersonType = {
	id: number,
	name: string
}
let jsonString:string = `{
	"id": 1,
	"name": "zhangsan"
}` // 注意属性必须使用引号包围，否则parse会解析失败返回null

let person = JSON.parse<PersonType>(jsonString) //这是一种泛型的写法，在方法名后面使用<>传入PersonType类型，就可以返回传入的类型。
console.log(person?.name);  // 返回zhangsan。由于person可能为null，parse可能失败，所以需要通过?.来访问属性
复制代码
注意上述代码中，如果let person时，想使用冒号定义类型，需要考虑parse失败的情况，要这么写：

type PersonType = {
	id: number,
	name: string
}
let person:PersonType|null = JSON.parse<PersonType>(jsonString)
console.log(person?.name); // 返回zhangsan
复制代码
或者如果你确保jsonString的值一定是合法的、parse一定可以成功，那么也可以在定义的末尾!号断言，告诉编译器肯定没有问题，那么此后就可以不使用?.了

type PersonType = {
	id: number,
	name: string
}
let person:PersonType = JSON.parse<PersonType>(jsonString)!
console.log(person.name); // 返回zhangsan
复制代码
使用!断言，是强制编译器信任开发者的写法，编译器放过后，在运行期一旦person为null，调用person.name就会崩溃。而使用person?.name则不会崩溃，只会返回null。

敏感字和符号
在定义Type时键名必须符合变量命名规则（如第一个字符不能数字，不能包含空格或运算符，不能使用语言保留的关键字等），

如果json字符串中的键名不符合变量命名规则，比如有个key的名字叫"a+b"，这种json转type会失败。

解决方案是，添加注释@JSONFIELD定义键名转换规则，才能通过JSON.parse解析转type。

type ExampleType = {
  /$string>
   @JSONFIELD "a+b"
   JSON.parse时会将json字符中的键名"a+b"转换为type类型的"ab"属性
   JSON.stringify时会将type类型的"ab"属性转换为json字符串中的"a+b"键名
  /
  ab: string
}
复制代码
以上示例定义的 ExampleType 类型，在 ab: string 声明时添加注释 @JSONFIELD "a+b"，表示：

JSON.parse 时会将json字符中的键名"a+b"转换为ExampleType类型的"ab"属性；
JSON.stringify 时会将ExampleType类型的"ab"属性转换为json字符串中的"a+b"键名。
推荐的转换规则如下：

将不合法的字符（如空格、运算符等）转换为下划线“”，如“a+b”转换为“ab”
将保留关键词（如class、enum等）转换时，在前面添加下划线，如“class”转换为“class”
如果转换后的名称已存在，在后面添加下划线避免冲突，如同时存在“a+b”和“a-b”，分别转换为ab和ab
以下举例json字符串 {"a+b":"addition value","a-b":"subtraction value","class":"classification value"}，应该如何定义 type 才能使用 JSON.parse 转换

type SpecialType = {
  /
   @JSONFIELD "a+b"
  /
  ab: string
  /$string>
    @JSONFIELD "a-b"
   /
  ab: string
  /
    @JSONFIELD "class"
   /
  class: string
}

//json字符串转换type对象
let t:SpecialType = JSON.parse<SpecialType>('{"a+b":"addition value","a-b":"subtraction value","class":"classification value"}');
console.log(t.ab)		//输出: addition value
console.log(t.ab)		//输出: subtraction value
console.log(t.class)	//输出: classification value

//type对象转换json字符串
let t:SpecialType = {
	ab: 'value 1',
	ab: 'value 2',
	class: 'value 3'
}
console.log(JSON.stringify(t))	//输出: {"a+b":"value 1","a-b":"value 2","class":"value 3"}
复制代码
以上@JSONFIELD注释规则需要HBuilderX3.9.0+版本支持

json转type工具
如果json数据属性较多、嵌套较多、还涉及转义，那么为json数据编写type类型定义，也是一件繁琐的事情。

HBuilderX 3.9起内置了一个json转type工具，在json编辑器中选择一段内容点右键，选择json转type，即可根据json数据内容自动推导生成type定义，如果json内容涉及转义，工具也会自动转义。



把右侧生成的type复制到代码里即可，那个IRootType的名字自己按需修改。

注意json数据的属性名称需要引号包围。

如果找不到这个右键菜单，检查是否是右下角是否显示JSON编辑器；检查是否安装了uts/uni-app x相关插件，一般真机运行时会自动安装相关插件。

为vue的data中的json定义类型
uvue文件中data中的json数据也涉及类型定义。此时注意：type定义必须放在export default {}前面。

<script>
	type PersonType = {
		id: number,
		name: string
	}
	export default {
		data() {
			return {
				personList: [
					{ id: 1, name: "zhangsan" },
					{ id: 2, name: "lisi" },
				] as PersonType[],
			}
		},
		onLoad() {
			console.log(this.personList[0].name); //zhangsan
		}
	}
</script>
复制代码
大多数情况下，data里的json数据是空的，联网从服务器取到一段json字符串，然后再赋值并转type。

由于篇幅较长，示例另见：request教程

type 类型的遍历
HBuilderX3.9+

uts 为自定义 type 类型提供了迭代器，可以使用 for-in 遍历出 type 类型中的所有属性名

let person : PersonType = { id: 1, name: "zhangsan", age: 18 }

for (let key in person) {
	console.log(key) // 输出 "id", "name", "age"
}

复制代码
type 类型的下标访问
HBuilderX3.9+

uts 为自定义 type 类型提供了下标操作，在适当的时机，可以使用下标的方式来读取或者修改 type 类型的属性值。

注意：由于通过下标修改属性值，编译阶段不会对下标操作的key值进行校验，所以可能会存在运行期代码失效的情况。为了代码安全，除非在必要时才进行通过下标修改属性的操作。
let person : PersonType = { id: 1, name: "zhangsan", age: 18 }

console.log(person["id"])  //1
obj["age"] = 25
console.log(obj["age"]) //25
console.log(obj.age) //25

复制代码
undefined
js中的 undefined类型表示变量被定义，但是未赋值或初始化。

uts 仅在编译为js时支持 undefined，在编译为kotlin和swift时不支持 undefined。即Android平台不允许变量未赋值。每个有类型的变量都需要初始化或赋值。

考虑多端，应避免使用undefined。

开发时类型
uts有运行时类型和开发时类型的概念区别。

开发时类型，指为了在开发期间ide可以更好的进行代码提示和校验，但在编译后这些类型会被擦除，变成运行时类型。

目前支持的开发时类型有：

相同运行时类型的字面量联合类型
字面量联合类型，指相同类型的数字或字符串字面量，把多个字面量值以或的方式赋值给一个类型。

它常常用于在开发阶段的值域约束。

比如以下例子里，a1的值域只能是302或404或500，而b1的值域只能是"get"或"post"。

// 注意不要写在uvue页面的export default里面
type a = 302 | 404 | 500
let a1 : a = 404 // 运行时类型是number
console.log(a1);

type b = "get" | "post"
let b1 : b = "get" // 运行时类型是string
console.log(b1);
if (b1=="") {} //光标在双引号中间时，代码助手会提示get和post这2个候选
b1=="get1" // 当为b1赋值不在值域范围的新值时，ide会报红
复制代码
相同字面量联合类型，在方法的参数值域定义里很常见。

但有几个注意：

这些字面量必须是一个类型，或者统一是数字，或者统一是字符串。
字面量联合类型只是开发时类型，在运行时，类型会变为number或string。
特殊值域string
很多数据，虽然类型是字符串，但其实有特殊的值域范围。

上一节提到的字符串字面量联合类型，其实是一种枚举型的值域范围约束。

但很多值域无法通过枚举表达。
比如string.ColorString，代表一个合法的颜色字符串，"red"、"#000"，这些是它的合法值域。
再比如string.IDString代表页面上合法的组件的id属性值清单，string.ImageURIString则代表工程下合法的图片路径清单。

HBuilder支持给变量定义特殊值域string类型，这些类型在HBuilder里都可以得到更好的代码提示和语法校验。

当然这也是开发时类型，在运行时，这些类型会统一抹平为string类型。

名称	描述
string.AttrString	元素上的属性
string.AttrValueString	元素上某个属性的值
string.ClassString	元素全局属性class的值
string.IDString	元素全局属性id的值
string.HTMLEventString	元素上的事件
string.ColorString	CSS颜色的值
string.RequireCommonString	提示common模块 以及js文件路径
string.VueI18NKeyString	国际化翻译的key值
string.VueDataString	vue默认参数data中的属性名称
string.VueRefString	vue组件中ref属性的值
string.VuexDispatchString	vuex 中 actions 的名称
string.VuexCommitString	vuex 中 mutations 的名称
string.PageURIString	vue, nvue, uvue页面文件的文件路径(根据项目自动匹配)
string.NPageURIString	nvue页面文件的文件路径
string.UPageURIString	uvue页面文件的文件路径, 仅在uniappx中生效
string.VideoIdString	video 组件的 id, 仅在uniappx中生效
string.WebviewIdString	web-view 组件的 id, 仅在uniappx中生效
string.ParentFieldString	uniCloud db schema中parentKey的值
string.SchemaFieldString	uniCloud db schema中required数组的值
string.ValidateFunctionString	uniCloud db schema中validateFunction的值
string.CloudFunctionString	uniCloud 云函数名
string.CloudObjectString	uniCloud 云对象名
string.DBCollectionString	uniCloud 数据库集合的名称
string.DBFieldString	uniCloud 数据库字段名称
string.JQLString	uniCloud 数据库要操作的集合, 要查询的字段
string.cssPropertyString	CSS属性的名称
string.cssPropertyValueString	CSS某个属性的值
string.cssSelectorString	CSS选择器的名称
string.URIString	任意文件的文件路径
string.CSSURIString	css文件的文件路径(后缀为.css的文件路径)
string.JSURIString	js文件的文件路径(后缀为.js的文件路径)
string.HTMLURIString	html文件的文件路径(后缀为.html的文件路径)
string.MarkdownURIString	markdown文件的文件路径(后缀为.md的文件路径)
string.ScriptImportURIString	js, ts, uts引用文件或模块的文件路径(支持vue,nvue,uvue中script标签内容), 例: import xxx from 'xxx'
string.CssImportURIString	css文件可以引用的文件的文件路径, 后缀为\[".css"]的文件路径 例: @import url('xxx.css')`
string.ScssImportURIString	scss文件可以引用的文件的文件路径, 后缀为\[".scss", ".css"]的文件路径, 例: @import 'xxx.scss'`
string.LessImportURIString	less文件可以引用的文件的文件路径, 后缀为\[".less", ".css"]的文件路径, 例: @import 'xxx.less'`
string.FontURIString	字体文件的文件路径
string.ImageURIString	图片文件的文件路径
string.AudioURIString	音频文件的文件路径
string.VideoURIString	视频文件的文件路径
联合类型
由于kotlin和swift限制，uts在App平台支持的联合类型有限：

支持 |null （即可为空）
字面量联合类型
编译为非js时，不支持其他方式的联合类型。

在编译为js时开发者可以使用其他联合类型。但考虑到多端兼容，应尽量避免。

很多时候库作者希望调用库的人传入数字或字符串都可以，比如传入1或"1px"都支持，此时设置类型为string就行，传入的数字也以字符串的方式接收，然后再使用parseInt等方法转换为数字即可。

类型保留和擦除
uts内置的类型，包括浏览器、Android、iOS内置的类型，在编译后不会擦除，在运行时仍可使用。

开发者自定义的类型，如通过类型字面量定义的type，在编译后会转为class。

开发时类型会在编译后被擦除。运行时无法通过 typeof 或 instanceof 获取。

注意

编译到js时联合类型等复杂类型在编译后会被擦除

uniappx

2024年8月9日 01:33:01

UTS 介绍
uts 是什么

uts，全称 uni type script，是一门跨平台的、高性能的、强类型的现代编程语言。

它可以被编译为不同平台的编程语言，如：

web平台/小程序，编译为JavaScript
Android平台，编译为Kotlin
iOS平台，编译Swift
鸿蒙OS平台，编译为ArkTS（HBuilderX 4.22+）
uts 采用了与 ts 基本一致的语法规范，支持绝大部分 ES6 API。

但为了跨端，uts进行了一些约束和特定平台的增补。

过去在js引擎下运行支持的语法，大部分在uts的处理下也可以平滑的在kotlin和swift中使用。但有一些无法抹平，需要使用条件编译。

和uni-app的条件编译类似，uts也支持条件编译。写在条件编译里的，可以调用平台特有的扩展语法。

用途和关系
uts是一门语言。也仅是一门语言，不包含ui框架。

uvue是DCloud提供的跨平台的、基于uts的、使用vue方式的ui框架。

uts相当于js，uvue相当于html和css。它们类似于v8和webkit的关系，或者类似于dart和flutter的关系。

uts这门语言，有2个用途：

开发uni-app 和 uni-app x 的原生扩展插件：因为uts可以调用所有原生能力。
uts和uvue一起组合，开发原生级的项目，也就是 uni-app x 项目
从HBuilderX 3.9起，支持uni-app x项目。详见uni-app x

也就是说，uts可以在uni-app中使用，也可以在uni-app x中使用。

在uni-app中，主编程语言是js。uts可以开发原生插件，包括API插件和组件插件。
在uni-app x中，主编程语言是uts。不管是应用逻辑还是扩展插件，均使用uts编程。仅在Web平台和iOS的js驱动模式下可以使用js。
如果插件作者，开发了uts插件，也可以同时在uni-app和uni-app x中使用。比如这2个uts插件：

电量：https://ext.dcloud.net.cn/plugin?id=9295
lottie组件：https://ext.dcloud.net.cn/plugin?id=10674
这2个uts插件，一个是api插件，一个是组件插件，它们同时兼容uni-app和uni-app x。

可以通过表格更清晰的了解uts语言在uni-app和uni-app x下的编译关系。

uni-app	uni-app x
普通页面和脚本	uts插件	普通页面和脚本	uts插件
Web和小程序	JS	JS	JS	JS
Android	JS	Kotlin	Kotlin	Kotlin
iOS	JS	Swift	JS(JS驱动时)	Swift
HarmonyNext	JS	ArkTS	x	x
这里的概念解释是：

uts插件，指unimodules目录下utssdk目录下的代码
除uts插件外，其他都属于 普通页面和脚本，包含vue、nvue、uvue等页面及单独的uts文件
在uni-app x的iOS平台，目前普通页面和脚本是编译为js的，而不是Swift。 这个策略主要是为了解决windows电脑开发uni-app x的问题。它并不影响性能，uni-app x的iOS通过优化解决了js性能问题。同时未来也会提供js驱动和Swift驱动双选
除了查阅表格，也可以简单的记3个原则：

所有的uts插件，都会编译为原生语言
web和小程序上，原生语言就是js
App上，目前仅uni-app x的Android平台会编译为原生语言，其他都编译为js
本文是 uts 的基本语法介绍。

想了解 uni-app 下如何开发 uts插件，另见文档https://doc.dcloud.net.cn/uni-app-x/plugin/uts-plugin.html
想了解 uni-app x，另见文档https://doc.dcloud.net.cn/uni-app-x/
类型声明
js是无类型的，TypeScript 的 type 就是类型的意思，给js加上了类型。它的类型定义方式是在变量名后面通过加冒号和类型来进行定义。

uts 中声明变量可以用 let 或 const，详见下。

变量定义（let）
声明一个可重新赋值的变量。语法 let [变量名] : [类型] = 值;。

相当于 TypeScript 中的 let、kotlin 中的 var、swift 中的 var。

let str :string = "hello"; // 声明一个字符串变量
str = "hello world"; // 重新赋值
复制代码
类型除了 string 之外，更多类型见数据类型

常量定义（const）
声明一个只读常量，只能为其赋值一次。语法 const [变量名] : [类型] = 值;。

相当于 TypeScript 中的 const、kotlin 中的 val、swift 中的 let。

const str :string = "hello"; // 声明一个字符串常量
str = "hello world"; // 报错，不允许重新赋值
复制代码
注意事项：

当前 uts 并未限制使用 var 来声明变量，但除非你知道你在做什么，否则不要轻易使用它，因为有不同平台差异：
编译至 JavaScript 平台时，等同于 JavaScript 平台的 var 。存在变量提升现象，具体参考 var和let的区别
编译至 Kotlin 平台时，等同于 Kotlin 平台的 var（允许重新赋值）
swift 中 let 是定义常量，而 uts 和 ts 中，let 是定义变量。注意勿混淆。
类型定义的冒号，左右可以有一个空格，也可以没有空格。let str:string 和 let str : string 和 let str :string 和 let str: string 都是合法的。
变量命名规则
在 uts 中，使用变量名需要遵守一定的规则。

变量名称可以包含数字和字母。
除了下划线  外，不能包含其他特殊字符，包括空格。
变量名不能以数字开头。
注意：与 TypeScript 不同的是，uts 不允许以 $ 开头命名变量

方法参数及返回值类型定义
方法的参数、返回值，也通过冒号定义。

如下示例，方法test，有一个参数score，是number类型，方法返回值类型为boolean类型。

function test(score: number): boolean {
	return (score>=60)
}
test(61) // 返回true
复制代码
方法无返回值时，使用:void。

function add(x :string, y :string) :void {
    let z :string = x + " " + y
	console.log(z)
	// 不需要return
}
复制代码
函数另有详细文档，详见：函数

vue data类型定义
vue 选项式开发时，冒号被用于赋值，无法通过let、const和冒号来定义data数据的类型。

此时可以使用字面量赋值自动推导；也可以使用 as 关键字来显式声明类型。

<script lang="uts">
	export default {
		data() {
			const date = new Date()
			return {
				s1 : "abc", // 根据字面量推导为string
				n1 : 0 as number, // 这里其实可以根据字面量自动推导，as number写不写都行
				n2, // 不合法，必须指定类型
				n3 as number, // 不合法，uts不支持undefined，必须通过冒号初始化赋值，哪怕赋值为null，见下
				n4 : null as number | null // 合法。定义为可为null的数字，初始值是null，但在使用n4前必须为其赋值数字。（number | null）是一个或的写法，前后顺序没有关系。uts的联合类型只支持 |null 。
				year: date.getFullYear() as number, // 在data里，目前无法通过变量类型推导data项的类型，需使用 as 显式声明类型为number
			}
		}
	}
</script>
复制代码
上述示例仅在 uni-app x 的uvue页面生效。老版uni-app，即js引擎版，不支持在页面里写uts代码，只支持在uts插件里写uts代码。

类型自动推导
现代语言（ts、kotlin、swift），都具备自动识别字面量，进行类型推导的功能。

即：如果开发者声明变量的同时，进行了初始化赋值。那么编译器可以根据赋值的字面量，自动推导出变量类型，不必开发者显式声明。

在定义变量时如果直接赋值字面量，而不使用冒号声明类型，也可以合法运行。

如下2种写法都是合法的，两个变量都是string类型：

// 以下每组写法是等价的
let s1 = "hello" // 根据字面量 "hello"，自动推导为string类型
let s2 : string = "hello"
let s3 : string
s3 = "hello"

let b1 = true // 根据字面量 true，自动推导为boolean类型
let b2 : boolean = true

// 以上为字符串和布尔的字面量类型自动推导，数字和数组也支持字面量类型推导，但规则比较复杂，需另见文档

复制代码
在HBuilderX 3.9以前， uts 未对字面量赋值类型推导做统一处理，编译到 kotlin 和 swift 时，由这2个语言自行做类型推导。

但 kotlin 和 swift 的自动推导，在某些地方有细节差异。尤其是数字字面量和数组字面量。在这2个场景下，建议显式声明类型，不使用自动推导。

// 显式声明数字和数组类型
let n1:number = 1
let n2 = 1 as number
let n3:Int = 1
let a1:Array<string> = ["uni-app", "uniCloud", "HBuilder"]
let a1:Array<number> = [1,2,3,4]
复制代码
HBuilderX 3.9+， uts 统一了字面量自动类型推导。

建议插件作者，除了boolean和string外，其他包括数字和数组在内的类型，尽量不使用字面量自动类型推导，而是显式声明类型。避免 uts 统一自动类型推导时引发的向下兼容问题。

类型判断
判断类型，有好几种方案：typeof、instanceof、isArray。

使用 typeof 可以判断布尔值、数字、字符串、函数。

typeof(true) == "boolean"
typeof("abc") == "string"

let n1 : number = 1
typeof(n1) == "number"
复制代码
但如果使用 typeof 验证数组，会发现返回的类型值是"object"，这与浏览器是相同的逻辑。

如果想验证数组类型，需要使用如下方法：

const a1 = ["uni-app", "uniCloud", "HBuilder"]
console.log(Array.isArray(a1)) // 返回true
console.log(a1 instanceof Array) // 返回true
复制代码
instanceof，除了验证数组，还可以验证类型，但注意它返回的不是具体类型，而是根据入参的一个boolean值。

let myDate = new Date();
console.log(myDate instanceof Date) // 返回true

uni.request({
	url: 'https://abc',
	success: (data) => {
		if (data.statusCode == 200) {
			const result = data.data as UTSJSONObject
			console.log(result instanceof UTSJSONObject) //返回true
		}
	},
	fail: () => {
		console.log('fail');
	}
});
复制代码
详见：typeof、instanceof

安全调用
js没有类型检查。而uts和ts都有严格的类型检查。

对于可为null的类型，调用时需要加问号，否则编译器会报错。

const s: string | null = null // s为一个可为null的字符串
console.log(s?.length) //除非前面已经给s赋值，否则调用s的方法和属性必须加?
复制代码
安全调用有很多细节，详见null类型

代码语句的分割
uts的多个代码语句，以回车或分号分割。

多行时行尾的分号可以省略。如果写在一行，应以分号分割。

如下的代码都是合法的：

let a:number = 1 //行尾可以不加分号
let b:boolean = false; //行尾可以加分号
let c:number = 3 ; let d:number = 4 // 同行多语句需要用分号分割

THE TRAGEDY OF HAMLET, PRINCE OF DENMARK

2024年8月1日 16:34:55

//场景五，城堡更偏僻的一部分。
//进入《幽灵与哈姆雷特》。
//哈姆雷特。
你要把我带到哪里去？
//说吧，我不再往前走了。
//鬼魂。
//记住我。
//哈姆雷特。
//这就做。
//鬼魂。
//我的时刻就要到了，
//当我想要郁闷和折磨人的火焰时
//我必须自首。
//哈姆雷特。
//唉，可怜的鬼魂！
//鬼魂。
//请不要可怜我，而是要请你认真倾听
//我将要展现的东西。
//哈姆雷特。
//说吧，我一定会听到的。
//鬼魂。
//所以，当你听到的时候，你就会复仇。
//哈姆雷特。
//什么？
//鬼魂。
//我是你父亲的灵魂，
//注定要在某个时期走到深夜，
//为了在烈火中禁食的那一天，
//直到我在大自然的日子里犯下的罪恶
被烧毁并被带走。
//但我被禁止
//说出我监狱里的秘密，
//我可以用一个故事展现谁最轻描淡写的话
//愿犁碎你的灵魂，冰冻你年轻的血液，
//让你的两只眼睛像星星一样从它们的球体开始，
//你的打结和组合的锁分开了，
//每一根特别的头发都竖起
//就像焦躁的石膏上的羽毛。
//但这永恒的火焰决不能
对有血有肉的人来说。
//列表，列表，O，列表！
//如果你曾经爱过你亲爱的父亲-
//哈姆雷特。
//哦，上帝！
//鬼魂。
//为他肮脏和最不自然的谋杀报仇。
//哈姆雷特。
//谋杀！
//鬼魂。
//最肮脏的谋杀，即使是最好的谋杀也是如此；
//但这是最肮脏、奇怪和不自然的。
//哈姆雷特。
//快让我知道，我，带着翅膀飞快
//作为冥想或爱的思念
//可能会横扫我的复仇。
//鬼魂。
//我觉得你很合适；
//你应该比肥肥的杂草更迟钝吗
//在莱斯码头上自在地腐烂，
你能不能不要在这里面搅动。
//现在，哈姆雷特，听着。
//“睡在我的果园里，就是这样，
//一条蛇蜇了我；丹麦的整只耳朵都是这样
//是通过伪造的我的死亡过程
//愤愤不平；但你要知道，你这个高尚的年轻人，
//那条毒蛇刺痛了你父亲的生命
//现在戴着他的王冠。
//哈姆雷特。
//哦，我的先知灵魂！
//我的叔叔！
//鬼魂。
//唉，那个乱伦，那个掺假的野兽，
//用他机智的巫术，用叛逆的天赋，-
//啊，邪恶的智慧，有能力的恩赐
//所以为了引诱，-赢得了他可耻的欲望
//我最贤惠的女王的遗嘱。
//哦，哈姆雷特，那是多么的跌倒啊，
//离我而去，我的爱就是那种尊严
//它与誓言是齐头并进的
//我在婚姻中向她求婚，却拒绝了
//在一个天赋贫乏的可怜虫身上
对我的人来说。
//但是美德，因为它永远不会被移动，
//虽然淫荡使它变成天堂的形状；
//所以欲望，尽管链接到一个闪闪发光的天使，
//会在天堂的床上安顿下来
//并以垃圾为食。
但是太软了！
//我想我闻到了清晨的空气；
让我简明扼要地说。
//睡在我的果园里，
//我的习惯总是在下午，
//在我的安全时刻，你叔叔偷了
//在瓶子里装着被诅咒的海贝农果汁，
//在我耳朵的门廊里倾泻而出
//麻风蒸馏，其效果
//对人类的鲜血怀有如此的敌意
//它像水银一样飞快地流过
//身体的自然大门和小巷；
//它以一种突如其来的活力摆出了架势
//而凝乳，就像牛奶中急切的粪便，
稀薄而有益健康的血液。
//它也是我的；
//最瞬间的一声Tetter叫了起来
//最像拉撒尔的，有着肮脏和可恶的外壳
//我那光滑的身体。
//就这样，我睡着了，被一个兄弟的手牵着，
//生命，王冠，女王的生命，立刻传来：
//即使在我罪恶的花朵中也被切断，
//无名的，失望的，无名的；
//没有结账，但汇到了我的账户上
//我头上有很多不完美的地方。
太可怕了！
太可怕了！
//太可怕了！
//如果你有天性，就不要忍受它；
//不要让丹麦的王室之床
//奢华的沙发和该死的乱伦。
//但不管你怎么做这件事，
//不要玷污你的思想，也不要让你的灵魂有所成就。
//反对你的母亲；让她上天堂吧，
//对于她胸中的荆棘，
刺伤她。
//马上跟你说再见吧！
//萤火虫表明交配物就在附近，
//让他的无用之火黯然失色。
再见，再见，再见。
//记住我。
//[退出，]
//哈姆雷特。
啊，天堂的万军啊！
哦，地球！
//还有什么？
那我是不是该和地狱结为夫妻？
不，五！
//抱紧，我的心；
//而你，我的肌肉，不会一下子变老，
但要僵硬地撑起我。
//还记得你吗？
//唉，你这可怜的幽灵，在记忆占据一席之地的时候
在这个心烦意乱的地球上。
//还记得你吗？
//是的，根据我的记忆
//我会抹去所有琐碎的美好记录，
//所有书的锯，所有的形式，所有的压力过去了，
//在那里复制的是青春和观察力；
//只有你的诫命才能存留
//在我大脑的书本和书卷里，
与更基本的物质混合。
//是的，以上天的名义！
//啊，最邪恶的女人！
//啊，恶棍，恶棍，面带微笑的该死的恶棍！
我的桌子。
//就像我把它写下来，
//一个人可以微笑，微笑，并成为一个恶棍！
//至少我确信在丹麦可能是这样。
//[正在写，]
所以，叔叔，你来了。
//现在我要说的是；
//这是‘再见，再见，记住我’
//我发过誓不会的。
//霍雷肖和马塞卢斯。
//在里面，我的主，我的主。
//马塞卢斯。
//哈姆雷特勋爵。
//霍雷肖。
//[在里面，]上天保佑他。
//哈姆雷特。
//那就这样吧！
//马塞卢斯。
//[在，]哈罗，呵，呵，我的主人！
//哈姆雷特。
你好，呵呵，呵呵，男孩!
//来吧，鸟，来吧。
//何瑞修和马塞卢斯登场。
//马塞卢斯。
//怎么会不是呢，尊贵的大人？
//霍雷肖。
//有什么消息吗，大人？
//哈姆雷特。
//不，太棒了！
//霍雷肖。
//好的，我的主人，说出来。
//哈姆雷特。
//不，你会说出来的。
//霍雷肖。
//不是我，我的主，以天起誓。
//马塞卢斯。
//我也不知道，大人。
//哈姆雷特。
//那么你怎么说，人类的心曾经想过，--
//但你会保密吗？
//霍雷肖和马塞卢斯。
//是啊，我以天起誓，大人。
//哈姆雷特。
//在整个丹麦没有一个恶棍居住
//但他是个彻头彻尾的无赖。
//霍雷肖。
//不需要鬼魂，大人，从坟墓里出来
//告诉我们这件事。
//哈姆雷特。
//为什么，对；你就是我的权利；
//因此，在没有更多情况的情况下，
//我认为我们握手道别是合适的：
//你，就像你的生意和欲望会告诉你的，-
//因为每个人都有事业和欲望，
//尽管如此；-对我自己来说，
//你看，我要去祈祷了。
//霍雷肖。
//这些都是胡言乱语，大人。
//哈姆雷特。
//我很抱歉，他们冒犯了你，由衷地；
//是的，信仰，全心全意。
//霍雷肖。
//没有冒犯的意思，大人。
//哈姆雷特。
//是的，由圣帕特里克，但有，霍雷肖，
也有很多冒犯之处。
//在这里触摸到这一愿景，
//让我告诉你，这是一个诚实的幽灵。
//因为你想知道我们之间有什么，
不管你怎么说，你都不会。
//现在，好朋友们，
//既然你们是朋友、学者和士兵，
//给我一个差劲的要求。
//霍雷肖。
有什么不是的，大人？
//我们会的。
//哈姆雷特。
//永远不要让别人知道你今晚看到了什么。
//霍雷肖和马塞卢斯。
//大人，我们不会的。
//哈姆雷特。
//不，但发誓不会。
//霍雷肖。
//是真心的，大人，不是我。
//马塞卢斯。
//我也不是，大人，在信仰上。
//哈姆雷特。
//在我的剑上。
//马塞卢斯。
//我们已经发过誓了，大人。
//哈姆雷特。
//真的，用我的剑，真的。
//鬼魂。
//[台下哭泣，]发誓。
//哈姆雷特。
哈哈，孩子，你是这么说的吗？
//你在吗，真佩妮？
//得了吧，你听到这家伙在地窖里了。
//同意宣誓。
//霍雷肖。
//宣誓吧，大人。
//哈姆雷特。
//千万别说你见过的事。
//向我的剑发誓。
//鬼魂。
//[在下面，]发誓。
//哈姆雷特。
Hic et Ubique？
//然后我们将改变我们的立场。
//到这里来，先生们，
//再把你的手放在我的剑上。
//千万不要说你听到的这件事。
////向我的剑发誓。
鬼魂。
//[在下面，]发誓。
//哈姆雷特。
说得好，老鼹鼠！
//我能这么快地工作吗？
一个有价值的投手！
//再来一次，好朋友们。
//霍雷肖。
//没有白天和黑夜，但这是奇妙的奇怪。
//哈姆雷特。
//因此，作为一个陌生人，对它表示欢迎。
//天地间有更多的东西，荷瑞修，
比你的哲学中所梦想的要多。
//但是，来吧，
//在这里，像以前一样，永远不会，所以请宽恕你，
//我对自己的承受是多么的奇怪-
//就像我以后可能会想到的那样
//把一个滑稽的性情放在-
//你，在这种时候看到我，永远不会，
//手臂就这样裹住了，或者摇摇头，
//或者通过说出一些可疑的短语，
//就像‘好吧，我们知道’，或者‘我们可以，如果我们愿意’，
//或“如果我们列出要说的话”；或“有，如果他们可能的话”，
//或如此模棱两可的施舍，值得注意
//你对我一无所知，-这不是真的。
////所以恩典和仁慈在你最需要的时候帮助你，
//发誓。
鬼魂。
//[在下面，]发誓。
//哈姆雷特。
休息，休息，心烦意乱。
//所以，先生们，
//我用我所有的爱把我托付给你们；
//哈姆雷特是个多么可怜的人
//愿他向你表达他的爱和朋友，
只要上帝保佑，就不会缺少。
//让我们一起进去，
//还有你的手指放在嘴唇上，我祈祷。
时间错综复杂了。
//哦，被诅咒的怨恨，
//我生来就是用来纠正错误的。
//不，来吧，我们一起去吧。
[退出，]

The Wonderful Wizard of Oz

2024年8月1日 02:07:16

//第二章。
//与芒奇金兄弟的委员会。
她被一阵突然而严重的电击惊醒，如果多萝西没有躺在柔软的床上，她可能会受伤。
事实上，瓶子让她喘不过气来，想知道发生了什么事；托托把他冰冷的小鼻子放在她的脸上，沮丧地哀号着。
多萝西坐起来，注意到房子一动也不动，天也不黑，因为明亮的阳光从窗户照进来，照进了小房间。
//她从床上跳起来，托托紧随其后，跑开了门。
//小女孩惊讶地叫了一声，环顾四周，看到这些奇妙的景象，眼睛越来越大。
龙卷风把房子轻轻地放下了--作为一个龙卷风--在一个美丽得令人惊叹的国家中。
四周是一片片美丽的绿地，庄严的树木结出了丰富而甘美的果实。
各处开着一排排艳丽的鲜花，长着稀有而鲜艳的羽毛的鸟儿在树林和灌木丛中歌唱，拍打着翅膀。
//不远处是一条小溪，在绿色的河岸之间奔腾着，波光粼粼，用一种非常感激的声音低语着，感谢一个在干燥、灰色的草原上生活了这么长时间的小女孩。
当她站在那里急切地看着奇怪而美丽的景色时，她注意到一群她所见过的最奇怪的人向她走来。
他们不像她一直习惯的成年人那么大，但也不是很小。
//事实上，他们看起来和多萝西差不多高，就她的年龄来说，多萝西是一个很成熟的孩子，尽管就看起来来说，他们比她大很多岁。
三个是男人，一个是女人，所有人都穿着奇装异服。
他们戴着圆帽，帽子高出头顶一英尺，帽檐上有小铃铛，当他们移动时，铃声甜美地响着。
男人的帽子是蓝色的，小女人的帽子是白色的，她穿着一件白色的长袍，褶皱垂在肩上。
它上面散落着小星星，在阳光下像钻石一样闪闪发光。
这些人穿着蓝色的衣服，颜色和他们的帽子一样，脚上穿着一双擦得很亮的靴子，上面有一卷深蓝色的靴子。
多萝西想，这两个人的年龄和亨利叔叔差不多，因为其中两个留着胡子。
但这位小妇人无疑比她大得多。
//她满脸皱纹，头发几乎是白的，走路也很僵硬。
当这些人走近多萝西站在门口的房子时，他们停了下来，彼此窃窃私语，好像不敢再走远一点。
//但是小个子老太太走到多萝西跟前，深深地鞠躬，用甜美的声音说：
//“欢迎你，最高贵的女巫，来到梦幻之国，我们非常感谢你杀死了东方的邪恶女巫，并让我们的人民从奴役中解放出来。”
多萝西惊奇地听着这篇演讲。
那个小妇人叫她女巫，说她杀了东方坏女巫，这是什么意思呢？
//多萝西是一个无辜、无害的小女孩，她被一场龙卷风带到离家许多英里的地方；她一生中从未杀死过任何东西。
但是小妇人显然希望她回答，所以多萝西犹豫地说：“你真好，但一定是弄错了，我没有杀死任何东西。”
“不管怎么说，你的房子是这样的，”小个子老太太笑着回答，“这是一回事。”
看，“她指着房子的一角继续说。
//“她的两只脚还在一块木头下面伸出，”
多萝西看了看，吓得叫了一声。
//就在那里，就在房子所在的大横梁的角落里，有两只脚伸出，穿着银色的鞋子，脚趾尖。
“哦，天哪，哦，天哪，”多萝西惊慌失措地双手合在一起喊道。
//“房子一定是砸在她身上了，不管我们怎么办，”
//“什么也做不了，”小妇人平静地说。
//“但她是谁，”多萝西问道。
“正如我所说，她是东方的邪恶女巫，”小妇人回答说，“她把所有的蒙奇金人都束缚了很多年，让他们日夜做她的奴隶，现在他们都被释放了，感谢你的帮助。”
//“梦幻人是谁，”多萝西问道。
//“他们是生活在邪恶女巫统治的这片东方土地上的人”。
//“你是芒奇金人吗？”多萝西问道。
不，但我是他们的朋友，虽然我住在北方，但当他们看到东方女巫死了，梦境人派了一个迅速的信使来找我，我马上就来了，我是北方的女巫。
//“哦，天哪，”多萝西叫道，“你是真的女巫吗？”
//“是的，的确，”小妇人回答说，“但我是个好女巫，人民爱我，我不像统治这里的邪恶女巫那样强大，否则我应该释放人民自己。
“但我认为所有的女巫都是邪恶的，”女孩说，面对一个真正的女巫，她有点害怕。
“哦，不，这是个大错误..
在整个奥兹国只有四个女巫，其中住在北方和南方的两个都是好女巫。
我知道这是真的，因为我自己也是他们中的一员，不会错的。
//那些生活在东方和西方的人确实是邪恶的女巫；但现在你已经杀死了他们中的一人，整个奥兹国只有一个邪恶的女巫--生活在西方的那个人。
//“但是，”多萝西想了一会儿说，“艾姆阿姨告诉我，女巫们都死了--很多年以前了。”
//“谁是艾姆阿姨，”小个子老太太问道。
她是我的阿姨，住在堪萨斯州，也就是我的家乡。
北方女巫似乎想了一会儿，低着头，眼睛盯着地面。
//然后她抬起头说：我不知道堪萨斯在哪里，因为我从来没有听人提到过那个国家，但告诉我，它是一个文明的国家吗？
//“哦，是的，”多萝西回答说。
“那就是原因了.
在文明的国家里，我相信没有巫师，也没有魔术师..
但是，你看，奥兹国从来没有文明过，因为我们与世界其他地方隔绝了。
//因此，我们中间仍然有女巫和巫师。
//“谁是巫师，”多萝西问道。
“奥兹本人就是伟大的巫师，”女巫回答道，压低了声音低声说。
//“他比我们所有其他人加起来都要强大，他住在翡翠之城，”
//多萝西正要问另一个问题，但就在这时，一直默默站在一旁的梦幻人大声喊叫，指着房子的角落，邪恶女巫一直躺在那里。
//“这是什么，”小老太太问，然后看了看，笑了起来，死去的女巫的脚已经完全消失了，除了那双银鞋子，什么也没有留下。
“她太老了，”北方女巫解释说，“她很快就被太阳晒干了。”
这就是她的结局..
但是这双银色的鞋子是你的，你可以穿它们。“她弯下腰捡起鞋子，抖掉上面的灰尘，递给多萝西。
//“东方女巫为那双银色的鞋子感到骄傲，”其中一位梦幻人说，“这双鞋有某种魅力，但我们永远不知道是什么。”
多萝西把鞋子拿进屋里，放在桌子上。
//然后她又出来对芒奇金夫妇说：
//“我急于回到我的阿姨和叔叔那里，因为我相信他们会担心我的，你能帮我找到路吗？”
梦境人和女巫先是互相看了看，然后又看了看多萝西，然后摇了摇头。
//“在东方，离这里不远，”一个人说，“那里有一片大沙漠，没有人能活着越过它。”
“南方也是一样，”另一个人说，“因为我去过那里，也见过。”
//南方是奎德林人的国家，“。
“我听说，”第三个人说，“在西方也是这样。
//那个国家，Winkie家住的地方，是由西方的邪恶女巫统治的，如果你经过她的路，她会把你变成她的奴隶。
//“北方是我的家，”老太太说，“在它的边缘是环绕着这片绿野仙踪的那片大沙漠，恐怕，亲爱的，你得和我们住在一起。”
听到这话，多萝西开始抽泣起来，因为她在这么多陌生的人中间感到孤独。
她的泪水似乎使心地善良的梦境人感到难过，因为他们立刻拿出手帕，也开始哭泣。
//至于那个矮小的老太太，她摘下帽子，在鼻尖上平衡了一下，一边庄严地数着“一、二、三”，帽子立刻变成了一块石板，上面写着白色的大粉笔记号。
//“让多萝西去翡翠之城”
小老太太从鼻子上取下石板，读完上面的字，问道：“亲爱的，你叫多萝西吗？”
//“是的，”孩子回答说，抬起头擦干眼泪。
//“那么你必须去翡翠之城，也许奥兹会帮你，”
//“这座城市在哪里，”多萝西问道。
//“它正好位于这个国家的中心，由我告诉过你的大巫师奥兹统治着，”
//“他是个好人吗？”女孩焦急地问道。
//“他是个好巫师，我不知道他是不是人，因为我从来没见过他。”
//“我怎么才能到那里，”多萝西问道。
//“你必须步行，这是一段很长的旅程，穿过一个它有时是令人愉快的，有时是黑暗和可怕的，然而，我会用我所知道的所有魔法来保护你免受伤害。
//“你不和我一起去吗？”女孩恳求道，她已经开始把这个小个子老太太当作她唯一的朋友了。
//“不，我不能那样做，”她回答说，“但我会给你我的吻，没有人敢伤害一个被北方女巫吻过的人。”
她走近多萝西，轻轻吻了一下她的额头。
//她的嘴唇接触女孩的地方留下了一个圆形的闪闪发光的印记，多萝西很快就发现了。
“通往翡翠城的路是用黄砖铺成的，”女巫说，“所以你不会找不到的。”
//当你到达奥兹国时，不要害怕他，而是要讲述你的故事，并请求他帮助你。
再见，亲爱的。“
三个梦境人向她深深鞠躬，祝她旅途愉快，然后他们穿过树林离开了。
//女巫友好地向多萝西点了点头，在她的左后跟上转了三圈，然后立刻消失了，让小托托大吃一惊的是，当多萝西离开时，他在她身后大声吠叫，因为当她站在旁边时，他甚至不敢咆哮。
但多萝西知道她是个女巫，就料到她会以这种方式消失，一点也不感到惊讶。

The Wonderful Wizard of Oz

2024年8月1日 01:53:25

//第一章
//旋风
多萝西住在堪萨斯大草原的中间，和亨利叔叔和艾姆阿姨住在一起。亨利叔叔是个农民，艾姆阿姨是农民的妻子。
他们的房子很小，因为建造它的木材必须用马车运送好几英里。
有四面墙，一层地板和一个屋顶，组成了一个房间；这个房间里有一个看起来生锈的炉子，一个放盘子的橱柜，一张桌子，三四把椅子和床。
亨利叔叔和艾姆阿姨在一个角落里睡了一张大床，多萝西在另一个角落里睡了一张小床。
那里根本没有阁楼，也没有地窖--除了在地上挖了一个小洞，叫做气旋地窖，一家人可以去那里，以防出现那种强大的旋风，足以摧毁它所经过的任何建筑。
//通过地板中央的一扇活板门可以到达，从那里有一架梯子通往那个又小又暗的洞。
当多萝西站在门口环顾四周时，她什么也看不见，除了四面的灰色大草原。
没有一棵树，也没有一所房子，打破了四面八方绵延至天边的平坦的田野。
太阳把耕作的土地烤成了灰色的一团，上面有一些细小的裂缝。
甚至连草也不是绿色的，因为太阳已经把长长的叶片的顶端烧焦了，直到它们变成了同样的灰色，到处都可以看到。
//一旦房子被粉刷过，但是太阳把油漆晒得起泡，雨水把它冲走了，现在房子和其他东西一样黯淡和灰色。
当艾姆阿姨来到那里生活时，她是一个年轻漂亮的妻子。
阳光和风也改变了她。
她们夺走了她眼睛里的光芒，留下了清醒的灰色；她们夺走了她脸颊和嘴唇上的红晕，它们也是灰色的。
她又瘦又憔悴，现在再也不笑了。
//当孤儿多萝西第一次来到她身边时，艾姆阿姨被孩子的笑声吓了一跳，每当多萝西快乐的声音传到她的耳朵里，她就会尖叫，用手按住自己的心；她仍然惊讶地看着这个小女孩，她能找到什么可笑的东西。
亨利叔叔从来不笑。
他从早到晚辛苦工作，不知道喜悦是什么。
//他也是灰色的，从他的长胡子到他粗糙的靴子，他看起来严肃而庄严，很少说话。
正是托托让多萝西笑了起来，使她没有像周围的其他人一样变得灰白。
托托不是灰色的，他是一只黑色的小狗，长着丝滑的长发，黑色的小眼睛在他滑稽的小鼻子两边快乐地闪烁。
//托托整天都在玩，多萝西和他一起玩，非常爱他。
然而，今天他们没有上场比赛。
亨利叔叔坐在门口的台阶上，焦急地望着天空，天空比平时更加灰暗。
多萝西抱着托托站在门口，也望着天空。
//艾姆阿姨正在洗碗。
从遥远的北方，他们听到了风的低沉哀号，亨利叔叔和多萝西可以看到在即将到来的暴风雨到来之前，长长的草在哪里波浪般地弯曲。
//这时，空中传来一声尖锐的哨声，当他们把眼睛转向那个方向时，他们看到草地上的涟漪也是从那个方向传来的。
//突然亨利叔叔站了起来。
“艾米，龙卷风要来了，”他对妻子喊道。
//“我去照看牲畜，”然后他跑向饲养牛和马的牛棚。
艾姆阿姨放下手中的活，走到门口。
//一眼就告诉她危险就在眼前。
//“快点，多萝西，”她尖叫道，“快跑到地下室去。”
托托从多萝西的怀抱中跳出来，躲在床下，女孩开始抓住他。
艾姆阿姨被吓坏了，她推开地板上的活板门，爬下梯子，走进那个又小又黑的洞里。
多萝西终于抓住了托托，开始跟着她的阿姨。
//当她走到房间的一半时，风吹来一阵巨大的尖叫声，房子摇晃得很厉害，她突然失去了立足之地，坐在了地板上。
//然后一件奇怪的事情发生了。
房子转了两三圈，慢慢地从空中升起。
//多萝西觉得自己好像要乘气球上去了。
北风和南风在房子所在的地方相遇，使它成为飓风的确切中心。
//在气旋的中央，空气通常是静止的，但房子四周巨大的风的压力把它推得越来越高，直到它到达气旋的最顶端；它留在那里，被带到很远的地方，就像你带着羽毛一样容易。
天很黑，风在她周围呼啸而过，但多萝西发现她骑得很轻松。
//在最初的几次旋转之后，还有一次房子倾斜得很厉害，她感觉自己好像被轻轻地摇晃着，就像摇篮里的婴儿一样。
托托不喜欢这样。
//他在房间里跑来跑去，一会儿这儿，一会儿那儿，大声地叫着；但多萝西静静地坐在地板上，等着看会发生什么。
一旦托托得到了她走到开着的地板门附近，掉了进去；起初，小女孩以为她把他弄丢了。
但很快，她看到他的一只耳朵从洞里伸了出来，因为强大的空气压力让他站起来，这样他就不会掉下去了。
//她爬到洞里，抓住托托的耳朵，把他再次拖进房间，然后关上了活板门，这样就不会再发生事故了。
一小时又一小时过去了，多萝西慢慢地克服了恐惧；但她感到非常孤独，风在她周围呼啸而过，几乎成了聋子。
起初，她曾想过，当房子再次倒塌时，她会不会被撞得粉身碎骨；但随着时间的推移，没有什么可怕的事情发生，她不再担心，决心冷静地等待，看看未来会发生什么。
最后，她爬过摇晃的地板，来到她的床上，躺在床上；托托跟着她，躺在她身旁。
尽管房子摇摇晃晃，风也在呼啸，多萝西很快就闭上了眼睛，睡着了。

Murder on the Orient Express

2024年7月31日 17:46:32

//第二部分
//证据
//东方快车谋杀案
//1
//车厢点火列车员的证据
//在餐车里，一切都准备好了。
波罗和M，Bouc一起坐在桌子的一边。
医生坐在过道对面。
波罗面前的桌子上有一张伊斯坦布尔-加莱长途汽车的平面图，上面用红色墨水标记了乘客的名字。
护照和票在一边堆成一堆。
//有信纸、墨水、钢笔和铅笔。
“太好了，”波罗说。
他说：“我们可以在没有更多麻烦的情况下开启我们的调查法庭。
首先，我认为，我们应该拿到马车灯列车员的证据。
你可能对这个人有所了解。
他有什么性格？
//他是一个你信得过的人吗？“
“我可以肯定地说，我是这样说的。
皮埃尔·米歇尔受雇于该公司已有15年多了。
//他是法国人--住在加莱附近。
完全受人尊敬和诚实。
//也许，对大脑来说，这并不是特别的
波罗理解地点了点头。
//“很好，”他说，“让我们看看他，”
//皮埃尔·米歇尔已经恢复了一些信心，但他仍然非常紧张。
//“我希望先生不要认为我有任何疏忽，”他焦急地说，他的眼睛从波罗转向M，Bouc，“这是一件可怕的事情，我希望先生不要认为这件事对我有任何影响。”
在安抚了那人的恐惧之后，波罗开始发问。
他首先引出了米歇尔的名字和地址，他的服役年限，以及他在这条特殊路线上的时间长短。
这些细节他已经知道了，但例行公事的问题使他感到轻松自在。
“现在，”波罗继续说，“让我们来看看昨晚发生的事情。
//M，Ratchett上床睡觉--什么时候？“
“差不多一吃完饭，先生。
实际上在我们离开贝尔格莱德之前。
他在前一天晚上也是这样做的。
//他吃饭的时候叫我整理床铺，我照做了，
//“后来有没有人进过他的车厢？”
//“他的贴身男仆先生和那位年轻的美国先生，他的秘书，”
//“其他任何人”
“没有，先生，据我所知没有，”
//“很好，这是你最后一次见到或听说他，”
//“不，先生，您忘了，我们刚停下来不久，他就在差二十分左右按响了门铃。”
“到底发生了什么？”
//“我敲门，但他大叫，说他搞错了。”
//“用英语或法语，”
“在法语中，”
//“他到底是怎么说的？”
“我不知道该怎么办。
我爱你，我爱你，“
//“很对，”波罗说，“这就是我听到的，然后你就走了。”
“好的，先生。”
“你回到座位上了吗？”
//“不，先生，我是先去接另一个刚响的铃的，”
//“现在，米歇尔，我要问你一个重要的问题，你一点一刻在哪里，‘”我，先生？
//我坐在尽头的小座位上--面朝走廊，
“你确定吗？”
“是啊--至少--”“我走进下一辆教练，雅典的教练，和我的同事谈了谈。
//我们谈到了雪。
//那是在一点多一点的时候。
我不能确切地说。“
“然后你回来了--什么时候？”
//“我的一个铃声响了，先生--我记得--我告诉过您，是那位美国女士，她已经按了好几次了。”
“我记得，”波罗说，“在那之后，”
“在那之后，先生？
我按了门铃，给你拿了些矿泉水。
//大约半个小时后，我在另一个车厢里铺好了床--这位年轻的美国绅士。
//拉切特的秘书，“
//“你去给麦昆先生铺床时，他一个人在他的车厢里吗？”
//“15号的英国上校和他在一起，他们坐在一起聊天，”
//“上校离开麦昆先生后做了什么？”
//“他回到了自己的车厢，”
//“不，15--那离你的座位很近，不是吗？”
//“是的，先生，这是走廊尽头数的第二个车厢。”
//“他的床已经铺好了，”
//“是的，先生，这是我在他吃饭时编的，”
//“这一切是什么时候发生的？”
//“我说不准，先生，当然不能迟于两点。”
//“在那之后，”
//“在那之后，先生，我一直坐在我的座位上，直到早上，”
“你没有再坐上雅典的教练，”
“不，先生，”
//“也许你睡着了，”
//“我不这么认为，先生，火车处于停顿状态使我不能像往常那样打瞌睡，”
//“你有没有看到任何乘客在走廊里上下移动？”
男人想：“我想，有一位女士去了远处的厕所。”
“哪位女士？”
//“我不知道，先生，它在走廊的尽头，她背对着我，她穿着一件红色和服，上面有龙。”
波罗点了点头。
在那之后，
//“什么都没有，先生，直到早上，”
“你确定吗？，“
“啊，对不起--您自己，先生，打开门向外看了一会儿，”
“很好，我的朋友，”波罗说。
//“我想知道你是否还记得，顺便说一句，我被什么沉重的东西砸到我的门上吵醒了，你知道那是什么吗，”
//那个人盯着他。
“什么都没有，先生，什么都没有，我敢肯定，”
//“那样的话，我一定是得了马车，”波罗哲理地说。
//“除非，”M，Bouc插话说，“你听到隔壁隔间里有什么声音，”
波罗没有注意到这一建议。
也许他不想在马车点燃列车员之前这样做。
//让我们谈另一点，他说，假设昨晚有一名刺客上了火车，能确定他作案后不会离开火车吗？
//皮埃尔·米歇尔摇摇头。
“也不能把他藏在上面的某个地方，”
//“它被搜索得很好，”M，Bouc说。
//“放弃这个想法，我的朋友，”
“另外，”米歇尔说，“没有人能上卧铺车厢，除非我看见他们，”
“最后一站是什么时候？”
“Vincovci”
“那是什么时候的事？”
//“我们本应该在11：58离开那里，但由于天气原因，我们迟到了20分钟。”
//“可能有人是从火车的普通部分过来的，”
//“不行，先生，晚饭后，普通车厢和卧铺车厢之间的门是锁着的。”
//“是你自己在Vincovci下车的吗？”
//“是的，先生，我像往常一样下到站台上，站在阶梯旁上车，其他列车长也是这样做的。”
“前门--餐车附近的那扇门怎么样？”
//“它总是固定在里面，”
“它现在没有那么紧了，”
//这个男人看起来很惊讶，然后他的脸变得清晰起来，“毫无疑问，有一名乘客打开车门向外看雪，”
“很有可能，”波罗说。
他若有所思地在桌子上敲了一两分钟。
“先生，这不怪我，”那人胆怯地说。
波罗亲切地对他笑了笑。
//“你已经有了邪恶的机会，我的朋友，”他说。
//“啊，我记得还有一点，你说正当你敲拉切特先生的门时，另一个铃声又响了。
事实上，我亲耳听到了，这是谁的？“
//“这是德拉戈米罗夫公主夫人的钟声，她想让我叫她的女仆来，”
“你就这么做了，”
//“是的，先生。”
波罗在他面前若有所思地研究着这个计划。
然后他点了点头。
//“仅此而已，”他说，“目前，”
“谢谢你，先生。”
那人站了起来。
他看着M，布克。
“别难过，”后者和蔼地说，“我看不出你有什么疏忽，”
皮埃尔·米歇尔满意地离开了车厢。

选择页面：

«…11 12 13 14 15…»

意见反馈添加微信：FFFyangy，或发送电子邮件：1033278875@qq.com，客服热线：13528685811

本站支持IPv6访问