ArkTS是一种设计用于构建高性能应用的编程语言。它在继承TypeScript语法的基础上进行了优化，以提供更高的性能和开发效率。

许多编程语言在设计之初未考虑移动设备，导致应用运行缓慢、低效且功耗大。随着移动设备在日常生活中越来越普遍，针对移动环境的编程语言优化需求日益增加。ArkTS专为解决这些问题而设计，聚焦提高运行效率。

TypeScript是在JavaScript基础上通过添加类型定义扩展而来的，ArkTS则是TypeScript的进一步扩展。TypeScript提供了一种更结构化的JavaScript编码方法，深受开发者喜爱。ArkTS保持了TypeScript的大部分语法，旨在为现有的TypeScript开发者提供高度兼容的体验，帮助移动开发者快速上手。

ArkTS的一大特性是它专注于低运行时开销。ArkTS对TypeScript的动态类型特性施加了**更严格的限制**，以减少运行时开销，提高执行效率。通过取消动态类型特性，ArkTS代码能更有效地被运行前编译和优化，从而实现更快的应用启动和更低的功耗。

ArkTS语言设计中考虑了与TypeScript和JavaScript的互通性。许多移动应用开发者希望重用TypeScript和JavaScript代码及库，因此ArkTS提供与TypeScript和JavaScript的无缝互通，使开发者可以轻松集成TypeScript和JavaScript代码到应用中，充分利用现有代码和库进行ArkTS开发。

[Text-文本与输入-ArkTS组件-ArkUI（方舟UI框架）-应用框架 - 华为HarmonyOS开发者](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/ts-basic-components-text)

## 基本知识

### 声明

ArkTS通过声明引入变量、常量、类型和函数。

**变量声明**

使用关键字let声明的变量可以在程序执行期间具有不同的值。

1. let hi: string = 'hello';
2. hi = 'hello, world';


**常量声明**

使用关键字const声明的常量为只读类型，只能被赋值一次。

1. const hello: string = 'hello';


对常量重新赋值会造成编译时错误。


**自动类型推断**

如果变量或常量的声明包含初始值，开发者无需显式指定类型，因为ArkTS规范已列举了所有允许自动推断类型的场景。

以下示例中，两条声明语句都是有效的，两个变量都是string类型：

1. let hi1: string = 'hello';
2. let hi2 = 'hello, world';





### 类型

**基本类型和引用类型**

**基本数据类型**包括number、string等简单类型，它们可以准确地表示单一的数据类型。对基本类型的存储和访问都是直接的，比较时直接比较其值。

**引用类型**包括对象、数组和函数等复杂数据结构。这些类型通过引用访问数据，对象和数组可以包含多个值或键值对，函数则可以封装可执行的代码逻辑。引用类型在内存中通过指针访问数据，修改引用会影响原始数据。

**number类型**

ArkTS提供number类型，任何整数和浮点数都可以被赋给此类型的变量。

数字字面量包括整数字面量和十进制浮点数字面量。

整数字面量包括以下类别：

- 十进制整数，由数字序列组成。例如：0、117、-345。
- 十六进制整数，以0x（或0X）开头，包含数字（0-9）和字母a-f或A-F。例如：0x1123、0x00111、-0xF1A7。
- 八进制整数，以0o（或0O）开头，只能包含数字（0-7）。例如：0o777。
- 二进制整数，以0b（或0B）开头，只能包含数字0和1。例如：0b11、0b0011、-0b11。

浮点数字面量包括以下部分：

- 十进制整数，支持正负号前缀（前缀为"+"或"-"），默认为正。
- 小数点（“.”）。
- 小数部分（由十进制数字字符串表示）。
- 指数部分，以“e”或“E”开头，后跟有符号（前缀为“+”或“-”）或无符号整数。


