diff --git a/zh-cn/application-dev/arkts-utils/arkts-overview.md b/zh-cn/application-dev/arkts-utils/arkts-overview.md index e385e01579da5c7ac617b23b352a9c21574b5633..0bab9362d8c900717edd3c281395181157b168b9 100644 --- a/zh-cn/application-dev/arkts-utils/arkts-overview.md +++ b/zh-cn/application-dev/arkts-utils/arkts-overview.md @@ -1,8 +1,8 @@ # ArkTS简介 -ArkTS是OpenHarmony应用开发的官方高级语言。 +ArkTS是OpenHarmony生态的应用开发语言。 -ArkTS在[TypeScript](https://www.typescriptlang.org/)（简称TS）生态基础上做了进一步扩展，保持了TS的基本风格，同时通过规范定义强化开发期静态检查和分析，提升代码健壮性，并实现更好的程序执行稳定性和性能。对比标准TS的差异可以参考[从TypeScript到ArkTS的适配规则](../quick-start/typescript-to-arkts-migration-guide.md)。ArkTS同时也支持与TS/JavaScript（简称JS）高效互操作。 +ArkTS在[TypeScript](https://www.typescriptlang.org/)（简称 TS）生态基础上做了进一步扩展，保持了TS的基本风格，同时通过规范定义强化开发期静态检查和分析，提升代码健壮性，并实现更好的程序执行稳定性和性能。对比标准TS的差异可以参考[从TypeScript到ArkTS的适配规则](../quick-start/typescript-to-arkts-migration-guide.md)。ArkTS同时也支持与TS/JavaScript（简称JS）高效互操作。 ArkTS基础类库和容器类库增强了语言的基础功能，提供包括[高精度浮点运算](../reference/apis-arkts/js-apis-arkts-decimal.md)、[二进制Buffer](buffer.md)、[XML生成解析转换](xml-overview.md)和多种容器库等能力，协助开发者简化开发工作，提升开发效率。 diff --git a/zh-cn/application-dev/quick-start/arkts-coding-style-guide.md b/zh-cn/application-dev/quick-start/arkts-coding-style-guide.md index 659deee4b346d3cc216a22bb221488bba39e063e..35f8d9d01916890f69b2887c3c04e077cb4630c6 100644 --- a/zh-cn/application-dev/quick-start/arkts-coding-style-guide.md +++ b/zh-cn/application-dev/quick-start/arkts-coding-style-guide.md @@ -2,13 +2,13 @@ ## 目标和适用范围 -本文参考业界标准及实践，结合ArkTS语言特点，为提高代码的规范、安全、性能提供编码指南。 +本文参考业界标准及实践，结合ArkTS语言特点，提供编码指南，以提高代码的规范、安全、性能。 -本文适用于使用ArkTS编写代码的开发场景。 +本文适用于使用ArkTS编写代码的场景。 ## 规则来源 -ArkTS在保持TypeScript基本语法风格的基础上，进一步强化静态检查和分析。本文部分规则筛选自《[OpenHarmony应用TS&JS编程指南](https://gitee.com/openharmony/docs/blob/master/zh-cn/contribute/OpenHarmony-Application-Typescript-JavaScript-coding-guide.md)》，为ArkTS语言新增的语法添加了规则，旨在提高代码可读性、执行性能。 +ArkTS保持TypeScript基本语法风格，进一步强化静态检查和分析。本文部分规则筛选自《[OpenHarmony应用TS&JS编程指南](https://gitee.com/openharmony/docs/blob/master/zh-cn/contribute/OpenHarmony-Application-Typescript-JavaScript-coding-guide.md)》，为ArkTS语言新增的语法添加了规则，旨在提高代码可读性、执行性能。 ## 章节概览 @@ -20,7 +20,7 @@ ArkTS在保持TypeScript基本语法风格的基础上，进一步强化静态 包含声明与初始化、数据类型、运算与表达式、异常等。 -参考了《OpenHarmony应用TS&JS编程指南》中的规则，对其中ArkTS语言不涉及的部分作了去除，为ArkTS语言新增的语法添加了规则。 +参考了《OpenHarmony应用TS&JS编程指南》中的规则，去除了ArkTS不涉及的部分，为新增语法添加了规则。 ## 术语和定义 @@ -46,7 +46,7 @@ ArkTS在保持TypeScript基本语法风格的基础上，进一步强化静态 **【描述】** 好的标识符命名应遵循以下原则： - - 能清晰的表达意图，避免使用单个字母、未成惯例的缩写来命名 + - 能清晰表达意图，避免使用单个字母或未成惯例的缩写来命名 - 使用正确的英文单词并符合英文语法，不要使用中文拼音 - 能区分出意思，避免造成误导 @@ -147,7 +147,7 @@ enum UserType { **【描述】** -布尔型的局部变量建议加上表达是非意义的前缀，比如is，也可以是has、can、should等。但是，当使用逻辑非运算符，并出现双重否定时，会出现理解问题，比如!isNotError，意味着什么，不是很好理解。因此，应避免定义否定的布尔变量名。 +布尔型的局部变量建议加上表达是非意义的前缀，如is、has、can、should等。避免使用逻辑非运算符时出现双重否定，如!isNotError，应避免定义否定的布尔变量名。 **【反例】** @@ -229,7 +229,7 @@ function test(dataSource: DataSource[]) { 代码行宽不宜过长，否则不利于阅读。 -控制行宽可以间接的引导程序员去缩短函数、变量的命名，减少嵌套的层数，精炼注释，提升代码可读性。 +控制行宽可以引导程序员缩短函数、变量命名，减少嵌套层数，精炼注释，提升代码可读性。 建议每行字符数不超过120个，除非需要显著增加可读性（超过120个），且不会隐藏信息。 例外：如果一行注释包含了超过120个字符的命令或URL，则可以保持一行，以方便复制、粘贴和通过grep查找；预处理的error信息在一行便于阅读和理解，即使超过120个字符。 @@ -239,7 +239,7 @@ function test(dataSource: DataSource[]) { **【描述】** -在`if`、`for`、`do`、`while`等语句的执行体加大括号`{}`是一种最佳实践，因为省略大括号容易导致错误，并且降低代码的清晰度。 +在条件语句和循环语句的执行体加大括号`{}`，省略大括号容易导致错误，降低代码的清晰度。 **【反例】** @@ -294,7 +294,7 @@ switch (condition) { **【描述】** -当语句过长或可读性不佳时，需要在合适的地方进行换行。 +当表达式过长或可读性不佳时，需要换行。 换行时将操作符放在行末，表示“未结束，后续还有”，保持与常用的格式化工具的默认配置一致。 **【正例】** @@ -313,8 +313,8 @@ if (userCount > MAX_USER_COUNT || **【描述】** -每个语句的变量声明都应只声明一个变量。 -这种方式更便于添加变量声明，无需考虑将分号改为逗号，以免引入错误。此外，每个语句只声明一个变量，使用调试器逐个调试也很方便，而不是一次跳过所有变量。 +每个变量声明的语句都应只声明一个变量。 +这种方式便于添加变量声明，避免引入错误。每个语句只声明一个变量，便于调试。 **【反例】** @@ -426,7 +426,7 @@ myFunc(bar, foo, baz); // 函数的多个参数之间的逗号后加个空格 **【描述】** -通常情况下，建议使用单引号。 +建议使用单引号。 **【反例】** @@ -448,7 +448,7 @@ console.log(message); **【描述】** -对象字面量的属性应保持一致的格式：要么每个属性都换行，要么所有属性都在同一行。当对象字面量的属性超过4个时，建议统一换行。 +对象字面量的属性应保持一致格式。当属性超过4个时，建议换行。 **【反例】** @@ -493,7 +493,7 @@ let obj: I = { **【描述】** -编写条件语句时，建议将`else`放在`if`代码块关闭括号的同一行。同样，编写异常处理语句时，建议将`catch`放在`try`代码块关闭括号的同一行。 +编写条件语句时，将`else`放在`if`代码块关闭括号的同一行。编写异常处理语句时，将`catch`放在`try`代码块关闭括号的同一行。 **【反例】** @@ -545,7 +545,7 @@ try { **【描述】** -应保持一致的大括号风格。建议将大括号置于控制语句或声明语句的同一行。 +应保持一致的大括号风格。将大括号置于语句的同一行。 **【反例】** @@ -572,7 +572,7 @@ function foo() { **【描述】** -ArkTS提供了`private`, `protected`和`public`可访问修饰符。默认情况下，属性的可访问修饰符为`public`。选取适当的可访问修饰符可以提升代码的安全性和可读性。注意：如果类中包含`private`属性，无法通过对象字面量初始化该类。 +ArkTS提供了`private`、`protected`和`public`三种可访问修饰符。默认情况下，属性的可访问修饰符为`public`。选择合适的可访问修饰符可以提升代码的安全性和可读性。注意：类中包含`private`属性时，无法通过对象字面量初始化该类。 **【反例】** @@ -604,7 +604,7 @@ class C { **【描述】** -ArkTS中，浮点值包含一个小数点，不要求小数点之前或之后必须有一个数字。在小数点前面和后面都添加数字可以提高代码的可读性。 +ArkTS中，浮点值包含一个小数点。在小数点前后添加数字可以提高代码的可读性。 **【反例】** @@ -628,9 +628,9 @@ const num = -0.7; **【描述】** -在ArkTS中，`Number.NaN`是`Number`类型的一个特殊值。它被用来表示非数值，这里的数值是指在IEEE浮点数算术标准中定义的双精度64位格式的值。 -在ArkTS中，`Number.NaN`的独特之处在于它不等于任何值，包括其本身。与`Number.NaN`进行比较时，结果是令人困惑的：`Number.NaN !== Number.NaN` 和 `Number.NaN != Number.NaN` 的值都是 `true`。 -因此，必须使用`Number.isNaN()`函数来测试一个值是否是`Number.NaN`。 +在ArkTS中，`Number.NaN`是`Number`类型的一个特殊值，表示非数值。这里的数值是指在IEEE浮点数算术标准中定义的双精度64位格式的值。 +在ArkTS中，`Number.NaN`的独特之处在于它不等于任何值，包括其本身。与`Number.NaN`进行比较时，`Number.NaN !== Number.NaN` 和 `Number.NaN != Number.NaN` 的结果都是 `true`。 +必须使用`Number.isNaN()`函数来测试一个值是否是`Number.NaN`。 **【反例】** diff --git a/zh-cn/application-dev/quick-start/arkts-get-started.md b/zh-cn/application-dev/quick-start/arkts-get-started.md index 424603e1715e1c07ae7d60030657f43d6ed78355..de3780efd6e7dcc2a83d42c826b0df28a565f0e4 100644 --- a/zh-cn/application-dev/quick-start/arkts-get-started.md +++ b/zh-cn/application-dev/quick-start/arkts-get-started.md @@ -7,15 +7,15 @@ ArkTS是OpenHarmony优选的主力应用开发语言，它在[TypeScript](https: 自API version 10起，ArkTS进一步通过规范强化静态检查和分析，其主要特性及标准TS的差异包括[从TypeScript到ArkTS的适配规则](typescript-to-arkts-migration-guide.md)： -- 强制使用静态类型：静态类型是ArkTS最重要的特性之一。如果使用静态类型，那么程序中变量的类型就是确定的。同时，由于所有类型在程序实际运行前都是已知的，编译器可以验证代码的正确性，从而减少运行时的类型检查，有助于性能提升。 +- 强制使用静态类型：静态类型是ArkTS的重要特性之一。使用静态类型时，程序中变量的类型确定，所有类型在程序运行前已知，编译器可以验证代码的正确性，减少运行时的类型检查，有助于性能提升。 -- 禁止在运行时改变对象布局：为实现最优性能，ArkTS要求在程序执行期间不能更改对象布局。 +- 禁止在运行时改变对象布局：为实现最佳性能，ArkTS要求在程序执行期间保持对象布局不变。 -- 限制运算符语义：为获得更好的性能并鼓励开发者编写更清晰的代码，ArkTS限制了一些运算符的语义。例如，一元加法运算符只能作用于数字，不能用于其他类型的变量等。 +- 限制运算符语义：为提升性能和代码清晰度，ArkTS限制了一些运算符的语义。比如，一元加法运算符只能作用于数字，不能用于其他类型的变量。 -- 不支持Structural typing：对Structural typing的支持需要在语言、编译器和运行时进行大量的考虑和仔细的实现，当前ArkTS不支持该特性。根据实际场景的需求和反馈，后续会重新考虑是否支持Structural typing。 +- 不支持Structural typing：支持Structural typing需要在语言、编译器和运行时进行大量考虑和实现。当前ArkTS不支持该特性，但会根据实际需求和反馈重新考虑。 -ArkTS兼容TS/JavaScript（简称JS）生态，开发者可以使用TS/JS进行开发或复用已有代码。OpenHarmony系统对TS/JS支持的详细情况见[兼容TS/JS的约束](arkts-migration-background.md#方舟运行时兼容tsjs)。 +ArkTS兼容TS/JavaScript（简称JS）生态，开发者可以使用TS/JS进行开发，也可以复用已有代码。有关OpenHarmony系统对TS/JS支持的详细情况，请参见[兼容TS/JS的约束](arkts-migration-background.md#方舟运行时兼容tsjs)。 未来，ArkTS会结合应用开发/运行的需求持续演进，逐步增强并行和并发能力、扩展系统类型，以及引入分布式开发范式等更多特性。 diff --git a/zh-cn/application-dev/quick-start/arkts-high-performance-programming.md b/zh-cn/application-dev/quick-start/arkts-high-performance-programming.md index 5f39df042485146b6ca9a9281b79ea08789c4490..4452a5f725c58e4d28444964cba8d905e002e61e 100644 --- a/zh-cn/application-dev/quick-start/arkts-high-performance-programming.md +++ b/zh-cn/application-dev/quick-start/arkts-high-performance-programming.md @@ -3,7 +3,7 @@ ## 概述 -本文提供应用性能敏感场景下的高性能编程建议，帮助开发者编写高性能应用。高性能编程实践是在开发过程中总结的一些高性能写法和建议。在实现业务功能时，应同步思考并理解高性能写法的原理，并将其应用于代码逻辑中。关于ArkTS编程规范，请参考[ArkTS编程规范](./arkts-coding-style-guide.md)。 +本文提供应用性能敏感场景下的高性能编程建议，帮助开发者编写高性能应用。在实现业务功能时，应理解高性能写法的原理并应用于代码逻辑中。关于ArkTS编程规范，请参考[ArkTS编程规范](./arkts-coding-style-guide.md)。 ## 声明与表达式 @@ -18,7 +18,7 @@ const index = 10000; // 该变量在后续过程中未发生改变，建议声 ### `number`类型变量避免整型和浮点型混用 -针对`number`类型，运行时在优化时会区分整型和浮点型数据。建议避免在初始化后改变数据类型。 +针对`number`类型，运行时在优化时会区分整型和浮点型数据。建议初始化时确定数据类型，避免在运行时改变。 ``` TypeScript let intNum = 1; @@ -31,7 +31,7 @@ doubleNum = 1; // 该变量在声明时为浮点型数据，建议后续不要 ### 数值计算避免溢出 -常见的可能导致溢出的数值计算包括如下场景，溢出之后，会导致引擎走入慢速的溢出逻辑分支处理，影响后续的性能。 +常见的数值计算溢出场景包括：溢出后，引擎将进入慢速的溢出处理逻辑，影响性能。 - 针对加法、减法、乘法、指数运算等运算操作，应避免数值大于INT32_MAX（2147483647）或小于INT32_MIN（-2147483648）。 @@ -40,7 +40,7 @@ doubleNum = 1; // 该变量在声明时为浮点型数据，建议后续不要 ### 循环中常量提取，减少属性访问次数 -如果常量在循环中不会改变，可以将其提取到循环外部，减少访问次数。 +如果常量在循环中不会改变，建议将其提取到循环外部，减少属性访问次数。 ``` TypeScript class Time { @@ -58,7 +58,7 @@ function getNum(num: number): number { } ``` -优化后的代码如下，可以将`Time.info[num - Time.start]`提取为常量，这样可以显著减少属性访问次数，提升性能。 +优化后的代码如下，可以将`Time.info[num - Time.start]`提取为常量，减少属性访问次数，提升性能。 ``` TypeScript class Time { @@ -95,7 +95,7 @@ function foo(): number { foo(); ``` -建议使用参数传递函数外部的变量，以替代使用闭包。 +建议使用参数传递外部变量，替代闭包。 ``` TypeScript let arr = [0, 1, 2]; @@ -120,7 +120,7 @@ function add(left?: number, right?: number): number | undefined { } ``` -根据业务需求，将函数参数声明为必选参数。可以考虑使用默认参数。 +根据业务需求，将函数参数声明为必选参数。考虑使用默认参数。 ``` TypeScript function add(left: number = 0, right: number = 0): number { return left + right; @@ -180,7 +180,7 @@ let arrNum: number[] = [1, 1.1, 2]; // 数值数组中混合使用整型数据 let arrUnion: (number | string)[] = [1, 'hello']; // 联合类型数组 ``` -根据业务需求，将相同类型的数据放在同一数组中。 +根据业务需求，将相同类型的数据置于同一数组。 ``` TypeScript let arrInt: number[] = [1, 2, 3]; let arrDouble: number[] = [0.1, 0.2, 0.3]; @@ -192,7 +192,7 @@ let arrString: string[] = ['hello', 'world']; ### 避免频繁抛出异常 -创建异常时会构造异常的栈帧，造成性能损耗。在性能敏感场景下，如`for`循环语句中，应避免频繁抛出异常。 +创建异常时会构造异常的栈帧。这会导致性能损耗。在性能敏感场景下，如`for`循环语句中，应避免频繁抛出异常。 优化前的代码示例： diff --git a/zh-cn/application-dev/quick-start/arkts-migration-background.md b/zh-cn/application-dev/quick-start/arkts-migration-background.md index 57c7955dd1a97b81a410bc9d7b5306b46f512c91..2910614c73acdb60e41a7dcebb073d84a0060409 100644 --- a/zh-cn/application-dev/quick-start/arkts-migration-background.md +++ b/zh-cn/application-dev/quick-start/arkts-migration-background.md @@ -1,12 +1,12 @@ # ArkTS语法适配背景 -ArkTS在保留TypeScript（简称TS）基本语法风格的基础上，进一步通过规范强化了静态检查和分析，使得在程序开发阶段能够检测出更多错误，提升程序的稳定性和运行性能。本文将详细解释为什么建议将TS代码适配为ArkTS代码。 +ArkTS保留TS基本语法风格，强化静态检查和分析，提升程序稳定性和运行性能。本文解释将TS代码适配为ArkTS代码的原因。 ## 程序稳定性 -动态类型语言如JavaScript（简称JS）虽能提升开发效率，但也容易在运行时引发非预期错误。例如未检查的`undefined`值可能导致程序崩溃，这类问题若能在开发阶段发现将显著提升稳定性。TypeScript（TS）通过类型标注机制，使编译器能在编译时检测出多数类型错误，但其非强制类型系统仍存在局限。例如未标注类型的变量会阻碍完整编译检查。ArkTS通过强制静态类型系统克服这一缺陷，实施更严格的类型验证机制，从而最大限度减少运行时错误的发生。 +动态类型语言如JavaScript提升开发效率，但容易引发运行时错误。未检查的`undefined`值可能导致程序崩溃。TypeScript通过类型标注机制，在编译时检测类型错误，但非强制类型系统存在局限。未标注类型的变量会阻碍完整编译检查。ArkTS通过强制静态类型系统，实施严格类型验证，从而减少运行时错误。 -下面这个例子展示了ArkTS通过强制严格的类型检查来提高代码稳定性和正确性。 +下面的例子展示ArkTS通过严格类型检查提高代码稳定性和正确性。 **显式初始化类的属性** @@ -54,7 +54,7 @@ let buddy = new Person() buddy.getName().length; // 0, 没有运行时异常 ``` -如果`name`可以是`undefined`，其类型应在代码中精确标注。 +如果`name`可以是`undefined`，其类型应精确标注。 ```typescript class Person { @@ -85,7 +85,7 @@ buddy.getName()?.length; // 编译成功，没有运行时错误 ## 程序性能 -为了确保程序的正确性，动态类型语言需要在运行时检查对象的类型。例如JavaScript不允许访问`undefined`的属性。检查一个值是否为`undefined`的唯一方法是在运行时进行类型检查。所有JavaScript引擎都会执行以下操作：如果一个值不是`undefined`，则可以访问其属性；否则，抛出异常。虽然现代JavaScript引擎可以优化这类操作，但仍然存在一些无法消除的运行时检查，这会导致程序变慢。由于TypeScript代码总是先被编译成JavaScript代码，因此在TypeScript中也会遇到相同的问题。ArkTS解决了这个问题。通过启用静态类型检查，ArkTS代码将被编译成方舟字节码文件，而不是JavaScript代码。因此，ArkTS运行速度更快，更容易被进一步优化。 +为了确保程序的正确性，动态类型语言需要在运行时检查对象类型。例如，JavaScript不允许访问`undefined`的属性。唯一检查一个值是否为`undefined`的方法是在运行时进行类型检查。所有JavaScript引擎都会执行以下操作：如果一个值不是`undefined`，则可以访问其属性；否则，抛出异常。虽然现代JavaScript引擎可以优化这类操作，但依然存在一些无法消除的运行时检查，导致程序变慢。由于TypeScript代码被编译成JavaScript代码，因此在TypeScript中也会遇到相同的问题。ArkTS通过启用静态类型检查解决了这个问题。ArkTS代码将被编译成方舟字节码文件，而不是JavaScript代码，因此运行速度更快，更容易被进一步优化。 **Null Safety** @@ -98,8 +98,8 @@ function notify(who: string, what: string) { notify('Jack', 'You look great today'); ``` -在大多数情况下，函数`notify`会接受两个`string`类型的变量作为输入，产生一个新的字符串。但是，如果将一些特殊值作为输入，例如`notify(null, undefined)`，情况会怎么样呢？ -程序仍会正常运行，输出预期值：`Dear null, a message for you: undefined`。一切看起来正常，但是请注意，为了保证该场景下程序的正确性，引擎总是在运行时进行类型检查，执行类似以下的伪代码。 +函数`notify`通常接受两个`string`类型的参数，生成一个新的字符串。但是，如果输入特殊值，如`notify(null, undefined)`，结果会如何呢？ +程序会正常运行，输出预期值：`Dear null, a message for you: undefined`。为确保该场景下程序的正确性，引擎在运行时进行类型检查，执行以下伪代码。 ```typescript function __internal_tostring(s: any): string { @@ -113,7 +113,7 @@ function __internal_tostring(s: any): string { } ``` -现在想象一下，如果函数`notify`是某些复杂的负载场景中的一部分，而不仅仅是打印日志，那么在运行时执行像`__internal_tostring`的类型检查将会是一个性能问题。 +如果函数`notify`在复杂的负载场景中使用，而不仅仅是打印日志，那么在运行时执行`__internal_tostring`的类型检查将会成为性能瓶颈。 如果可以保证在运行时，只有`string`类型的值（不会是其他值，例如`null`或者`undefined`）可以被传入函数`notify`呢？在这种情况下，因为可以确保没有其他边界情况，像`__internal_tostring`的检查就是多余的了。对于这个场景，这样的机制叫做“null-safety”，也就是说，保证`null`或`undefined`不是一个合法的`string`类型变量的值。如果ArkTS有了这个特性，类型不符合的代码将无法编译。 @@ -126,21 +126,21 @@ notify('Jack', 'You look great today'); notify(null, undefined); // 编译时错误 ``` -TS通过启用编译选项`strictNullChecks`实现此特性。虽然TS被编译成JS，但因为JS没有这个特性，所以严格`null`检查仅在编译时起效。从程序稳定性和性能的角度考虑，ArkTS将“null-safety”视为一个重要的特性。因此，ArkTS强制进行严格`null`检查，在ArkTS中上述代码将始终编译失败。作为交换，此类代码为ArkTS引擎提供了更多信息和关于值的类型保证，有助于优化性能。 +TS通过编译选项`strictNullChecks`实现此特性。TS编译成JS，但JS没有这个特性，严格`null`检查仅在编译时起效。从稳定性和性能考虑，ArkTS将“null-safety”视为重要特性。因此，ArkTS强制严格`null`检查，上述代码将编译失败。作为交换，此类代码为ArkTS引擎提供类型保证，优化性能。 ## .ets代码兼容性 -在API version 10之前，ArkTS（.ets文件）完全采用了标准TS的语法。从API version 10 Release起，明确定义ArkTS的语法规则，同时，SDK增加了在编译流程中对.ets文件的ArkTS语法检查，通过编译告警或编译失败提示开发者适配新的ArkTS语法。 +在API version 10之前，ArkTS（.ets文件）使用标准TS语法。从API version 10 Release起，SDK在编译流程中增加了对.ets文件的ArkTS语法检查，通过编译告警或编译失败提示开发者适配新的ArkTS语法规则。 -根据工程的compatibleSdkVersion，具体策略如下： +根据compatibleSdkVersion，策略如下： - - compatibleSdkVersion >= 10 为标准模式。在该模式下，对.ets文件，违反ArkTS语法规则的代码会导致工程编译失败，需要完全适配ArkTS语法后方可编译成功。 - - compatibleSdkVersion < 10 为兼容模式。在该模式下，对.ets文件以warning形式提示违反ArkTS语法规则的所有代码。尽管违反ArkTS语法规则的工程在兼容模式下仍可编译成功，但需完全适配ArkTS语法后方可在标准模式下编译成功。 + - compatibleSdkVersion >= 10 为标准模式。违反ArkTS语法的.ets文件代码会导致编译失败，需完全适配ArkTS语法后方可编译成功。 + - compatibleSdkVersion < 10 为兼容模式。违反ArkTS语法的.ets文件代码以warning形式提示。尽管违反ArkTS语法的工程在兼容模式下仍可编译成功，但需完全适配ArkTS语法后方可在标准模式下编译成功。 ## 支持与TS/JS的交互 -ArkTS支持与TS/JS的高效互操作。在当前版本中，ArkTS运行时兼容动态类型对象语义。在与TS/JS交互时，将TS/JS的数据和对象作为ArkTS的数据和对象使用，可能会绕过ArkTS的静态编译检查，导致非预期的行为或增加额外的开销。 +ArkTS支持与TS/JS的高效互操作。当前版本的ArkTS运行时兼容动态类型对象语义。与TS/JS交互时，使用TS/JS的数据和对象可能会绕过ArkTS的静态编译检查，导致意外行为或增加额外开销。 ```typescript // lib.ts @@ -162,7 +162,7 @@ foo(c); ## 方舟运行时兼容TS/JS -在API version 11上，OpenHarmony SDK中的TypeScript版本为4.9.5，target字段为es2017。应用中支持使用ECMA2017及更高版本的语法进行TS/JS开发。 +在API version 11上，OpenHarmony SDK中的TypeScript版本为4.9.5，target字段设置为es2017。应用支持使用ECMA2017及更高版本的语法进行TS/JS开发。 **应用环境限制** @@ -187,4 +187,4 @@ foo(c); **与标准TS/JS的差异** -在标准的TS/JS中，JSON的数字格式要求小数点后必须跟随数字，例如 `2.e3` 这类科学计数法不被允许，会导致`SyntaxError`。而在方舟运行时中，支持这类科学计数法 +在标准的TS/JS中，JSON的数字格式要求小数点后必须跟随数字，例如 `2.e3` 这类科学计数法不被允许，会导致`SyntaxError`。而方舟运行时支持这类科学计数法。 diff --git a/zh-cn/application-dev/quick-start/arkts-more-cases.md b/zh-cn/application-dev/quick-start/arkts-more-cases.md index e8cd3e6d9c7328c8578467fdeb7d959292f0335e..9dbf12809fe99ab9c070f452f5a20aa5789350bc 100644 --- a/zh-cn/application-dev/quick-start/arkts-more-cases.md +++ b/zh-cn/application-dev/quick-start/arkts-more-cases.md @@ -1,6 +1,6 @@ # 适配指导案例 -本文通过具体应用场景中的案例，提供在ArkTS语法规则下将TS代码适配成ArkTS代码的建议。各章以ArkTS语法规则的英文名称命名，每个案例展示适配前的TS代码和适配后的ArkTS代码。 +本文提供在ArkTS语法规则下将TS代码适配成ArkTS代码的建议。各章以ArkTS语法规则的英文名称命名，展示适配前的TS代码和适配后的ArkTS代码。 ## arkts-identifiers-as-prop-names @@ -40,7 +40,7 @@ let wantInfo: W = { ## arkts-no-any-unknown -### 按照业务逻辑，将代码中的`any, unknown`改为具体的类型 +### 将代码中的`any, unknown`改为具体类型 ```typescript function printObj(obj: any) { @@ -118,7 +118,7 @@ function printProperties(obj: Record) { ## arkts-no-call-signature -使用函数类型进行替代。 +使用函数类型替代。 **应用代码** @@ -216,7 +216,7 @@ console.log(t.createController()!.value); ## arkts-no-indexed-signatures -使用Record类型进行替代。 +使用Record类型替代。 **应用代码** @@ -358,7 +358,7 @@ console.log(t.createController()!.value); ## arkts-no-props-by-index -可以将对象转换为Record类型，以便访问其属性。 +将对象转换为Record类型，以便访问其属性。 **应用代码** @@ -380,7 +380,7 @@ function foo(params: Record) { ## arkts-no-inferred-generic-params -所有泛型调用都应显式标注泛型参数类型，如 Map\、.map\()。 +显式标注所有泛型调用的泛型参数类型，如 Map\、.map\()。 **应用代码** @@ -432,7 +432,7 @@ let regexp: RegExp = new RegExp('\\s*','g'); **原因** -如果正则表达式中使用了标志符，需要将其作为`new RegExp()`的参数。 +如果正则表达式中使用了标志符，将其作为`new RegExp()`的参数。 ## arkts-no-untyped-obj-literals @@ -521,7 +521,7 @@ let s: C = new C(-2); //抛出异常 let t: C = { value: -2 }; //ArkTS不支持 ``` -如果允许使用`C`来标注object literal的类型，变量`t`会导致行为的二义性。ArkTS禁止通过object literal绕过这一行为。 +如果允许使用`C`标注object literal的类型，变量`t`会导致行为的二义性。ArkTS禁止通过object literal绕过这一行为。 ### 用class/interface为object literal标注类型，要求使用identifier作为object literal的key @@ -667,7 +667,7 @@ let t:T = new T(); **原因** -class/interface中声明的方法应被所有实例共享。ArkTS不支持通过object literal改写实例方法。ArkTS支持函数类型的属性。 +class/interface中声明的方法应被所有实例共享。不支持通过object literal改写实例方法。支持函数类型的属性。 ### export default对象 @@ -747,8 +747,8 @@ test.foo('', option); **原因** -对象字面量缺少类型，根据`test.foo`分析可以得知，`option`的类型来源于声明文件，那么只需要将类型导入即可。 -在`test.d.ets`中，`I`定义在namespace中。在ets文件中，先导入namespace，再通过名称获取相应的类型。 +对象字面量缺少类型，根据`test.foo`分析可以得知，`option`的类型来源于声明文件，将类型导入即可。 +在`test.d.ets`中，`I`定义在namespace中。导入namespace并获取类型。 ### object literal传参给Object类型 @@ -778,7 +778,7 @@ emit('', emitArg); ## arkts-no-obj-literals-as-types -使用interface显式定义结构类型。 +使用interface定义结构类型。 **应用代码** @@ -797,7 +797,7 @@ interface Person { ## arkts-no-noninferrable-arr-literals -显式声明数组元素的类型（使用interface或class），并为数组变量添加类型注解。 +声明数组元素类型，使用interface或class，并为数组变量添加类型注解。 **应用代码** @@ -828,7 +828,7 @@ let permissionList: PermissionItem[] = [ ## arkts-no-method-reassignment -使用函数类型的类字段（class field）代替原型方法。 +使用类字段（class field）的函数类型来替代原型方法。 **应用代码** @@ -867,7 +867,7 @@ c1.add = sub; ## arkts-no-polymorphic-unops -使用 Number.parseInt()、new Number() 等显式转换函数。 +使用 Number.parseInt()、new Number() 等显式转换。 **应用代码** @@ -889,7 +889,7 @@ let d = new Number('string'); ## arkts-no-type-query -使用类、接口或类型别名替代typeof，避免依赖变量做类型推导。 +使用类、接口或类型别名替代typeof，避免依赖变量进行类型推导。 **应用代码** @@ -948,7 +948,7 @@ function test(str: string, obj: Record) { ## arkts-no-destruct-assignment -使用索引访问元素或手动赋值代替解构赋值。 +使用索引访问元素或手动赋值替代解构赋值。 **应用代码** @@ -976,7 +976,7 @@ for (let arr of map) { ## arkts-no-types-in-catch -使用无类型 catch (error)，然后通过类型断言处理。 +使用无类型catch (error)，通过类型断言处理错误。 **应用代码** @@ -1005,7 +1005,7 @@ try { ## arkts-no-for-in -使用 Object.entries(obj) + for of 替代 for in。 +使用`Object.entries(obj)`和`for of`循环替代`for in`循环。 **应用代码** @@ -1067,7 +1067,7 @@ type OptionsFlags = Record ## arkts-limited-throw -将对象转换为Error，或创建新的Error实例抛出。 +将对象转换为Error，或创建并抛出新的Error实例。 **应用代码** @@ -1110,7 +1110,7 @@ foo.apply(obj); **建议改法1** -使用类的方法实现,如果该方法被多个类使用,可以考虑采用继承的机制。 +使用类的方法实现。如果多个类需要使用该方法，可以考虑采用继承机制。 ```typescript class Test { @@ -1187,7 +1187,7 @@ class Test { ## arkts-no-spread -使用Object.assign()、手动赋值或数组方法替代扩展运算符。 +使用Object.assign()、手动赋值或数组方法。 **应用代码** @@ -1241,7 +1241,7 @@ ArkTS中，对象布局在编译期是确定的。如果需要将一个对象的 ## arkts-no-ctor-signatures-funcs -在class内声明属性，而不是在构造函数上。 +在类内声明属性，而不是在构造函数中。 **应用代码** @@ -1297,11 +1297,11 @@ console.log(t.createController()!.value); ## arkts-no-globalthis -ArkTS不支持`globalThis`。一方面无法为`globalThis`添加静态类型，只能通过查找方式访问其属性，导致额外性能开销。另一方面，无法为`globalThis`的属性标记类型，无法保证操作的安全性和高性能。 +ArkTS不支持`globalThis`。无法为`globalThis`添加静态类型，只能通过查找方式访问其属性，导致额外性能开销。此外，无法为`globalThis`的属性标记类型，无法保证操作的安全性和高性能。 -1. 建议按照业务逻辑根据`import/export`语法实现数据在不同模块的传递。 +1. 建议根据业务逻辑使用`import/export`语法实现数据在不同模块的传递。 -2. 必要情况下，可以通过构造的**单例对象**来实现全局对象的功能。(**说明：** 不能在har中定义单例对象，har在打包时会在不同的hap中打包两份，无法实现单例。) +2. 必要时，可以通过构造**单例对象**来实现全局对象的功能。(**说明：** 不能在har中定义单例对象，因为har在打包时会在不同的hap中分别打包，无法保证单例。) **构造单例对象** @@ -1373,7 +1373,7 @@ GlobalContext.getContext().getObject('value'); ## arkts-no-func-apply-bind-call -### 使用标准库中接口 +### 使用标准库接口 **应用代码** @@ -1534,9 +1534,9 @@ entries.forEach((value, key) => { ### 使用`Number`的属性和方法 -ArkTS不允许使用全局对象的属性和方法： `Infinity, NaN, isFinite, isNaN, parseFloat, parseInt`。 +ArkTS不允许使用全局对象的属性和方法，例如 `Infinity, NaN, isFinite, isNaN, parseFloat, parseInt` -可以使用`Number`的属性和方法： `Infinity, NaN, isFinite, isNaN, parseFloat, parseInt`。 +可以使用`Number`的属性和方法，例如 `Infinity, NaN, isFinite, isNaN, parseFloat, parseInt` **应用代码** @@ -1643,11 +1643,11 @@ a?.bar(); ### 严格属性初始化检查 -在class中，如果一个属性没有初始化，且没有在构造函数中被赋值，ArkTS将报错。 +在class中，如果属性没有初始化，且未在构造函数中赋值，ArkTS将报错。 **建议改法** -1.一般情况下，**建议按照业务逻辑**在声明时初始化属性，或者在构造函数中为属性赋值。如： +1.**建议按照业务逻辑**在声明时初始化属性，或在构造函数中为属性赋值。如： ```typescript //code with error @@ -1679,10 +1679,10 @@ class Test { ​ 方式(ii) `prop?: A` -​ 方式三(iii) `prop： A | undefined = undefined` +​ 方式三(iii) `prop: A | undefined = undefined` -- 从性能角度看，`null`类型仅用于编译期的类型检查，不会影响虚拟机性能。而`undefined | A`被视为联合类型，运行时可能产生额外开销。 -- 从代码可读性、简洁性的角度来说，`prop?:A`是`prop： A | undefined = undefined`的语法糖，**推荐使用可选属性的写法**。 +- 从性能角度，`null`类型仅用于编译期的类型检查，不会影响虚拟机性能。`undefined | A`被视为联合类型，运行时可能产生额外开销。 +- 从代码可读性和简洁性的角度来说，`prop?:A`是`prop： A | undefined = undefined`的语法糖，**推荐使用可选属性的写法** ### 严格函数类型检查 @@ -1704,7 +1704,7 @@ foo((value?: string) => {}, ''); **原因** -例如，在以下的例子中，如果编译期不开启严格函数类型的检查，那么该段代码可以编译通过，但是在运行时会产生非预期的行为。具体来看，在`foo`的函数体中，一个`undefined`被传入`fn`（这是可以的，因为`fn`可以接受`undefined`），但是在代码第6行`foo`的调用点，传入的`(value: string) => { console.info(value.toUpperCase()) }`的函数实现中，始终将参数`value`当做string类型，允许其调用`toUpperCase`方法。如果不开启严格函数类型的检查，那么这段代码在运行时，会出现在`undefined`上无法找到属性的错误。 +如果编译期未开启严格函数类型检查，该段代码可以编译通过，但在运行时会产生非预期行为。具体来说，在`foo`的函数体中，`undefined`被传入`fn`（因为`fn`可以接受`undefined`），但在`foo`的调用点（代码第 6 行），传入的`(value: string) => { console.info(value.toUpperCase()) }`函数实现始终将参数`value`当作字符串类型，允许其调用`toUpperCase`方法。如果不开启严格函数类型检查，这段代码在运行时会出现“在`undefined`上无法找到属性”的错误。 ```typescript function foo(fn: (value?: string) => void, value: string): void { @@ -1715,7 +1715,7 @@ function foo(fn: (value?: string) => void, value: string): void { foo((value: string) => { console.info(value.toUpperCase()) }, ''); // Cannot read properties of undefined (reading 'toUpperCase') ``` -为了避免运行时的非预期行为，开启严格类型检查时，这段代码将无法编译通过，需要提醒开发者修改代码，确保程序安全。 +为了避免运行时出现非预期行为，开启严格类型检查后，此代码将无法编译通过。建议开发者修改代码，确保程序的安全性。 ### 严格空值检查 @@ -1736,7 +1736,7 @@ t.printValue(); **建议改法** -在编写代码时，建议减少可空类型的使用。如果对变量、属性标记了可空类型，那么在使用它们之前，需要进行空值的判断，根据是否为空值处理不同的逻辑。 +编写代码时，建议减少可空类型的使用。如果对变量或属性标记了可空类型，使用前需要进行空值判断，并根据判断结果处理不同的逻辑。 ```typescript class Test { @@ -1755,7 +1755,7 @@ t.printValue(); **原因** -在第一段代码中，如果编译期不开启严格空值检查，那么该段代码可以编译通过，但是在运行时会产生非预期的行为。这是因为`t`的属性`value`为`undefined`（`value?: string`是`value: string | undefined = undefined`的语法糖），在第11行调用`printValue`方法时，由于在该方法体内未对`this.value`的值进行空值检查，而直接按照`string`类型访问其属性，这就导致了运行时的错误。为了避免运行时的非预期行为，如果在编译时开启严格空值检查，这段代码将编译不通过从而可以提醒开发者修改代码（如按照第二段代码的方式），保证程序安全。 +在第一段代码中，如果编译时未开启严格空值检查，该代码可以编译通过，但在运行时会产生非预期行为。原因是`t`的属性`value`为`undefined`（`value?: string`是`value: string | undefined = undefined`的语法糖），在第11行调用`printValue`方法时，方法体未对`this.value`进行空值检查，直接按`string`类型访问其属性，导致运行时错误。为了避免运行时的非预期行为，开启严格空值检查会使这段代码编译不通过，从而提醒开发者修改代码（例如，按照第二段代码的方式），确保程序安全。 ### 函数返回类型不匹配 @@ -1769,7 +1769,7 @@ class Test { **建议改法** -在这种写法下，函数返回类型被解析为 `void | undefined`，需要添加括号用来区分union类型。 +在这种写法下，需要添加括号来区分函数返回类型`void | undefined`。 ```typescript class Test { @@ -1853,7 +1853,7 @@ if (a != null) { **建议改法2** -如果确定此处调用`foo`一定返回非空值，可以使用非空断言`!`。 +如果确认调用`foo`一定会返回非空值，可以使用非空断言`!`。 ```typescript class A { @@ -1911,7 +1911,7 @@ if (a.foo) { **原因** -在原先代码的定义中，`foo`是可选属性，可能为`undefined`，对`undefined`的调用会导致报错。建议根据业务逻辑判断是否需要将`foo`设为可选属性。如果确实需要，那么在访问该属性后需要进行空值检查。 +`foo`是可选属性，可能为`undefined`，对`undefined`的调用会导致错误。建议根据业务逻辑判断是否需要将`foo`设为可选属性。如果确实需要，访问该属性前应进行空值检查。 ### Variable '***' is used before being assigned @@ -1954,9 +1954,9 @@ if (a) { **原因** -对于primitive types，可以根据业务逻辑赋值，例如0，''，false。 +对于原始类型，可以根据业务逻辑赋值，例如赋值为0、''或false。 -对于对象类型，可以将其类型修改为与null的联合类型，并赋值为null。使用时需要进行非空检查。 +对于对象类型，可将其类型修改为与null的联合类型并赋值为null。使用时，需进行非空检查。 ### Function lacks ending return statement and return type does not include 'undefined'. @@ -1970,9 +1970,9 @@ function foo(a: number): number { } ``` -**建议改法1** +**建议改法1** -根据业务逻辑，在else分支中返回合适的数值。 +在else分支中返回合适的数值。 **建议改法2** @@ -1987,7 +1987,7 @@ function foo(a: number): number | undefined { ## arkts-strict-typing-required -删除忽略注释，为所有变量显式声明类型。 +删除忽略注释，并为所有变量显式声明类型。 **应用代码** @@ -2004,7 +2004,7 @@ let a: number = 123; **原因** -ArkTS不支持通过注释的方式绕过严格类型检查。首先将注释（`// @ts-nocheck`或者`// @ts-ignore`）删去，再根据报错信息修改其他代码。 +ArkTS不支持通过注释绕过严格类型检查。删除注释（`// @ts-nocheck`或`// @ts-ignore`），并根据报错信息修改代码。 ## Importing ArkTS files to JS and TS files is not allowed @@ -2014,9 +2014,9 @@ ArkTS不支持通过注释的方式绕过严格类型检查。首先将注释（ **建议改法** -方式1.将.ts文件的后缀修改为ets，并按ArkTS语法规则适配代码。 +方式1.将.ts文件的后缀修改为.ets，并按ArkTS语法规则适配代码。 -方式2.将.ets文件中被.ts文件依赖的代码单独抽取到.ts文件中。 +方式2.将.ets文件中被.ts文件依赖的代码抽取到单独的.ts文件中。 ## arkts-no-special-imports @@ -2139,7 +2139,7 @@ console.log(getC2Value()); ## arkts-no-side-effects-imports -改用动态import。 +使用动态import。 **应用代码** @@ -2155,7 +2155,7 @@ import('module') ## arkts-no-func-props -使用class来组织多个相关函数。 +使用class组织相关函数。 **应用代码** @@ -2193,7 +2193,7 @@ class Foo { ## arkts-limited-esobj -使用具体类型（如number, string）或接口代替模糊的ESObject。 +使用具体类型或接口代替模糊的ESObject。 **应用代码** @@ -2294,7 +2294,7 @@ function deepCopy(obj: object): object { ### Struct组件外使用状态变量 -由于`struct`和`class`的不同，不建议将`this`作为参数传递到`struct`外部使用，以避免实例引用无法释放，导致内存泄露。建议传递状态变量对象到`struct`外部使用，通过修改对象的属性来触发UI刷新。 +不建议将`this`作为参数传递到`struct`外部使用，以避免内存泄露。建议传递状态变量对象到`struct`外部，通过修改对象属性触发UI刷新。 **不推荐用法** @@ -2404,7 +2404,7 @@ struct StyleExample { ### Struct支持联合类型的方案 -下面这段代码有arkts-no-any-unknown的报错，由于struct不支持泛型，建议使用联合类型，实现自定义组件类似泛型的功能。 +下面代码有arkts-no-any-unknown报错，struct不支持泛型，建议使用联合类型实现自定义组件的泛型功能。 **不推荐用法** diff --git a/zh-cn/application-dev/quick-start/introduction-to-arkts.md b/zh-cn/application-dev/quick-start/introduction-to-arkts.md index d0e136cb6248fff9cab15b2e51545f4f51308b36..934c61a7d0103fa2769c3cc4605942fd2f840798 100644 --- a/zh-cn/application-dev/quick-start/introduction-to-arkts.md +++ b/zh-cn/application-dev/quick-start/introduction-to-arkts.md @@ -4,13 +4,13 @@ ArkTS是一种设计用于构建高性能应用的编程语言。它在继承Typ 许多编程语言在设计之初没有考虑到移动设备，导致应用的运行缓慢、低效、功耗大，随着移动设备在人们的日常生活中变得越来越普遍，针对移动环境的编程语言优化需求也越来越多。ArkTS是专为解决这些问题而设计的，聚焦于提高运行效率。 -TypeScript是在JavaScript基础上通过添加类型定义扩展而来的，ArkTS则是TypeScript的进一步扩展。TypeScript提供了一种更结构化的JavaScript编码方法，深受开发者喜爱。ArkTS保持了TypeScript的大部分语法，旨在为现有的TypeScript开发者实现无缝过渡，帮助移动开发者快速上手。 +TypeScript通过添加类型定义扩展了JavaScript，ArkTS进一步扩展了TypeScript。TypeScript提供了一种更结构化的编码方法，深受开发者喜爱。ArkTS保持了TypeScript的大部分语法，旨在帮助现有TypeScript开发者实现无缝过渡，移动开发者可以快速上手。 -ArkTS的一大特性是它专注于低运行时开销。ArkTS对TypeScript的动态类型特性施加了更严格的限制，以减少运行时开销，提高执行效率。通过取消动态类型特性，ArkTS代码能更有效地被运行前编译和优化，从而实现更快的应用启动和更低的功耗。 +ArkTS专注于低运行时开销，对TypeScript的动态类型特性施加了严格限制，减少运行时开销，提高执行效率。取消动态类型特性后，ArkTS代码能更有效地编译和优化，实现更快的应用启动和更低的功耗。 ArkTS语言设计中考虑了与TypeScript和JavaScript的互通性。许多移动应用开发者希望重用TypeScript和JavaScript代码及库，因此ArkTS提供与TypeScript和JavaScript的无缝互通，使开发者可以轻松集成TypeScript和JavaScript代码到应用中，充分利用现有代码和库进行ArkTS开发。 -本教程将指导开发者了解ArkTS的核心功能、语法和最佳实践，助力开发者使用ArkTS高效构建高性能的移动应用。 +本教程指导开发者掌握ArkTS的核心功能、语法和最佳实践，助力高效构建高性能的移动应用。 如需详细了解ArkTS语言，请参阅[ArkTS具体指南](../arkts-utils/arkts-overview.md)。 @@ -37,13 +37,13 @@ hi = 'hello, world'; const hello: string = 'hello'; ``` -对常量重新赋值会造成编译时错误。 +对只读常量重新赋值会造成编译时错误。 #### 自动类型推断 由于ArkTS是一种静态类型语言，所有数据的类型都必须在编译时确定。 -如果变量或常量的声明包含了初始值，开发者就不需要显式指定其类型，因为ArkTS规范中列举了所有允许自动推断类型的场景。 +如果变量或常量的声明包含初始值，开发者无需显式指定其类型，因为ArkTS规范已列出所有允许自动推断类型的场景。 以下示例中，两条声明语句都是有效的，两个变量都是`string`类型： @@ -64,7 +64,7 @@ let hi2 = 'hello, world'; ArkTS提供`number`类型，任何整数和浮点数都可以被赋给此类型的变量。 -数字字面量包括整数字面量和十进制浮点数字面量。 +数字字面量包括整数字面量。它还包括十进制浮点数字面量。 整数字面量包括以下类别： @@ -114,7 +114,7 @@ console.log('bigIntger' + bigIntger.toString()); `boolean`类型由`true`和`false`两个逻辑值组成。 -通常在条件语句中使用`boolean`类型的变量： +`boolean`类型的变量通常在条件语句中使用： ```typescript let isDone: boolean = false; @@ -141,7 +141,7 @@ let s3 = `The result is ${a}`; #### `void`类型 -`void`类型用于指定函数没有返回值。 +`void`类型用于指定函数不返回任何值。 此类型只有一个值，同样是`void`。由于`void`是引用类型，因此它可以用于泛型类型参数。 ```typescript @@ -162,8 +162,8 @@ let o3: Object = 1; #### `array`类型 -`array`类型，即数组，是由可赋值给数组声明中指定的元素类型的数据组成的对象。 -数组可由数组复合字面量赋值。数组复合字面量是用方括号括起来的零个或多个表达式列表，每个表达式为数组中的一个元素。数组的长度由数组中元素的个数确定。数组中第一个元素的索引为0。 +`array`类型，即数组，由指定元素类型的数据组成。 +数组可以通过数组复合字面量赋值。数组复合字面量由用方括号括起来的零个或多个表达式组成，每个表达式代表数组中的一个元素。数组的长度由元素个数确定，第一个元素的索引为0。 以下示例将创建包含三个元素的数组： @@ -173,8 +173,8 @@ let names: string[] = ['Alice', 'Bob', 'Carol']; #### `enum`类型 -`enum`类型，即枚举类型，是预先定义的一组命名值的值类型，其中命名值又称为枚举常量。 -使用枚举常量时必须以枚举类型名称为前缀。 +`enum`类型，即枚举类型，是一组预先定义的命名值，这些命名值称为枚举常量。 +使用枚举常量时，必须以枚举类型名称为前缀。 ```typescript enum ColorSet { Red, Green, Blue } @@ -237,7 +237,7 @@ function foo(animal: Animal) { #### `Aliases`类型 -`Aliases`类型为匿名类型（数组、函数、对象字面量或联合类型）提供名称，或为已有类型提供替代名称。 +`Aliases`类型为匿名类型（如数组、函数、对象字面量或联合类型）提供名称，或为已有类型提供替代名称。 ```typescript type Matrix = number[][]; @@ -320,8 +320,8 @@ type NullableObject = Object | null; #### `If`语句 -`if`语句用于需要根据逻辑条件执行不同语句的场景。当逻辑条件为真时，执行对应的一组语句，否则执行另一组语句（如果有的话）。 -`else`部分也可能包含`if`语句。 +`if`语句根据逻辑条件执行不同语句。 +`else`部分可包含`if`语句。 `if`语句如下所示： @@ -414,7 +414,7 @@ let message = Math.random() > 0.5 ? 'Valid' : 'Failed'; #### `For`语句 -`for`语句会被重复执行，直到循环退出语句值为`false`。 +`for`语句重复执行，直到条件为`false`。 `for`语句如下所示： @@ -427,10 +427,10 @@ for ([init]; [condition]; [update]) { `for`语句的执行流程如下： 1、 执行`init`表达式（如有）。此表达式通常初始化一个或多个循环计数器。 -2、 计算`condition`。如果它为真值（转换后为`true`的值），则执行循环主体的语句。如果它为假值（转换后为`false`的值），则`for`循环终止。 -3、 执行循环主体的语句。 -4、 如果有`update`表达式，则执行该表达式。 -5、 回到步骤2。 +2、 计算`condition`。如果为真值，执行循环主体的语句；如果为假值，终止`for`循环。 +3、 执行循环主体。 +4、 执行`update`表达式（如有）。 +5、 回到步骤2。 示例： @@ -501,7 +501,7 @@ do { #### `Break`语句 -使用`break`语句可以终止循环语句或`switch`。 +使用`break`语句终止循环或`switch`。 示例： @@ -515,7 +515,7 @@ while (true) { } ``` -如果`break`语句后带有标识符，则将控制流转移到该标识符所包含的语句块之外。 +如果`break`语句后带有标识符，则将控制流转移到该标识符之外。 示例： @@ -532,7 +532,7 @@ label: while (true) { #### `Continue`语句 -`continue`语句会停止当前循环迭代的执行，并将控制传递给下一个迭代。 +`continue`语句停止当前迭代，传递控制给下一个迭代。 示例： @@ -693,9 +693,9 @@ function hi2(): void { console.log('hi'); } ### 函数的作用域 -函数中定义的变量和其他实例仅可以在函数内部访问，不能从外部访问。 +函数中定义的变量和其他实例仅在函数内部访问。 -如果函数中定义的变量与外部作用域中已有实例同名，则函数内的局部变量定义将覆盖外部定义。 +函数内的局部变量定义会覆盖外部已有的同名变量定义。 ```typescript let outerVar = 'I am outer '; @@ -710,7 +710,7 @@ func(); ### 函数调用 -调用函数以执行其函数体，实参值会赋值给函数的形参。 +调用函数执行其函数体，实参赋值给形参。 如果函数定义如下： @@ -730,7 +730,7 @@ console.log(x); // 输出: hello world ### 函数类型 -函数类型通常用于定义回调函数： +函数类型用于定义回调函数。 ```typescript type trigFunc = (x: number) => number // 这是一个函数类型 @@ -744,7 +744,7 @@ do_action(Math.sin); // 将函数作为参数传入 ### 箭头函数（又名Lambda函数） -函数可以定义为箭头函数，例如： +函数可定义为箭头函数。 ```typescript let sum = (x: number, y: number): number => { @@ -754,7 +754,7 @@ let sum = (x: number, y: number): number => { 箭头函数的返回类型可以省略，此时返回类型由函数体推断。 -表达式可以指定为箭头函数，使表达更简短，因此以下两种表达方式是等价的： +表达式可以指定为箭头函数，使表达更简短，以下两种表达方式等价： ```typescript let sum1 = (x: number, y: number) => { return x + y; } @@ -763,9 +763,9 @@ let sum2 = (x: number, y: number) => x + y ### 闭包 -闭包是由函数及声明该函数的环境组合而成的。该环境包含了这个闭包创建时作用域内的任何局部变量。 +闭包由函数及声明该函数的环境组合而成。环境包含闭包创建时作用域内的局部变量。 -在下例中，`f`函数返回了一个闭包，它捕获了`count`变量，每次调用`z`，`count`的值会被保留并递增。 +在下例中，`f`函数返回一个闭包，捕获`count`变量。每次调用`z`，`count`值递增。 ```typescript function f(): () => number { @@ -781,7 +781,7 @@ z(); // 返回：2 ### 函数重载 -可以通过编写重载，指定函数的不同调用方式。具体方法是，为同一个函数写入多个同名但签名不同的函数头，函数实现紧随其后。 +可以通过编写重载，指定函数的不同调用方式。为同一个函数写入多个同名但签名不同的函数头，函数实现紧随其后。 ```typescript function foo(x: number): void; /* 第一个函数定义 */ @@ -793,13 +793,13 @@ foo(123); // OK，使用第一个定义 foo('aa'); // OK，使用第二个定义 ``` -不允许重载函数有相同的名字和参数列表，否则将导致编译错误。 +不允许重载函数有相同的名字和参数列表，否则导致编译错误。 ## 类 类声明引入一个新类型，并定义其字段、方法和构造函数。 -在以下示例中，定义了`Person`类，该类具有字段`name`和`surname`、构造函数和方法`fullName`： +在以下示例中，定义了一个`Person`类，该类包含字段`name`和`surname`、构造函数和方法`fullName`： ```typescript class Person { @@ -885,7 +885,7 @@ Person.numberOfPersons; #### 字段初始化 -为了减少运行时错误并提高执行性能， +为了减少运行时错误，提高执行性能， ArkTS要求所有字段在声明时或者构造函数中显式初始化。这和标准TS中的`strictPropertyInitialization`模式一样。 以下代码是在ArkTS中不合法的代码。 @@ -910,7 +910,7 @@ let jack = new Person(); jack.getName().length; // 运行时异常：name is undefined ``` -在ArkTS中，应该这样写代码。 +在ArkTS中，应该这样写代码： ```typescript class Person { @@ -932,7 +932,7 @@ let jack = new Person(); jack.getName().length; // 0, 没有运行时异常 ``` -接下来的代码展示了当`name`的值可以是`undefined`时，应该如何编写代码。 +接下来的代码演示了当`name`可能为`undefined`时的编写方法。 ```typescript class Person { @@ -1011,7 +1011,7 @@ class RectangleSize { } ``` -必须通过类的实例调用实例方法： +需要通过类的实例调用实例方法： ```typescript let square = new RectangleSize(10, 10); @@ -1024,7 +1024,7 @@ square.calculateArea(); // 输出：100 静态方法定义了类作为一个整体的公共行为。 -必须通过类名调用静态方法： +需要通过类名调用静态方法： ```typescript class Cl { @@ -1067,7 +1067,7 @@ class Employee extends Person { } ``` -包含`implements`子句的类必须实现列出的接口中定义的所有方法，但使用默认实现定义的方法除外。 +包含`implements`子句的类必须实现列出的接口中定义的所有方法，但默认实现的方法除外。 ```typescript interface DateInterface { @@ -1083,7 +1083,7 @@ class MyDate implements DateInterface { #### 父类访问 -关键字`super`可用于访问父类的实例字段、实例方法和构造函数。在实现子类功能时，可以通过该关键字从父类中获取所需接口： +关键字`super`可用于访问父类的实例字段、实例方法和构造函数。实现子类功能时，通过该关键字从父类中获取所需接口。 ```typescript class RectangleSize { @@ -1116,7 +1116,7 @@ class FilledRectangle extends RectangleSize { #### 方法重写 -子类可以重写其父类中定义的方法的实现。重写的方法必须具有与原始方法相同的参数类型和相同或派生的返回类型。 +子类可以重写父类方法的实现。重写的方法必须具有相同的参数类型和相同或派生的返回类型。 ```typescript class RectangleSize { @@ -1136,7 +1136,7 @@ class Square extends RectangleSize { #### 方法重载签名 -通过重载签名，指定方法的不同调用。具体方法为，为同一个方法写入多个同名但签名不同的方法头，方法实现紧随其后。 +通过重载签名，指定方法的不同调用。为同一个方法写入多个同名但签名不同的方法头，方法实现紧随其后。 ```typescript class C { @@ -1150,7 +1150,7 @@ c.foo(123); // OK，使用第一个签名 c.foo('aa'); // OK，使用第二个签名 ``` -如果两个重载签名的名称和参数列表均相同，则为错误。 +当两个重载签名的名称和参数列表相同时，将导致错误。 ### 构造函数 @@ -1174,11 +1174,11 @@ class Point { let p = new Point(); ``` -在这种情况下，默认构造函数使用字段类型的默认值初始化实例中的字段。 +在这种情况下，默认构造函数将使用字段类型的默认值来初始化实例中的字段。 #### 派生类的构造函数 -构造函数函数体的第一条语句可以使用关键字`super`来显式调用直接父类的构造函数。 +构造函数函数体的第一条语句可以使用关键字`super`来显式调用直接基类的构造函数。 ```typescript class RectangleSize { @@ -1195,7 +1195,7 @@ class Square extends RectangleSize { #### 构造函数重载签名 -可以通过编写重载签名，指定构造函数的不同调用方式。具体方法是，为同一个构造函数写入多个同名但签名不同的构造函数头，构造函数实现紧随其后。 +可以通过编写重载签名，指定构造函数的不同调用方式。为同一个构造函数写入多个同名但签名不同的构造函数头，构造函数实现紧随其后。 ```typescript class C { @@ -1208,7 +1208,7 @@ let c1 = new C(123); // OK，使用第一个签名 let c2 = new C('abc'); // OK，使用第二个签名 ``` -如果两个重载签名的名称和参数列表均相同，则为错误。 +如果两个重载签名的名称和参数列表相同，则视为错误。 ### 可见性修饰符 @@ -1256,9 +1256,9 @@ class Derived extends Base { ### 对象字面量 -对象字面量是一个表达式，可用于创建类实例并提供一些初始值。它在某些情况下更方便，可以用来代替`new`表达式。 +对象字面量是一个表达式，可用于创建类实例并提供一些初始值。它在某些情况下更方便，可以用来代替`new`关键字。 -对象字面量的表示方式是：封闭在花括号对({})中的'属性名：值'的列表。 +对象字面量的表示方式为：花括号内包含的'属性名：值'的列表。 ```typescript class C { @@ -1269,7 +1269,7 @@ class C { let c: C = {n: 42, s: 'foo'}; ``` -ArkTS是静态类型语言，如上述示例所示，对象字面量只能在可以推导出该字面量类型的上下文中使用。其他正确的例子： +ArkTS是静态类型语言。对象字面量只能在能推导出其类型的上下文中使用。其他正确示例如下： ```typescript class C { @@ -1289,7 +1289,7 @@ function bar(): C { } ``` -也可以在数组元素类型或类字段类型中使用： +对象字面量还可以在数组元素类型或类字段类型中使用。 ```typescript class C { @@ -1301,7 +1301,7 @@ let cc: C[] = [{n: 1, s: 'a'}, {n: 2, s: 'b'}]; #### `Record`类型的对象字面量 -泛型`Record`用于将类型（键类型）的属性映射到另一个类型（值类型）。常用对象字面量来初始化该类型的值： +泛型`Record`用于将类型（键类型）的属性映射到另一个类型（值类型）。通常用对象字面量来初始化该类型的值： ```typescript let map: Record = { @@ -1327,9 +1327,9 @@ let map: Record = { ### 抽象类 -带有`abstract`修饰符的类称为抽象类。抽象类可用于表示一组更具体的概念所共有的概念。 +带有`abstract`修饰符的类称为抽象类。抽象类用于表示一组更具体概念的共性。 -尝试创建抽象类的实例会导致编译错误： +创建抽象类的实例会导致编译错误。 ```typescript abstract class X { @@ -1342,7 +1342,7 @@ abstract class X { let x = new X(666) //编译时错误：不能创建抽象类的具体实例 ``` -抽象类的子类可以是抽象类也可以是非抽象类。抽象父类的非抽象子类可以实例化。因此，执行抽象类的构造函数和该类非静态字段的字段初始化器： +抽象类的子类可以是抽象类或非抽象类。抽象父类的非抽象子类可以实例化。因此，执行抽象类的构造函数和非静态字段的初始化器： ```typescript abstract class Base { @@ -1363,9 +1363,9 @@ let x = new Derived(666); #### 抽象方法 -带有`abstract`修饰符的方法称为抽象方法，抽象方法可以被声明但不能被实现。 +抽象方法使用`abstract`修饰符声明，但不提供具体实现。 -只有抽象类内才能有抽象方法，如果非抽象类具有抽象方法，则会发生编译时错误： +只有抽象类可以有抽象方法。非抽象类具有抽象方法会导致编译错误。 ```typescript class Y { @@ -1375,9 +1375,9 @@ class Y { ## 接口 -接口声明引入新类型。接口是定义代码协定的常见方式。 +接口声明引入新类型。接口用于定义代码协定。 -任何一个类的实例只要实现了特定接口，就可以通过该接口实现多态。 +类的实例实现特定接口后，即可通过该接口实现多态。 接口通常包含属性和方法的声明。 @@ -1420,7 +1420,7 @@ class RectangleSize implements AreaSize { 接口属性可以是字段、getter、setter或getter和setter组合的形式。 -属性字段只是getter/setter对的便捷写法。以下表达方式是等价的： +属性字段是getter/setter对的便捷写法。以下方式等效： ```typescript interface Style { @@ -1478,7 +1478,7 @@ interface ExtendedStyle extends Style { ### 抽象类和接口 -抽象类与接口都无法实例化。抽象类是类的抽象，抽象类用来捕捉子类的通用特性，接口是行为的抽象。在ArkTS中抽象类与接口的区别如下： +抽象类与接口均无法实例化。抽象类用于捕捉子类的通用特性，接口用于定义行为。在ArkTS中，抽象类与接口的区别如下： * 一个类只能继承一个抽象类，而一个类可以实现一个或多个接口； ```typescript @@ -1549,7 +1549,7 @@ let s = new CustomStack(); s.push('hello'); ``` -编译器在使用泛型类型和函数时会确保类型安全。参见以下示例： +编译器确保泛型类型和函数的类型安全。参见以下示例： ```typescript let s = new CustomStack(); @@ -1572,11 +1572,11 @@ class MyHashMap { } ``` -在上面的例子中，`Key`类型扩展了`Hashable`，`Hashable`接口的所有方法都可以为key调用。 +在上述示例中，`Key`类型扩展了`Hashable`，`Hashable`接口的所有方法都可以为key调用。 ### 泛型函数 -使用泛型函数可编写更通用的代码。比如返回数组最后一个元素的函数： +使用泛型函数可编写更通用的代码。例如，返回数组最后一个元素的函数： ```typescript function last(x: number[]): number { @@ -1585,7 +1585,7 @@ function last(x: number[]): number { last([1, 2, 3]); // 3 ``` -如果需要为任何数组定义相同的函数，使用类型参数将该函数定义为泛型： +如果需要为数组定义相同的函数，使用类型参数将该函数定义为泛型： ```typescript function last(x: T[]): T { @@ -1593,9 +1593,9 @@ function last(x: T[]): T { } ``` -现在，该函数可以与任何数组一起使用。 +该函数支持所有数组。 -在函数调用中，类型实参可以显式或隐式设置： +在函数调用中，类型实参可以显式设置或隐式推断。 ```typescript // 显式设置的类型实参 @@ -1609,7 +1609,7 @@ let res: number = last([1, 2, 3]); ### 泛型默认值 -泛型类型的类型参数可以设置默认值，这样无需指定实际类型实参，直接使用泛型类型名称即可。以下示例展示了类和函数的这一特性。 +泛型类型的类型参数可以设置默认值，这样无需指定实际类型实参，直接使用泛型类型名称即可。以下示例展示了这一特性。 ```typescript class SomeType {} @@ -1629,7 +1629,7 @@ foo(); ## 空安全 -默认情况下，ArkTS中的所有类型都不允许为空，这类似于TypeScript的(`strictNullChecks`)模式，但规则更严格。 +默认情况下，ArkTS中的所有类型都不允许为空，类似于TypeScript的(`strictNullChecks`)模式，但规则更严格。 在下面的示例中，所有行都会导致编译时错误： @@ -1667,11 +1667,11 @@ function foo(a: A | null) { ### 空值合并运算符 -空值合并二元运算符`??`用于检查左侧表达式的求值是否等于`null`或者`undefined`。如果是，则表达式的结果为右侧表达式；否则，结果为左侧表达式。 +空值合并二元运算符`??`用于检查左侧表达式是否等于`null`或`undefined`。如果是，结果为右侧表达式；否则，结果为左侧表达式。 -换句话说，`a ?? b`等价于三元运算符`(a != null && a != undefined) ? a : b`。 +`a ?? b`等价于三元运算符`(a != null && a != undefined) ? a : b`。 -在以下示例中，`getNick`方法返回已设置的昵称，若未设置则返回空字符串。 +在以下示例中，`getNick`方法返回已定义的昵称，若未定义则返回空字符串。 ```typescript class Person { @@ -1709,9 +1709,9 @@ class Person { **说明**：`getSpouseNick`的返回类型必须为`string | null | undefined`，因为该方法在某些情况下会返回`null`或`undefined`。 -可选链可以任意长，可以包含任意数量的`?.`运算符。 +可选链可以包含任意数量的`?.`运算符。 -在以下示例中，如果`Person`实例的`spouse`属性不为空，并且`spouse`的`nick`属性也不为空时，输出`spouse.nick`。否则，输出`undefined`。 +在以下示例中，如果`Person`实例的`spouse`属性不为`undefined`，并且`spouse`的`nick`属性也不为`undefined`时，输出`spouse.nick`。否则，输出`undefined`。 ```typescript class Person { @@ -1730,17 +1730,17 @@ p.spouse?.nick; // undefined ## 模块 -程序可划分为多组编译单元或模块。 +程序可划分为多个编译单元或模块。 -每个模块都有其自己的作用域，即，在模块中创建的任何声明（变量、函数、类等）在该模块之外都不可见，除非它们被显式导出。 +每个模块都有其自己的作用域，模块中的任何声明（变量、函数、类等）在该模块之外都不可见，除非显式导出。 -与此相对，从另一个模块导出的变量、函数、类、接口等必须首先导入到模块中。 +与此相对，必须首先将另一个模块导出的变量、函数、类、接口等导入到当前模块中。 ### 导出 可以使用关键字`export`导出顶层的声明。 -未导出的声明名称被视为私有名称，只能在声明该名称的模块中使用。 +未导出的声明名称被视为私有名称，仅在声明该名称的模块中使用。 ```typescript export class Point { @@ -1761,14 +1761,14 @@ export function Distance(p1: Point, p2: Point): number { #### 静态导入 -导入声明用于导入从其他模块导出的实体，并在当前模块中提供其绑定。导入声明由两部分组成： +导入声明用于从其他模块导入实体并在当前模块中提供绑定。导入声明包含两部分： * 导入路径，用于指定导入的模块； * 导入绑定，用于定义导入的模块中的可用实体集和使用形式（限定或不限定使用）。 -导入绑定可以有几种形式。 +导入绑定有几种形式。 -假设模块具有路径“./utils”和导出实体“X”和“Y”。 +假设模块路径为“./utils”，导出实体为“X”和“Y”。 导入绑定`* as A`表示绑定名称“A”，通过`A.name`可访问从导入路径指定的模块导出的所有实体： @@ -1796,8 +1796,8 @@ X // 编译时错误：'X'不可见 ``` #### 动态导入 -应用开发的有些场景中，如果希望根据条件导入模块或者按需导入模块，可以使用动态导入代替静态导入。 -import()语法被称为动态导入（dynamic import），是一种类似函数的表达式，用于动态导入模块。调用这种方式，会返回一个promise。 +在某些应用开发场景中，如果希望根据条件导入模块或按需导入模块，可以使用动态导入代替静态导入。 +import()语法是一种类似函数的表达式，用于动态导入模块。调用这种方式会返回一个promise。 如下例所示，import(modulePath)可以加载模块并返回一个promise，该promise resolve为一个包含其所有导出的模块对象。该表达式可以在代码中的任意位置调用。 ```typescript @@ -1816,7 +1816,7 @@ import("./Calc").then((obj: ESObject) => { }); ``` -如果在异步函数中，可以使用let module = await import(modulePath)。 +在异步函数中，使用 `let module = await import(modulePath)`。 ```typescript // say.ts @@ -1828,7 +1828,7 @@ export function bye() { } ``` -那么，可以像下面这样进行动态导入： +可以像下面这样进行动态导入： ```typescript async function test() { @@ -1840,19 +1840,19 @@ async function test() { } ``` -更多的使用动态import的业务场景和使用实例见[动态import](../arkts-utils/arkts-dynamic-import.md)。 +更多关于动态import的业务场景和使用实例，请参见[动态import](../arkts-utils/arkts-dynamic-import.md)。 ### 顶层语句 -顶层语句是指在模块的最外层直接编写的语句，这些语句不被包裹在任何函数、类、块级作用域中。顶层语句包括变量声明、函数声明、表达式等。 +顶层语句是在模块最外层编写的语句，不被包裹在任何函数、类、块级作用域中。包括变量声明、函数声明、表达式等。 ## 关键字 ### this -关键字`this`只能在类的实例方法中使用。 +关键字`this`只能在类的实例方法中使用，指向调用实例方法的对象或正在构造的对象。 **示例** @@ -1865,7 +1865,7 @@ class A { } ``` -使用限制： +使用限制如下： * 不支持`this`类型 * 不支持在函数和类的静态方法中使用`this` @@ -1886,7 +1886,7 @@ function foo(arg1: number) { } ``` -关键字`this`的指向: +关键字`this`的指向： * 调用实例方法的对象 * 正在构造的对象 @@ -1920,7 +1920,7 @@ class MyClass { ClassAuthor({authorName: "Bob"}) // 编译错误：注解需要'@'为前缀 @ ClassAuthor({authorName: "Bob"}) // 编译错误：符号`@`和名称之间不允许有空格和行分隔符 ``` -如果在使用位置无法访问注解名称，则会发生编译错误。 +如果无法访问注解名称，将发生编译错误。 注解声明可以导出并在其他文件中使用。 多个注解可以应用于同一个声明（注解间的先后顺序不影响使用）。 @@ -1970,9 +1970,9 @@ import {X} from './a'; data: number = X.x; // 编译错误：注解字段的默认值必须使用常量表达式 } ``` -注解必须定义在顶层作用域（top-level），否则会出现编译报错。
+注解需定义在顶层作用域（top-level），否则将导致编译错误。
注解的名称不能与注解定义所在作用域内可见的其他实体名称相同，否则会出现编译报错。
-注解不支持类型Typescript中的合并，否则会出现编译报错。 +注解不支持Typescript中的类型合并，否则会出现编译报错。 ```typescript namespace ns { @interface MataInfo { // 编译错误：注解必须定义在顶层作用域 @@ -1996,12 +1996,12 @@ class Position { // 编译错误：注解的名称不能与注解定义所在作 data: sting; } ``` -注解不是类型，把注解当类型使用时会出现编译报错（例如：对注解使用类型别名）。 +注解不是类型，不能作为类型使用，否则会出现编译报错（例如：对注解使用类型别名）。 ```typescript @interface Position {} type Pos = Position; // 编译错误：注解不是类型 ``` -注解不支持在类的getter和setter方法添加，若添加注解会编译报错。 +注解不支持在类的getter和setter方法中使用，若使用注解会编译报错。 ```typescript @interface ClassAuthor { authorName: string; @@ -2032,7 +2032,7 @@ class MyClass { } @interface MyAnno {} ``` -当前仅允许对`class declarations`和`method declarations`使用注解，对类和方法可以同时使用同一个注解。
注解用法示例如下： +当前仅允许对`class declarations`和`method declarations`使用注解，且对类和方法可以同时使用同一个注解。
注解用法示例如下： ```typescript @ClassPreamble({authorName: "John", revision: 2}) class C1 { @@ -2068,7 +2068,7 @@ class C1 { // ... } ``` -如果注解中定义了数组类型的字段，则使用数字字面量来设置该字段的值。 +如果注解中定义了数组类型的字段，则使用常量表达式（例如数字字面量）来设置该字段的值。 ```typescript @interface ClassPreamble { authorName: string; @@ -2086,7 +2086,7 @@ class C3 { // ... } ``` -如果不需要定义注解字段，注解名称后的括号可省略。 +如果不需要定义注解字段，可省略注解名称后的括号。 ```typescript @MyAnno class C4 { @@ -2095,12 +2095,12 @@ class C4 { ``` #### 导入和导出注解 -注解也可以被导入导出。针对导出，当前仅支持在定义时的导出，即`export @interface`的形式。
+注解可以被导入和导出。针对导出，当前仅支持在定义时的导出，即`export @interface`的形式。
**示例：** ```typescript export @interface MyAnno {} ``` -针对导入，当前仅支持`import {}`和`import * as`两种方式。
+当前仅支持`import {}`和`import * as`两种导入方式。
**示例：** ```typescript // a.ets @@ -2121,13 +2121,13 @@ class C { ```typescript import { MyAnno as Anno } from './a'; // 编译错误：不允许在import中对注解进行重命名 ``` -不允许对注解使用任何其他形式的import/export，会发生编译报错。 +不允许对注解使用任何其他形式的import/export，否则会发生编译报错。 - 由于注解不是类型，因此禁止使用`type`符号进行导入和导出。 ```typescript import type { MyAnno } from './a'; // 编译错误：注解不允许使用'type'符号进行导入和导出 ``` -- 如果仅从模块导入注解，则不会触发模块的副作用。 +- 仅从模块导入注解不会触发模块的副作用。 ```typescript // a.ets export @interface Anno {} @@ -2149,7 +2149,7 @@ class X { #### .d.ets文件中的注解 注解可以出现在.d.ets文件中。 -可以在.d.ets文件中用环境声明（ambient declaration）来声明注解。 +可以在.d.ets文件中用环境声明来声明注解。 ```typescript ambientAnnotationDeclaration: 'declare' userDefinedAnnotationDeclaration @@ -2172,7 +2172,7 @@ export declare @interface NameAnno{name: string = ""} // a.ets export @interface NameAnno{name: string = ""} // ok ``` -环境声明的注解和class类似，也可以被import使用。 +环境声明的注解可以被import使用。 ```typescript // a.d.ets export declare @interface MyAnno {} @@ -2187,7 +2187,7 @@ class C { ``` **编译器自动生成的.d.ets文件**
-当编译器根据ets代码自动生成.d.ets文件时，存在以下2种情况。 +编译器根据ets代码自动生成.d.ets文件时，存在以下两种情况。 1. 当注解定义被导出时，源代码中的注解定义会在.d.ets文件中保留。 ```typescript // a.ets @@ -2200,10 +2200,10 @@ export @interface ClassAuthor {} // a.d.ets 编译器生成的声明文件 export declare @interface ClassAuthor {} ``` -2. 当下面所有条件成立时，源代码中实体的注解实例会在.d.ets文件中保留。
+2. 当以下所有条件满足时，源代码中实体的注解实例将在.d.ets文件中保留。
2.1 注解的定义被导出（import的注解也算作被导出）。
- 2.2 如果实体是类，则类被导出。
- 2.3 如果实体是方法，则类被导出，并且方法不是私有方法。 + 2.2 实体是类时，类被导出。
+ 2.3 实体是方法时，类被导出且方法不是私有方法。 ```typescript // a.ets import { ClassAuthor } from './author'; @@ -2238,7 +2238,7 @@ export declare class C { ``` **开发者生成的.d.ets文件**
-开发者生成的.d.ets文件中的注解信息不会自动应用到实现的源代码中。
+开发者生成的.d.ets文件中的注解信息不会自动应用到源代码中。
**示例：** ```typescript // b.d.ets 开发者生成的声明文件 @@ -2260,7 +2260,7 @@ class C { 在最终编译产物中，class C没有注解。 #### 重复注解和继承 -同一个实体不能重复使用同一个注解，否则会有编译报错。 +同一实体不能重复使用同一注解，否则将导致编译错误。 ```typescript @MyAnno({name: "123", value: 456}) @MyAnno({name: "321", value: 654}) // 编译错误：不允许重复注释 @@ -2268,10 +2268,10 @@ class C { // ... } ``` -子类不会继承基类的注解和基类方法的注解。 +子类不会继承基类的注解。 #### 注解和抽象类、抽象方法 -不支持对抽象类和抽象方法使用注解，否则会有编译报错。 +不支持对抽象类或抽象方法使用注解，否则会导致编译错误。 ```typescript @MyAnno // 编译错误：不允许在抽象类和抽象方法上使用注解 abstract class C { diff --git a/zh-cn/application-dev/quick-start/typescript-to-arkts-migration-guide.md b/zh-cn/application-dev/quick-start/typescript-to-arkts-migration-guide.md index 3a698f5ada4016ef75a030abc2fbc890db9dd30e..15f71b14a48900c20d4f31a2bd38e29e925e5d74 100644 --- a/zh-cn/application-dev/quick-start/typescript-to-arkts-migration-guide.md +++ b/zh-cn/application-dev/quick-start/typescript-to-arkts-migration-guide.md @@ -1,6 +1,6 @@ # 从TypeScript到ArkTS的适配规则 -ArkTS规范约束了TypeScript（简称TS）中影响开发正确性或增加运行时开销的特性。本文罗列了ArkTS中限制的TS特性，并提供重构代码的建议。ArkTS保留了TS大部分语法特性，未在本文中约束的TS特性，ArkTS完全支持。例如，ArkTS支持自定义装饰器，语法与TS一致。按本文约束进行代码重构后，代码仍为合法有效的TS代码。 +ArkTS规范约束了影响开发正确性或增加运行时开销的TS特性。本文罗列了ArkTS中限制的TS特性，并提供重构代码的建议。ArkTS保留了TS大部分语法特性，未在本文中约束的TS特性，ArkTS完全支持。例如，ArkTS支持自定义装饰器，语法与TS一致。按本文约束进行代码重构后，代码仍为合法有效的TS代码。 **示例** @@ -44,7 +44,7 @@ function addTen(x: number): number { ### 强制使用静态类型 -静态类型是ArkTS的重要特性之一。当程序使用静态类型时，所有类型在编译时已知，这有助于开发者理解代码中的数据结构。编译器可以提前验证代码的正确性，减少运行时的类型检查，从而提升性能。 +静态类型是ArkTS的重要特性。使用静态类型时，所有类型在编译时已知，这有助于开发者理解代码中的数据结构。编译器可以提前验证代码的正确性，减少运行时的类型检查，从而提升性能。 基于上述考虑，ArkTS中禁止使用`any`类型。 @@ -67,17 +67,17 @@ if (!res.succeeded()) { } ``` -`any`类型在TypeScript中并不常见，仅约1%的TypeScript代码库使用。代码检查工具（例如ESLint）也制定了一系列规则来禁止使用`any`。因此，虽然禁止`any`将导致代码重构，但重构量很小，有助于整体性能提升。 +`any`类型在TypeScript代码库中的使用率低于1%。代码检查工具（如ESLint）已制定规则禁止使用`any`。尽管禁止`any`会导致代码重构，但重构量小，有助于提升整体性能。 ### 禁止在运行时变更对象布局 -为实现最佳性能，ArkTS要求在程序执行期间不能更改对象的布局。换句话说，ArkTS禁止以下行为： +为实现最佳性能，ArkTS要求在程序执行期间不能更改对象的布局，具体禁止以下行为： - 向对象中添加新的属性或方法。 - 从对象中删除已有的属性或方法。 - 将任意类型的值赋值给对象属性。 -TypeScript编译器已经禁止了许多此类操作。然而，有些操作还是有可能绕过编译器的，例如，使用`as any`转换对象的类型，或者在编译TS代码时关闭严格类型检查的配置，或者在代码中通过`@ts-ignore`忽略类型检查。 +TypeScript编译器已经禁止了许多此类操作。然而，有些操作还是有可能绕过编译器的，例如，使用`as any`转换对象的类型，或者关闭编译器的严格类型检查配置，或者在代码中通过`@ts-ignore`忽略类型检查。 在ArkTS中，严格类型检查不是可配置项。ArkTS强制进行部分严格类型检查，并通过规范禁止使用`any`类型，禁止在代码中使用`@ts-ignore`。 @@ -126,9 +126,9 @@ let p6 = new Point(6.0, 6.0); console.log('Distance between p5 and p6: ' + distance(p5, p6)); ``` -修改对象布局会影响代码可读性和运行时性能。定义类后，在其他地方修改对象布局，容易引起困惑乃至引入错误。此外，还需要额外的运行时支持，增加执行开销。这与静态类型约束冲突：使用显式类型时，不应添加或删除属性。 +修改对象布局会影响代码可读性和运行时性能。定义类后，其他地方修改对象布局容易引起混淆和错误。这需要额外的运行时支持，增加执行开销。使用显式类型时，不应添加或删除属性，这与静态类型约束冲突。 -当前，只有少数项目允许在运行时变更对象布局，一些常用的代码检查工具也增加了相应的限制规则。这个约束只会导致少量代码重构，但会提升性能。 +当前，只有少数项目允许在运行时变更对象布局，一些常用的项目也增加了相应的限制规则。这个约束只会导致少量代码重构，但会提升性能。 ### 限制运算符的语义 @@ -142,9 +142,9 @@ let t = +42; // 合法运算 let s = +'42'; // 编译时错误 ``` -使用额外的语义重载语言运算符会增加语言规范的复杂度，而且，开发者还被迫牢记所有可能的例外情况及对应的处理规则。在特定情况下，这会导致不必要的运行时开销。 +使用额外的语义重载语言运算符会增加语言规范的复杂度。开发者还被迫牢记所有可能的例外情况及对应的处理规则。在特定情况下，这会导致不必要的运行时开销。 -当前只有不到1%的代码库使用该特性。因此，尽管限制运算符的语义需要重构代码，但重构量很小且非常容易操作，并且，通过重构能使代码更清晰、具备更高性能。 +当前只有不到1%的代码库使用该特性。因此，尽管限制运算符的语义需要重构代码，但重构量很小且非常容易操作。通过重构能使代码更清晰、具备更高性能。 ### 不支持 structural typing @@ -186,18 +186,18 @@ let t: T = new T(); greeter(t); // 是否允许？ ``` -具体采用哪种方法，情况如下： +具体情况如下： - `T`和`U`没有继承关系或没有`implements`相同的接口，但由于它们具有相同的`public`API，它们“在某种程度上是相等的”，所以上述两个问题的答案都是“是”。 - `T`和`U`没有继承关系或没有`implements`相同的接口，应当始终被视为完全不同的类型，因此上述两个问题的答案都是“否”。 -采用第一种方法的语言支持structural typing，而采用第二种方法的语言则不支持structural typing。目前TypeScript支持structural typing，而ArkTS不支持。 +第一种方法支持structural typing，第二种方法不支持。TypeScript支持structural typing，ArkTS不支持。 关于structural typing是否有助于生成清晰、易理解的代码，目前尚未有定论。ArkTS不支持structural typing的原因如下： -因为对structural typing的支持是一个重大的特性，需要在语言规范、编译器和运行时进行大量的考虑和仔细的实现。另外，由于ArkTS使用静态类型，运行时为了支持这个特性需要额外的性能开销。 +因为structural typing是一个重要特性，需要在语言规范、编译器和运行时进行大量考虑和仔细实现。此外，由于ArkTS采用静态类型，运行时支持该特性需要额外的性能开销。 -鉴于此，当前我们还不支持该特性。根据实际场景的需求和反馈，我们后续会重新加以考虑。更多案例和建议请参考[约束说明](#约束说明)。 +鉴于此，目前尚不支持该特性。根据实际场景的需求和反馈，我们将在后续版本中重新评估。更多案例和建议，请参考[约束说明](#约束说明)。 ## 约束说明 @@ -209,7 +209,7 @@ greeter(t); // 是否允许？ **错误码：10605001** -在ArkTS中，对象的属性名不能为数字或字符串。例外：ArkTS支持属性名为字符串字面量和枚举中的字符串值。通过属性名访问类的属性，通过数值索引访问数组元素。 +对象的属性名不能为数字或字符串。支持属性名为字符串字面量和枚举中的字符串值。通过属性名访问类的属性，通过数值索引访问数组元素。 **TypeScript** @@ -259,7 +259,7 @@ let obj: Record = { **错误码：10605002** -在ArkTS中，对象布局在编译时确定，不可在运行时更改，因此不支持`Symbol()`API。该API在静态类型语言中通常没有实际意义。 +对象布局在编译时确定，不可在运行时更改，因此不支持`Symbol()`API。静态类型语言中该API通常没有实际意义。 ArkTS只支持`Symbol.iterator`。 @@ -297,7 +297,7 @@ class C { **错误码：10605004** -类型（类、接口、枚举）和命名空间的名称必须唯一，并且不能与其他名称（如变量名、函数名）重复。 +类型（类、接口、枚举）和命名空间的名称必须唯一，且不能与变量名、函数名等其他名称重复。 **TypeScript** @@ -321,7 +321,7 @@ type T = number[] // 为避免名称冲突，此处不允许使用X **错误码：10605005** -`let`关键字可以在块级作用域中声明变量，帮助程序员避免错误。因此，ArkTS不支持`var`，请使用`let`声明变量。 +`let`关键字在块级作用域中声明变量，有助于避免编程错误。因此，ArkTS不支持`var`，请使用`let`声明变量。 **TypeScript** @@ -378,7 +378,7 @@ scopedLet = 5; //编译时错误 **错误码：10605008** -ArkTS不支持`any`和`unknown`类型。显式指定具体类型。 +ArkTS不支持`any`和`unknown`类型。需显式指定具体类型。 **TypeScript** @@ -523,7 +523,7 @@ class C { **说明** -当前不支持静态块的语法。支持该语法后，在.ets文件中使用静态块需遵循此约束。 +当前不支持静态块语法。支持后，在.ets文件中使用静态块需遵循相关约束。 ### 不支持index signature @@ -612,7 +612,7 @@ interface Employee extends Identity, Contact {} **错误码：10605021** -ArkTS不支持`this`类型，改用显式具体类型。 +不支持`this`类型，改用显式具体类型。 **TypeScript** @@ -654,7 +654,7 @@ class C { **错误码：10605022** -ArkTS不支持条件类型别名，建议引入带显式约束的新类型，或使用`Object`进行逻辑重构。 +ArkTS不支持条件类型别名，建议引入带显式约束的新类型或使用`Object`进行逻辑重构。 不支持`infer`关键字。 **TypeScript** @@ -685,7 +685,7 @@ type YI> = Item **错误码：10605025** -ArkTS不支持在`constructor`中声明类字段。在`class`中声明这些字段。 +ArkTS不支持在`constructor`中声明类字段。请在`class`中声明这些字段。 **TypeScript** @@ -779,9 +779,9 @@ ArkTS不支持索引访问类型。 **错误码：10605029** -ArkTS不支持动态声明字段，不支持动态访问字段。只能访问已在类中声明或者继承可见的字段，访问其他字段将会造成编译时错误。 +ArkTS不支持动态声明或访问字段。只能访问类中声明或继承的可见字段，访问其他字段会导致编译错误。 使用点操作符访问字段，例如（`obj.field`），不支持索引访问（`obj[field]`）。 -ArkTS支持通过索引访问`TypedArray`（例如`Int32Array`）中的元素。 +ArkTS支持通过索引访问`TypedArray`中的元素。 **TypeScript** @@ -848,7 +848,7 @@ arr[0]; **错误码：10605030** -ArkTS不支持structural typing，编译器无法比较两种类型的`public`API并决定它们是否相同。使用其他机制，例如继承、接口或类型别名。 +ArkTS不支持structural typing，编译器无法比较两种类型的`public`API并决定它们是否相同。建议使用其他机制，例如继承、接口或类型别名。 **TypeScript** @@ -962,8 +962,8 @@ foo(new Y()); **错误码：10605034** -如果可以从传递给泛型函数的参数中推断出具体类型，ArkTS允许省略泛型类型实参。否则，省略泛型类型实参会发生编译时错误。 -禁止仅基于泛型函数返回类型推断泛型类型参数。 +如果可以从参数中推断出类型，ArkTS允许省略泛型类型实参。否则，省略泛型类型实参会编译错误。 +禁止仅基于泛型函数的返回类型推断泛型类型参数。 **TypeScript** @@ -1005,11 +1005,11 @@ let z = greet(); **错误码：10605038** -在ArkTS中，需要显式标注对象字面量的类型，否则，将发生编译时错误。在某些场景下，编译器可以根据上下文推断出字面量的类型。 +在ArkTS中，需要显式标注对象字面量的类型，否则会发生编译错误。某些场景下，编译器可以根据上下文推断字面量类型。 -在以下上下文中不支持使用字面量初始化类和接口： +以下上下文中不支持使用字面量初始化类和接口： -* 初始化具有`any`、`Object`或`object`类型的任何对象 +* 初始化具有`any`、`Object`或`object`类型的对象 * 初始化带有方法的类或接口 * 初始化包含自定义含参数的构造函数的类 * 初始化带`readonly`字段的类 @@ -1189,7 +1189,7 @@ getPoint({x: 5, y: 10}); **错误码：10605040** -ArkTS不支持使用对象字面量声明类型，可以使用类或者接口声明类型。 +ArkTS不支持使用对象字面量声明类型，可以使用类或接口声明类型。 **TypeScript** @@ -1223,7 +1223,7 @@ type S = Set **错误码：10605043** -ArkTS将数组字面量的类型推断为所有元素的联合类型。如果其中任何一个元素的类型无法推导，则编译时会发生错误。 +ArkTS将数组字面量的类型推断为所有元素的联合类型。若任一元素类型无法推导，编译时将报错。 **TypeScript** @@ -1251,7 +1251,7 @@ let a2: C[] = [{n: 1, s: '1'}, {n: 2, s: '2'}]; // a2的类型为“C[]” **错误码：10605046** -ArkTS不支持函数表达式，使用箭头函数。 +ArkTS不支持函数表达式，但支持使用箭头函数。 **TypeScript** @@ -1277,7 +1277,7 @@ let f = (s: string) => { **错误码：10605050** -ArkTS不支持类表达式，必须显式声明一个类。 +ArkTS不支持类表达式，需要显式声明类。 **TypeScript** @@ -1319,7 +1319,7 @@ const rectangle = new Rectangle(0.0, 0.0); **错误码：10605051** -ArkTS不允许类被`implements`，只有接口可以被`implements`。 +在ArkTS中，只有接口可以被`implements`，类不支持此用法。 **TypeScript** @@ -1353,8 +1353,8 @@ class C1 implements C { **错误码：10605052** -ArkTS不支持修改对象的方法。在静态语言中，对象布局固定，类的所有实例共享同一个方法。 -若需为特定对象添加方法，可封装函数或采用继承机制。 +ArkTS不支持修改对象的方法。在静态语言中，对象布局固定，所有实例共享同一个方法。 +若需为特定对象添加方法，可封装函数或使用继承机制。 **TypeScript** @@ -1414,9 +1414,9 @@ c3.foo(); // Extra foo **错误码：10605053** -在ArkTS中，`as`关键字是类型转换的唯一语法，错误的类型转换会导致编译时错误或者运行时抛出`ClassCastException`异常。ArkTS不支持使用``语法进行类型转换。 +在ArkTS中，`as`关键字是唯一的类型转换语法，错误的类型转换会导致编译错误或运行时抛出`ClassCastException`异常。ArkTS不支持使用``语法进行类型转换。 -需要将`primitive`类型（如`number`或`boolean`）转换为引用类型时，请使用`new`表达式。 +将`primitive`类型转换为引用类型时，使用`new`表达式。 **TypeScript** @@ -1472,7 +1472,7 @@ let e2 = (new Number(5.0)) instanceof Number; // true **错误码：10605054** -不支持使用JSX。 +禁止使用JSX。 ### 一元运算符`+`、`-`和`~`仅适用于数值类型 @@ -1482,7 +1482,7 @@ let e2 = (new Number(5.0)) instanceof Number; // true **错误码：10605055** -ArkTS仅允许一元运算符用于数值类型，否则会导致编译时错误。与TypeScript不同，ArkTS不支持隐式字符串到数值的转换，必须进行显式转换。 +ArkTS仅支持一元运算符对数值类型进行操作，否则将导致编译错误。与TypeScript不同，ArkTS不支持隐式字符串到数值的转换，必须进行显式转换。 **TypeScript** @@ -1538,7 +1538,7 @@ let y = +returnString(); // 编译时错误 **错误码：10605059** -在ArkTS中，对象布局在编译时确定，运行时不可更改。因此，删除属性的操作没有意义。 +在ArkTS中，对象布局于编译时确定，运行时不可更改。因此删除属性的操作没有意义。 **TypeScript** @@ -1573,7 +1573,7 @@ p.y = null; **错误码：10605060** -ArkTS仅支持在表达式中使用`typeof`运算符，不允许使用`typeof`作为类型。 +ArkTS仅支持在表达式中使用`typeof`运算符，不允许将其用作类型。 **TypeScript** @@ -1605,7 +1605,7 @@ let s2: string **错误码：10605065** -TypeScript中，`instanceof`运算符的左操作数类型必须为`any`类型、对象类型或类型参数，否则结果为`false`。ArkTS中，`instanceof`运算符的左操作数类型必须为引用类型（如对象、数组或函数），否则会发生编译时错误。此外，左操作数必须是对象实例。 +在TypeScript中，`instanceof`运算符的左操作数类型必须是`any`类型、对象类型或类型参数，否则结果为`false`。在ArkTS中，`instanceof`运算符的左操作数类型必须是引用类型（例如对象、数组或函数），否则会导致编译时错误。此外，左操作数必须是对象实例。 ### 不支持`in`运算符 @@ -1615,7 +1615,7 @@ TypeScript中，`instanceof`运算符的左操作数类型必须为`any`类型 **错误码：10605066** -在ArkTS中，对象布局在编译时已知且运行时无法修改，因此不支持`in`运算符。需要检查类成员是否存在时，使用`instanceof`代替。 +在ArkTS中，对象布局在编译时确定且运行时不可修改，因此不支持`in`运算符。若需检查类成员是否存在，请使用`instanceof`替代。 **TypeScript** @@ -1647,7 +1647,7 @@ let b = p instanceof Person; // true，且属性name一定存在 **错误码：10605069** -ArkTS不支持解构赋值。可使用其他替代方法，例如，使用临时变量。 +ArkTS不支持解构赋值。可使用其他方法替代，例如使用临时变量。 **TypeScript** @@ -1686,7 +1686,7 @@ for (let i = 1; i < data.length; ++i) { **错误码：10605071** -在ArkTS中，逗号运算符仅适用于`for`循环语句，用于明确执行顺序。 +在ArkTS中，逗号运算符仅用于`for`循环语句中，以明确执行顺序。 >**注意：** 这与声明变量和函数参数传递时使用的逗号分隔符不同。 **TypeScript** @@ -1721,7 +1721,7 @@ x = x++; **错误码：10605074** -ArkTS不支持解构变量声明。解构变量声明是一个依赖于结构兼容性的动态特性，且解构声明中的名称必须与被解构对象中的属性名称一致。 +ArkTS不支持解构变量声明。解构变量声明依赖结构兼容性，名称必须与对象属性一致。 **TypeScript** @@ -1764,7 +1764,7 @@ let y = zp.y; **错误码：10605079** -TypeScript的catch语句中，只能标注`any`或`unknown`类型。ArkTS不支持这些类型，应省略类型标注。 +TypeScript的catch语句只能标注`any`或`unknown`类型。ArkTS不支持这些类型，省略类型标注。 **TypeScript** @@ -1794,7 +1794,7 @@ try { **错误码：10605080** -由于在ArkTS中，对象布局在编译时是确定的并且在运行时无法修改，因此不支持使用`for .. in`迭代一个对象的属性。 +ArkTS不支持使用`for .. in`迭代对象属性。 **TypeScript** @@ -1822,7 +1822,7 @@ for (let i = 0; i < a.length; ++i) { **错误码：10605083** -ArkTS不支持映射类型，使用其他语法来表示相同的语义。 +ArkTS不支持映射类型，可以使用其他语法表示相同语义。 **TypeScript** @@ -1854,7 +1854,7 @@ class CFlags { **错误码：10605084** -ArkTS不支持`with`语句，使用其他语法来表示相同的语义。 +ArkTS不支持`with`语句，使用其他语法表示相同语义。 **TypeScript** @@ -1880,7 +1880,7 @@ let area: number = Math.PI * r * r; **错误码：10605087** -ArkTS只支持抛出`Error`类或其派生类的实例。禁止抛出其他类型的数据，例如`number`或`string`。 +ArkTS只支持抛出`Error`类或其派生类的实例。禁止抛出`number`或`string`等其他类型的数据。 **TypeScript** @@ -1904,7 +1904,7 @@ throw new Error(); **错误码：10605090** -ArkTS在部分场景中支持对函数返回类型进行推断。当`return`语句中的表达式是对某个函数或方法进行调用，且该函数或方法的返回类型没有被显著标注时，会出现编译时错误。在这种情况下，请标注函数返回类型。 +ArkTS在部分场景中支持对函数返回类型进行推断。如果`return`语句中的表达式是对某个函数或方法进行调用，且该函数或方法的返回类型未标注，会出现编译时错误。此时，请标注函数返回类型。 **TypeScript** @@ -1963,7 +1963,7 @@ doOperation(2, 3); **错误码：10605091** -ArkTS要求实参必须直接传递给函数，且必须指定到形参。 +ArkTS要求实参直接传递给函数，并指定到形参。 **TypeScript** @@ -2003,7 +2003,7 @@ function main() { **错误码：10605092** -ArkTS不支持在函数内声明函数，改用lambda函数。 +ArkTS不支持在函数内声明函数，可以改用lambda函数。 **TypeScript** @@ -2091,7 +2091,7 @@ function main(): void { **错误码：10605094** -目前ArkTS不支持生成器函数，可使用`async`或`await`机制处理并行任务。 +目前ArkTS不支持生成器函数，可以使用`async`和`await`机制处理并行任务。 **TypeScript** @@ -2132,7 +2132,7 @@ foo() **错误码：10605096** -ArkTS不支持`is`运算符，必须用`instanceof`运算符替代。在使用之前，必须使用`as`运算符将对象转换为需要的类型。 +ArkTS不支持`is`运算符，必须使用`instanceof`运算符替代。使用前，需用`as`运算符将对象转换为所需类型。 **TypeScript** @@ -2208,9 +2208,9 @@ function main(): void { **错误码：10605099** -ArkTS仅支持使用展开运算符展开数组、`Array`的子类和`TypedArray`（例如`Int32Array`）。仅支持使用在以下场景中： -1. 传递给剩余参数时； -2. 复制一个数组到数组字面量。 +ArkTS仅支持使用展开运算符展开数组、`Array`的子类和`TypedArray`（如`Int32Array`）。仅支持的场景包括： +1. 将参数传递给剩余参数； +2. 将数组复制到数组字面量中。 **TypeScript** @@ -2275,7 +2275,7 @@ let arr4 = [...arr1, 10, ...arr2, 11, ...arr3]; **错误码：106050102** -在TypeScript中，如果一个接口继承了两个具有相同方法的接口，则必须使用联合类型声明该方法的返回值类型。在ArkTS中，由于接口不能包含两个无法区分的方法（如参数列表相同但返回类型不同），因此不能继承具有相同方法的两个接口。 +在TypeScript中，如果一个接口继承了两个具有相同方法的接口，则必须使用联合类型声明该方法的返回值类型。在ArkTS中，接口不能包含两个无法区分的方法（如参数列表相同但返回类型不同），因此不能继承具有相同方法的两个接口。 **TypeScript** @@ -2410,7 +2410,7 @@ interface Document { **错误码：10605104** -ArkTS中，接口不能继承类，只能继承其他接口。 +在ArkTS中，接口不能继承类，只能继承其他接口。 **TypeScript** @@ -2444,7 +2444,7 @@ interface SelectableControl extends Control { **错误码：10605106** -ArkTS不支持构造函数类型，改用lambda函数。 +ArkTS不支持构造函数类型，使用lambda函数替代。 **TypeScript** @@ -2495,7 +2495,7 @@ const person = createPerson(Impersonizer, 'John', 30); **错误码：10605111** -ArkTS不支持使用运行期间计算的表达式初始化枚举成员。枚举中所有显式初始化的成员必须具有相同类型。 +ArkTS不支持使用运行期间计算的表达式初始化枚举成员。枚举中所有显式初始化的成员必须类型相同。 **TypeScript** @@ -2543,7 +2543,7 @@ enum E2 { **错误码：10605113** -ArkTS不支持`enum`声明合并。 +在ArkTS中，不支持`enum`声明合并。 **TypeScript** @@ -2581,7 +2581,7 @@ enum ColorSet { **错误码：10605114** -ArkTS不支持将命名空间用作对象，可以使用类或模块。 +ArkTS不支持将命名空间用作对象，可以使用类或模块替代。 **TypeScript** @@ -2612,7 +2612,7 @@ MyNamespace.x = 2; **错误码：10605116** -在ArkTS中，命名空间用于定义标识符的可见范围，仅在编译时有效。因此，命名空间中不支持非声明语句。可以将非声明语句写在函数中。 +在ArkTS中，命名空间仅在编译时有效，不支持非声明语句。将非声明语句写在函数中。 **TypeScript** @@ -2646,7 +2646,7 @@ A.init(); **错误码：10605121** -ArkTS不支持通过`require`导入和`import`赋值表达式，改用`import`。 +ArkTS不支持`require`导入和`import`赋值表达式，使用`import`替代。 **TypeScript** @@ -2668,7 +2668,7 @@ import * as m from 'mod' **错误码：10605126** -ArkTS不支持`export = ...`语法，改用常规的`export`或`import`。 +ArkTS不支持`export = ...`语法，改用常规的`export`或`import`语句。 **TypeScript** @@ -2710,7 +2710,7 @@ let p = Pt.Point.origin **错误码：10605128** -由于ArkTS本身有与JavaScript交互的机制，ArkTS不支持ambient module声明。 +ArkTS不支持ambient module声明，因为本身存在与JavaScript交互的机制。 **TypeScript** @@ -2735,7 +2735,7 @@ import { normalize } from 'someModule' **错误码：10605129** -在ArkTS中，导入是编译时而非运行时行为，不支持在模块名中使用通配符。 +在ArkTS中，导入是编译时行为，不支持模块名中的通配符。 **TypeScript** @@ -2771,7 +2771,7 @@ console.log('N.foo called: ' + N.foo(42)); **错误码：10605130** -ArkTS不支持通用模块定义（UMD）。因为在ArkTS中没有“脚本”的概念（相对于“模块”）。此外，在ArkTS中，导入是编译时而非运行时特性。改用`export`和`import`语法。 +ArkTS不支持通用模块定义（UMD）。ArkTS中没有“脚本”的概念（相对于“模块”）。此外，导入是编译时时特性。改用`export`和`import`语法。 **TypeScript** @@ -2815,7 +2815,7 @@ ArkTS没有原型的概念，因此不支持`new.target`。此特性不符合静 **错误码：10605134** -ArkTS不支持确定赋值断言，例如：`let v!: T`。改为在声明变量的同时为变量赋值。 +ArkTS不支持确定赋值断言，例如：`let v!: T`。请在声明变量的同时为变量赋值。 **TypeScript** @@ -2893,7 +2893,7 @@ class C { **错误码：10605137** -由于ArkTS不支持动态更改对象的布局，因此不支持全局作用域和`globalThis`。 +ArkTS不支持全局作用域和`globalThis`。 **TypeScript** @@ -2917,7 +2917,7 @@ import * as M from 'file1' let x = M.abc; ``` -### 不支持一些utility类型 +### 不支持一些Utility类型 **规则：**`arkts-no-utility-types` @@ -2927,9 +2927,9 @@ let x = M.abc; ArkTS仅支持`Partial`、`Required`、`Readonly`和`Record`，不支持TypeScript中其他的`Utility Types`。 -对于`Partial`类型，泛型参数T必须为类或者接口类型。 +`Partial`的泛型参数T必须为类或接口类型。 -对于`Record`类型的对象，通过索引访问到的值的类型是包含`undefined`的联合类型。 +`Record`类型的对象，通过索引访问的类型是联合类型，包含`undefined`。 ### 不支持对函数声明属性 @@ -2939,7 +2939,7 @@ ArkTS仅支持`Partial`、`Required`、`Readonly`和`Record`，不支持TypeScri **错误码：10605139** -由于ArkTS不支持动态改变函数对象布局，因此，不支持对函数声明属性。 +ArkTS不支持动态改变函数对象布局，因此不支持声明函数属性。 ### 不支持`Function.apply`和`Function.call` @@ -2949,7 +2949,7 @@ ArkTS仅支持`Partial`、`Required`、`Readonly`和`Record`，不支持TypeScri **错误码：10605152** -ArkTS不允许使用标准库函数`Function.apply`和`Function.call`。这些函数用于显式设置被调用函数的`this`参数。在ArkTS中，`this`的语义仅限于传统的OOP风格，函数体中禁止使用`this`。 +ArkTS禁用标准库函数`Function.apply`和`Function.call`。这些函数用于显式设置被调用函数的`this`参数。在ArkTS中，`this`仅限于传统OOP风格，函数体中禁止使用`this`。 ### 不支持`Function.bind` @@ -2959,7 +2959,7 @@ ArkTS不允许使用标准库函数`Function.apply`和`Function.call`。这些 **错误码：10605140** -ArkTS禁用标准库函数`Function.bind`。标准库使用这些函数显式设置被调用函数的`this`参数。在ArkTS中，`this`仅限于传统OOP风格，函数体中禁用使用`this`。 +ArkTS禁用标准库函数`Function.bind`。标准库使用这些函数显式设置被调用函数的`this`参数。在ArkTS中，`this`仅限于传统OOP风格，函数体中不得使用`this`。 ### 不支持`as const`断言 @@ -2970,7 +2970,7 @@ ArkTS禁用标准库函数`Function.bind`。标准库使用这些函数显式设 **错误码：10605142** -ArkTS不支持`as const`断言和字面量类型。标准TypeScript中，`as const`用于标注字面量类型。 +ArkTS不支持`as const`断言和字面量类型。标准TypeScript使用`as const`标注字面量类型。 **TypeScript** @@ -3012,7 +3012,7 @@ let z: Label = { **错误码：10605143** -ArkTS不支持导入断言。因为导入是编译时特性，运行时检查导入API是否正确没有意义。改用常规的`import`语法。 +ArkTS不支持导入断言。导入是编译时特性，运行时检查导入API是否正确没有意义。请使用常规的`import`语法。 **TypeScript** @@ -3035,7 +3035,7 @@ import { something } from 'module' **错误码：10605144** -ArkTS不允许使用TypeScript或JavaScript标准库中的某些接口。大部分接口与动态特性有关。ArkTS中禁止使用以下接口： +ArkTS禁止使用TypeScript或JavaScript标准库中的部分接口，尤其是与动态特性相关的接口。以下接口在ArkTS中被禁止使用： 全局对象的属性和方法：`eval`