```TS
1. let n1 = 3.14;
2. let n2 = 3.141592;
3. let n3 = 0.5;
4. let n4 = 1e2;

5. function factorial(n: number): number {
6.   if (n <= 1) {
7.     return 1;
8.   }
9.   return n * (n - 1);
10. }
11.   // ...
12.   factorial(n1) // 6.719600000000001
13.   factorial(n2) // 6.728008294464001
14.   factorial(n3) // 1
15.   factorial(n4) // 9900
```


number类型在表示大整数（即超过-9007199254740991~9007199254740991）时会造成精度丢失。在开发时可以按需使用bigint类型来确保精度：

```TS
1. let bigInt: bigint = 10的阶乘999999999999999999999999999999999999999999999999999999999999n;
2. console.info('bigInt:' + bigInt.toString());
```


**boolean类型**

boolean类型由true和false两个逻辑值组成。


**string类型**

string类型代表字符序列，可以使用转义字符来表示字符。

字符串字面量由单引号（'）或双引号（"）之间括起来的零个或多个字符组成。字符串字面量还有一特殊形式，是用反向单引号（\`）括起来的模板字面量。

**void类型**

void类型用于指定函数没有返回值。

此类型只有一个值，同样是void。由于void是引用类型，因此它可以用于泛型类型参数。

```ts
1. class Class<T> {
2.   // ...
3. }
4. let instance: Class<void>;
```


**Object类型**

Object类型是所有引用类型的基类型。任何值，包括基本类型的值，都可以直接被赋给Object类型的变量（基本类型值会被自动装箱）。

object类型用于表示除基本类型外的类型。

```ts
1. let o1: Object = 'Alice';
2. let o2: Object = ['a', 'b'];
3. let o3: Object = 1;
4. let o4: object = [1, 2, 3];
```

**array类型**

array类型，即数组，是由可赋值给数组声明中指定的元素类型的数据组成的对象。

数组可由数组复合字面量赋值。数组复合字面量是用方括号括起来的零个或多个表达式列表，每个表达式为数组中的一个元素。数组的长度由数组中元素的个数确定。数组中第一个元素的索引为0。

以下示例将创建包含三个元素的数组：

`1. let names: string[] = ['Alice', 'Bob', 'Carol'];`


**enum类型**

enum类型，即枚举类型，是预先定义的一组命名值的值类型，其中命名值又称为枚举常量。

使用枚举常量时必须以枚举类型名称为前缀。

1. enum ColorSet { Red, Green, Blue }
2. let c: ColorSet = ColorSet.Red;

[BasicKnowledge.ets](https://gitcode.com/HarmonyOS_Samples/guide-snippets/blob/HarmonyOS-7.0-beta-20260514/ArkTS/Start/LearningArkTs/IntroductionToArkTS/entry/src/main/ets/pages/BasicKnowledge.ets#L112-L115)

常量表达式用于显式设置枚举常量的值。

1. enum ColorSet { White = 0xFF, Grey = 0x7F, Black = 0x00 }
2. let c: ColorSet = ColorSet.Black;


**Union类型**

Union类型，即联合类型，是由多个类型组合成的引用类型。联合类型包含了变量可能的所有类型。

```ts
1. class Cat {
2.   public name: string = 'cat';
3.   // ...
4. }

5. class Dog {
6.   public name: string = 'dog';
7.   // ...
8. }

9. class Frog {
10.   public name: string = 'frog';
11.   // ...
12. }

13. type Animal = Cat | Dog | Frog | number | string | null | undefined;
14. // Cat、Dog、Frog是一些类型（类或接口）

15. let animal: Animal = new Cat();
16. animal = new Frog();
17. animal = 42;
18. animal = 'dog';
19. animal = undefined;
20. // 可以将类型为联合类型的变量赋值为任何组成类型的有效值
```
[BasicKnowledge.ets](https://gitcode.com/HarmonyOS_Samples/guide-snippets/blob/HarmonyOS-7.0-beta-20260514/ArkTS/Start/LearningArkTs/IntroductionToArkTS/entry/src/main/ets/pages/BasicKnowledge.ets#L124-L149)

可以使用不同机制获取联合类型中的特定类型值。

示例：
```ts
1. class Cat { sleep () {}; meow () {} }
2. class Dog { sleep () {}; bark () {} }
3. class Frog { sleep () {}; leap () {} }

4. type Animal = Cat | Dog | Frog;

5. function foo(animal: Animal) {
6.   if (animal instanceof Frog) {  // 判断animal是否是Frog类型
7.     animal.leap();  // animal在这里是Frog类型
8.   }
9.   animal.sleep(); // Animal具有sleep方法
10. }
```

[BasicKnowledge.ets](https://gitcode.com/HarmonyOS_Samples/guide-snippets/blob/HarmonyOS-7.0-beta-20260514/ArkTS/Start/LearningArkTs/IntroductionToArkTS/entry/src/main/ets/pages/BasicKnowledge.ets#L151-L164)

**Aliases类型**

Aliases类型为匿名类型（如数组、函数、对象字面量或联合类型）提供名称，或为已定义的类型提供替代名称。

```ts
1. // 二维数组类型
2. type Matrix = number[][];
3. const gameBoard: Matrix = [
4.   [1, 0],
5.   [0, 1]
6. ];

7. // 函数类型
8. type Handler = (s: string, no: number) => string;
9. const repeatString: Handler = (str, times) => {
10.   return str.repeat(times);
11. };
12. console.info(repeatString('abc', 3)); // 'abcabcabc'
13. // ...
14. // 泛型函数类型
15. type Predicate<T> = (x: T) => boolean;
16. const isEven: Predicate<number> = (num) => num % 2 === 0;

17. // 可为空的对象类型
18. type NullableObject = Object | null;

19. class Cat {
20. }

21. let animalData: NullableObject = new Cat();
22. let emptyData: NullableObject = null;
```


**instanceof运算符**

instanceof运算符用于在运行时检查一个对象是否是指定类或其子类的实例。


**for-of语句**

使用for-of语句可遍历数组、Set、Map、字符串等可迭代的类型。示例如下：
```ts
1. for (forVar of IterableExpression) {
2.   // process forVar
3. }
```

示例：

```ts
1. for (let ch of 'a string object') {
2.   console.info(ch);
3.   // ...
```



如果break语句后带有标识符，则将控制流转移到该标识符所包含的语句块之外。

示例：

1. let x = 1;
2. label: while (true) {
3.   switch (x) {
4.     case 1:
5.       // statements
6.       break label; // 中断while语句
7.   }
8. }



**throw和try语句**

throw语句用于抛出异常或错误：

`1. throw new Error('this error')`


try语句用于捕获和处理异常或错误：

```ts
1. try {
2.   // ...
3. } catch (e) {
4.   // 异常处理
5.   // ...
6. }
```




支持finally语句：
```ts
1. function processData(s: string) {
2.   let error: Error | null = null;

3.   try {
4.     console.info('Data processed: ' + s);
5.     // ...
6.     // 可能发生异常的语句
7.     // ...
8.   } catch (e) {
9.     error = e as Error;
10.     // ...
11.     // 异常处理
12.     // ...
13.   } finally {
14.     // 无论是否发生异常都会执行的代码
15.     if (error != null) {
16.       console.error(`Error caught: input='${s}', message='${error.message}'`);
17.     }
18.   }
19. }
```


## 函数

### 函数声明

函数声明引入一个函数，包含其名称、参数列表、返回类型和函数体。

以下示例是一个简单的函数和它的语法语义说明：

1.参数类型标注：x: string, y: string 显式声明参数类型为字符串类型。

2.返回值类型：: string 指定函数返回值为字符串类型。

```ts
1. function add(x: string, y: string): string {
2.   let z: string = `${x} ${y}`;
3.   return z;
4. }
```

在函数声明中，必须为每个参数标记类型。如果参数为可选参数，那么允许在调用函数时省略该参数。函数的最后一个参数可以是rest参数。
