ArkTS

Stone大约 32 分钟

ArkTS

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

基于 TypeScript：ArkTS 是 TypeScript 的超集，意味着它包含了 TypeScript 的所有特性，并在此基础上进行了扩展，以更好地适应 HarmonyOS 的特定需求。
声明式 UI：ArkTS 支持声明式 UI，这使得开发者能够以更直观和简洁的方式描述用户界面。这种方式侧重于描述 UI 应该呈现的样子，而不是如何实现它。
自定义组件和动态 UI 扩展：开发者可以使用 ArkTS 创建自定义组件，以及动态地扩展 UI 元素。这为创建复杂和高度可定制的用户界面提供了强大的灵活性。
状态管理和数据共享：ArkTS 提供了多维度的状态管理机制。在 UI 开发框架中，与 UI 相关联的数据可以在组件内使用，也可以在不同组件层级间传递，比如父子组件之间、爷孙组件之间，还可以在应用全局范围内传递或跨设备传递。
高效的渲染控制：ArkTS 提供了渲染控制的能力。条件渲染可根据应用的不同状态，渲染对应状态下的 UI 内容。循环渲染可从数据源中迭代获取数据，并在每次迭代过程中创建相应的组件。数据懒加载从数据源中按需迭代数据，并在每次迭代过程中创建相应的组件。
轻量化并发机制：ArkTS 对并发编程 API 和能力进行了增强，提供了 Taskpool 和 Worker 支持并发编程，优化了并发运行实例的启动性能和内存开销。
兼容性：ArkTS 支持与 TS/JS 高效互操作，兼容 TS/JS 生态。
性能提升：ArkTS 在保持 TypeScript 基本语法风格的基础上，进一步通过规范强化静态检查和分析，使得在程序运行之前的开发期能检测更多错误，提升代码健壮性，并实现更好的运行性能。

声明

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

变量声明

以关键字 let 开头的声明引入变量，该变量在程序执行期间可以具有不同的值。

let hi: string = 'hello';
hi = 'hello, world';

常量声明

以关键字 const 开头的声明引入只读常量，该常量只能被赋值一次。

const hello: string = 'hello';

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

自动类型推断

由于 ArkTS 是一种静态类型语言，所有数据的类型都必须在编译时确定。但是，如果一个变量或常量的声明包含了初始值，那么开发者就不需要显式指定其类型。ArkTS 规范中列举了所有允许自动推断类型的场景。

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

let hi1: string = 'hello';
let hi2 = 'hello, world';

类型

Number

ArkTS 提供 number 和 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” 开头的指数部分，后跟有符号（即，前缀为 “+” 或 “-” ）或无符号整数。

示例：

let n1 = 3.14;
let n2 = 3.141592;
let n3 = .5;
let n4 = 1e2;

function factorial(n: number): number {
  if (n <= 1) {
    return 1;
  }
  return n * factorial(n - 1);
}

factorial(n1)  //  7.660344000000002 
factorial(n2)  //  7.680640444893748 
factorial(n3)  //  1 
factorial(n4)  //  9.33262154439441e+157

Boolean

Boolean 类型由 true 和 false 两个逻辑值组成。通常在条件语句中使用 Boolean 类型的变量：

let isDone: boolean = false;

// ...

if (isDone) {
  console.log ('Done!');
}

String

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

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

let s1 = 'Hello, world!\n';
let s2 = 'this is a string';
let a = 'Success';
let s3 = `The result is ${a}`;

Void

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

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

class Class<T> {
  //...
}
let instance: Class <void>

Object

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

Array

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

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

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

let names: string[] = ['Alice', 'Bob', 'Carol'];
let names： string[] = ['Alice'， 'Bob'， 'Carol'];

Enum

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

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

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

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

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

Union

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

class Cat {
  name: string = 'cat';
  // ...
}
class Dog {
  name: string = 'dog';
  // ...
}
class Frog {
  name: string = 'frog';
  // ...
}
type Animal = Cat | Dog | Frog | number;
// Cat、Dog、Frog是一些类型（类或接口）

let animal: Animal = new Cat();
animal = new Frog();
animal = 42;
// 可以将类型为联合类型的变量赋值为任何组成类型的有效值

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

示例：

class Cat { sleep () {}; meow () {} }
class Dog { sleep () {}; bark () {} }
class Frog { sleep () {}; leap () {} }

type Animal = Cat | Dog | Frog;

function foo(animal: Animal) {
  if (animal instanceof Frog) {
    animal.leap();  // animal在这里是Frog类型
  }
  animal.sleep(); // Animal具有sleep方法
}

Aliases

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

type Matrix = number[][];
type Handler = (s: string, no: number) => string;
type Predicate <T> = (x: T) => boolean;
type NullableObject = Object | null;

运算符

赋值运算符

赋值运算符 =，使用方式如 x=y。

复合赋值运算符将赋值与运算符组合在一起，其中 x op = y 等于 x = x op y。

复合赋值运算符列举如下：+=、-=、*=、/=、%=、<<=、>>=、>>>=、&=、|=、^=。

比较运算符

运算符	说明
===	如果两个操作数严格相等（对于不同类型的操作数认为是不相等的），则返回 true。
!==	如果两个操作数严格不相等（对于不同类型的操作数认为是不相等的），则返回 true。
==	如果两个操作数相等，则返回 true。
!=	如果两个操作数不相等，则返回 true。
>	如果左操作数大于右操作数，则返回 true。
>=	如果左操作数大于或等于右操作数，则返回 true。
<	如果左操作数小于右操作数，则返回 true。
<=	如果左操作数小于或等于右操作数，则返回 true。

算术运算符

一元运算符为 -、+、--、++。

二元运算符列举如下：

运算符	说明
+	加法
-	减法
*	乘法
/	除法
%	除法后余数

位运算符

运算符	说明
a & b	按位与：如果两个操作数的对应位都为 1，则将这个位设置为 1，否则设置为 0。
a \| b	按位或：如果两个操作数的相应位中至少有一个为 1，则将这个位设置为 1，否则设置为 0。
a ^ b	按位异或：如果两个操作数的对应位不同，则将这个位设置为 1，否则设置为 0。
~ a	按位非：反转操作数的位。
a << b	左移：将 a 的二进制表示向左移 b 位。
a >> b	算术右移：将 a 的二进制表示向右移 b 位，带符号扩展。
a >>> b	逻辑右移：将 a 的二进制表示向右移 b 位，左边补 0。

逻辑运算符

运算符	说明
a && b	逻辑与
a \|\| b	逻辑或
! a	逻辑非

语句

If 语句

if 语句用于需要根据逻辑条件执行不同语句的场景。当逻辑条件为真时，执行对应的一组语句，否则执行另一组语句（如果有的话）。

else 部分也可能包含 if 语句。

if 语句如下所示：

if (condition1) {
  // 语句1
} else if (condition2) {
  // 语句2
} else {
  // else语句
}

条件表达式可以是任何类型。但是对于 boolean 以外的类型，会进行隐式类型转换：

let s1 = 'Hello';
if (s1) {
  console.log(s1); // 打印“Hello”
}

let s2 = 'World';
if (s2.length != 0) {
  console.log(s2); // 打印“World”
}

Switch 语句

使用 switch 语句来执行与 switch 表达式值匹配的代码块。

switch 语句如下所示：

switch (expression) {
  case label1: // 如果label1匹配，则执行
    // ...
    // 语句1
    // ...
    break; // 可省略
  case label2:
  case label3: // 如果label2或label3匹配，则执行
    // ...
    // 语句23
    // ...
    break; // 可省略
  default:
    // 默认语句
}

如果 switch 表达式的值等于某个 label 的值，则执行相应的语句。
如果没有任何一个 label 值与表达式值相匹配，并且 switch 具有 default 子句，那么程序会执行 default 子句对应的代码块。
break 语句（可选的）允许跳出 switch 语句并继续执行 switch 语句之后的语句。
如果没有 break 语句，则执行 switch 中的下一个 label 对应的代码块。

条件表达式

条件表达式由第一个表达式的布尔值来决定返回其它两个表达式中的哪一个。

示例如下：

condition ? expression1 : expression2

如果 condition 的为真值（转换后为 true 的值），则使用 expression1 作为该表达式的结果；否则，使用 expression2。

示例：

let isValid = Math.random() > 0.5 ? true : false;
let message = isValid ? 'Valid' : 'Failed';

For 语句

for 语句会被重复执行，直到循环退出语句值为 false。

for 语句如下所示：

for ([init]; [condition]; [update]) {
  statements
}

for 语句的执行流程如下：

1、执行 init 表达式（如有）。此表达式通常初始化一个或多个循环计数器。

2、计算 condition。如果它为真值（转换后为 true 的值），则执行循环主体的语句。如果它为假值（转换后为 false 的值），则 for 循环终止。

3、执行循环主体的语句。

4、如果有 update 表达式，则执行该表达式。

5、回到步骤2。

示例：

let sum = 0;
for (let i = 0; i < 10; i += 2) {
  sum += i;
}

For-of 语句

使用 for-of 语句可遍历数组或字符串。示例如下：

for (forVar of expression) {
  statements
}

示例：

for (let ch of 'a string object') {
  /* process ch */
}

While 语句

只要 condition 为真值（转换后为 true 的值），while 语句就会执行 statements 语句。示例如下：

while (condition) {
  statements
}

示例：

let n = 0;
let x = 0;
while (n < 3) {
  n++;
  x += n;
}

Do-while 语句

如果 condition 的值为真值（转换后为 true 的值），那么 statements 语句会重复执行。示例如下：

do {
  statements
} while (condition)

示例：

let i = 0;
do {
  i += 1;
} while (i < 10)

Break 语句

使用 break 语句可以终止循环语句或 switch。

示例：

let x = 0;
while (true) {
  x++;
  if (x > 5) {
    break;
  }
}

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

示例：

let x = 1;
label: while (true) {
  switch (x) {
    case 1:
      // statements
      break label; // 中断while语句
  }
}

Continue 语句

continue 语句会停止当前循环迭代的执行，并将控制传递给下一个迭代。

示例：

let sum = 0;
for (let x = 0; x < 100; x++) {
  if (x % 2 == 0) {
    continue;
  }
  sum += x;
}

Throw 和 Try 语句

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

throw new Error('this error')

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

try {
  // 可能发生异常的语句块
} catch (e) {
  // 异常处理
}

下面的示例中 throw 和 try 语句用于处理除数为 0 的错误：

class ZeroDivisor extends Error {}

function divide (a: number, b: number): number{
  if (b == 0) throw new ZeroDivisor();
  return a / b;
}

function process (a: number, b: number) {
  try {
    let res = divide(a, b);
    console.log('result: ' + res);
  } catch (x) {
    console.log('some error');
  }
}

支持 finally 语句：

function processData(s: string) {
  let error: Error | null = null;

  try {
    console.log('Data processed: ' + s);
    // ...
    // 可能发生异常的语句
    // ...
  } catch (e) {
    error = e as Error;
    // ...
    // 异常处理
    // ...
  } finally {
    if (error != null) {
      console.log(`Error caught: input='${s}', message='${error.message}'`);
    }
  }
}

函数

函数声明

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

以下示例是一个简单的函数，包含两个 string 类型的参数，返回类型为 string：

function add(x: string, y: string): string {
  let z: string = `${x} ${y}`;
  return z;
}

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

可选参数

可选参数的格式可为 name?: Type。

function hello(name?: string) {
  if (name == undefined) {
    console.log('Hello!');
  } else {
    console.log(`Hello, ${name}!`);
  }
}

可选参数的另一种形式为设置的参数默认值。如果在函数调用中这个参数被省略了，则会使用此参数的默认值作为实参。

function multiply(n: number, coeff: number = 2): number {
  return n * coeff;
}
multiply(2);  // 返回2*2
multiply(2, 3); // 返回2*3

Rest 参数

函数的最后一个参数可以是 rest 参数。使用 rest 参数时，允许函数或方法接受任意数量的实参。

function sum(...numbers: number[]): number {
  let res = 0;
  for (let n of numbers)
    res += n;
  return res;
}

sum(); // 返回0
sum(1, 2, 3); // 返回6

返回类型

如果可以从函数体内推断出函数返回类型，则可在函数声明中省略标注返回类型。

// 显式指定返回类型
function foo(): string { return 'foo'; }

// 推断返回类型为string
function goo() { return 'goo'; }

不需要返回值的函数的返回类型可以显式指定为 void 或省略标注。这类函数不需要返回语句。

以下示例中两种函数声明方式都是有效的：

function hi1() { console.log('hi'); }
function hi2(): void { console.log('hi'); }

函数的作用域

函数中定义的变量和其他实例仅可以在函数内部访问，不能从外部访问。

如果函数中定义的变量与外部作用域中已有实例同名，则函数内的局部变量定义将覆盖外部定义。

函数调用

调用函数以执行其函数体，实参值会赋值给函数的形参。

如果函数定义如下：

function join(x: string, y: string): string {
  let z: string = `${x} ${y}`;
  return z;
}

则此函数的调用需要包含两个 string 类型的参数：

let x = join('hello', 'world');
console.log(x);

函数类型

函数类型通常用于定义回调：

type trigFunc = (x: number) => number // 这是一个函数类型

function do_action(f: trigFunc) {
   f(3.141592653589); // 调用函数
}

do_action(Math.sin); // 将函数作为参数传入

箭头函数

函数可以定义为箭头函数，例如：

let sum = (x: number, y: number): number => {
  return x + y;
}

箭头函数的返回类型可以省略；省略时，返回类型通过函数体推断。

表达式可以指定为箭头函数，使表达更简短，因此以下两种表达方式是等价的：

let sum1 = (x: number, y: number) => { return x + y; }
let sum2 = (x: number, y: number) => x + y

闭包

闭包是由函数及声明该函数的环境组合而成的。该环境包含了这个闭包创建时作用域内的任何局部变量。

在下例中，f 函数返回了一个闭包，它捕获了 count 变量，每次调用 z，count 的值会被保留并递增。

function f(): () => number {
  let count = 0;
  let g = (): number => { count++; return count; };
  return g;
}

let z = f();
z(); // 返回：1
z(); // 返回：2

函数重载

我们可以通过编写重载，指定函数的不同调用方式。具体方法为，为同一个函数写入多个同名但签名不同的函数头，函数实现紧随其后。

function foo(x: number): void;            /* 第一个函数定义 */
function foo(x: string): void;            /* 第二个函数定义 */
function foo(x: number | string): void {  /* 函数实现 */
}

foo(123);     //  OK，使用第一个定义
foo('aa'); // OK，使用第二个定义

不允许重载函数有相同的名字以及参数列表，否则将会编译报错。

类

类声明引入一个新类型，并定义其字段、方法和构造函数。

在以下示例中，定义了 Person 类，该类具有字段 name 和 surname、构造函数和方法 fullName：

class Person {
  name: string = '';
  surname: string = '';
  constructor (n: string, sn: string) {
    this.name = n;
    this.surname = sn;
  }
  fullName(): string {
    return this.name + ' ' + this.surname;
  }
}

定义类后，可以使用关键字 new 创建实例：

let p = new Person('John', 'Smith');
console.log(p.fullName());

或者，可以使用对象字面量创建实例：

class Point {
  x: number = 0;
  y: number = 0;
}
let p: Point = {x: 42, y: 42};

字段

字段是直接在类中声明的某种类型的变量。

类可以具有实例字段或者静态字段。

实例字段

实例字段存在于类的每个实例上。每个实例都有自己的实例字段集合。

要访问实例字段，需要使用类的实例。

class Person {
  name: string = '';
  age: number = 0;
  constructor(n: string, a: number) {
    this.name = n;
    this.age = a;
  }

  getName(): string {
    return this.name;
  }
}

let p1 = new Person('Alice', 25);
p1.name;
let p2 = new Person('Bob', 28);
p2.getName();

静态字段

使用关键字 static 将字段声明为静态。静态字段属于类本身，类的所有实例共享一个静态字段。

要访问静态字段，需要使用类名：

class Person {
  static numberOfPersons = 0;
  constructor() {
     // ...
     Person.numberOfPersons++;
     // ...
  }
}

Person.numberOfPersons;

字段初始化

为了减少运行时的错误和获得更好的执行性能，

ArkTS 要求所有字段在声明时或者构造函数中显式初始化。这和标准 TS 中的 strictPropertyInitialization 模式一样。

以下代码是在 ArkTS 中不合法的代码。

class Person {
  name: string; // undefined
  
  setName(n:string): void {
    this.name = n;
  }
  
  getName(): string {
    // 开发者使用"string"作为返回类型，这隐藏了name可能为"undefined"的事实。
    // 更合适的做法是将返回类型标注为"string | undefined"，以告诉开发者这个API所有可能的返回值。
    return this.name;
  }
}

let jack = new Person();
// 假设代码中没有对name赋值，例如调用"jack.setName('Jack')"
jack.getName().length; // 运行时异常：name is undefined

在ArkTS中，应该这样写代码。

class Person {
  name: string = '';
  
  setName(n:string): void {
    this.name = n;
  }
  
  // 类型为'string'，不可能为"null"或者"undefined"
  getName(): string {
    return this.name;
  }
}
  

let jack = new Person();
// 假设代码中没有对name赋值，例如调用"jack.setName('Jack')"
jack.getName().length; // 0, 没有运行时异常

接下来的代码展示了如果 name 的值可以是 undefined，那么应该如何写代码。

class Person {
  name?: string; // 可能为`undefined`

  setName(n:string): void {
    this.name = n;
  }

  // 编译时错误：name可以是"undefined"，所以将这个API的返回值类型标记为string
  getNameWrong(): string {
    return this.name;
  }

  getName(): string | undefined { // 返回类型匹配name的类型
    return this.name;
  }
}

let jack = new Person();
// 假设代码中没有对name赋值，例如调用"jack.setName('Jack')"

// 编译时错误：编译器认为下一行代码有可能会访问undefined的属性，报错
jack.getName().length;  // 编译失败

jack.getName()?.length; // 编译成功，没有运行时错误

getter 和 setter

setter 和 getter 可用于提供对对象属性的受控访问。

在以下示例中，setter 用于禁止将 _age 属性设置为无效值：

class Person {
  name: string = '';
  private _age: number = 0;
  get age(): number { return this._age; }
  set age(x: number) {
    if (x < 0) {
      throw Error('Invalid age argument');
    }
    this._age = x;
  }
}

let p = new Person();
p.age; // 输出0
p.age = -42; // 设置无效age值会抛出错误

在类中可以定义 getter 或者 setter。

方法

方法属于类。类可以定义实例方法或者静态方法。静态方法属于类本身，只能访问静态字段。而实例方法既可以访问静态字段，也可以访问实例字段，包括类的私有字段。

实例方法

以下示例说明了实例方法的工作原理。

calculateArea 方法通过将高度乘以宽度来计算矩形的面积：

class RectangleSize {
  private height: number = 0;
  private width: number = 0;
  constructor(height: number, width: number) {
    this.height = height;
    this.width = width;
  }
  calculateArea(): number {
    return this.height * this.width;
  }
}

必须通过类的实例调用实例方法：

let square = new RectangleSize(10, 10);
square.calculateArea(); // 输出：100

静态方法

使用关键字 static 将方法声明为静态。静态方法属于类本身，只能访问静态字段。

静态方法定义了类作为一个整体的公共行为。

必须通过类名调用静态方法：

class Cl {
  static staticMethod(): string {
    return 'this is a static method.';
  }
}
console.log(Cl.staticMethod());

继承

一个类可以继承另一个类（称为基类），并使用以下语法实现多个接口：

class [extends BaseClassName] [implements listOfInterfaces] {
  // ...
}

继承类继承基类的字段和方法，但不继承构造函数。继承类可以新增定义字段和方法，也可以覆盖其基类定义的方法。

基类也称为“父类”或“超类”。继承类也称为“派生类”或“子类”。

示例：

class Person {
  name: string = '';
  private _age = 0;
  get age(): number {
    return this._age;
  }
}
class Employee extends Person {
  salary: number = 0;
  calculateTaxes(): number {
    return this.salary * 0.42;
  }
}

包含 implements 子句的类必须实现列出的接口中定义的所有方法，但使用默认实现定义的方法除外。

interface DateInterface {
  now(): string;
}
class MyDate implements DateInterface {
  now(): string {
    // 在此实现
    return 'now';
  }
}

父类访问

关键字 super 可用于访问父类的实例字段、实例方法和构造函数。在实现子类功能时，可以通过该关键字从父类中获取所需接口：

class RectangleSize {
  protected height: number = 0;
  protected width: number = 0;

  constructor (h: number, w: number) {
    this.height = h;
    this.width = w;
  }

  draw() {
    /* 绘制边界 */
  }
}
class FilledRectangle extends RectangleSize {
  color = ''
  constructor (h: number, w: number, c: string) {
    super(h, w); // 父类构造函数的调用
    this.color = c;
  }

  draw() {
    super.draw(); // 父类方法的调用
    // super.height -可在此处使用
    /* 填充矩形 */
  }
}

方法重写

子类可以重写其父类中定义的方法的实现。重写的方法必须具有与原始方法相同的参数类型和相同或派生的返回类型。

class RectangleSize {
  // ...
  area(): number {
    // 实现
    return 0;
  }
}
class Square extends RectangleSize {
  private side: number = 0;
  area(): number {
    return this.side * this.side;
  }
}

方法重载签名

通过重载签名，指定方法的不同调用。具体方法为，为同一个方法写入多个同名但签名不同的方法头，方法实现紧随其后。

class C {
  foo(x: number): void;            /* 第一个签名 */
  foo(x: string): void;            /* 第二个签名 */
  foo(x: number | string): void {  /* 实现签名 */
  }
}
let c = new C();
c.foo(123);     // OK，使用第一个签名
c.foo('aa'); // OK，使用第二个签名

如果两个重载签名的名称和参数列表均相同，则为错误。

构造函数

类声明可以包含用于初始化对象状态的构造函数。

构造函数定义如下：

constructor ([parameters]) {
  // ...
}

如果未定义构造函数，则会自动创建具有空参数列表的默认构造函数，例如：

class Point {
  x: number = 0;
  y: number = 0;
}
let p = new Point();

在这种情况下，默认构造函数使用字段类型的默认值来初始化实例中的字段。

派生类的构造函数

构造函数函数体的第一条语句可以使用关键字super来显式调用直接父类的构造函数。

class RectangleSize {
  constructor(width: number, height: number) {
    // ...
  }
}
class Square extends RectangleSize {
  constructor(side: number) {
    super(side, side);
  }
}

构造函数重载签名

我们可以通过编写重载签名，指定构造函数的不同调用方式。具体方法为，为同一个构造函数写入多个同名但签名不同的构造函数头，构造函数实现紧随其后。

class C {
  constructor(x: number)             /* 第一个签名 */
  constructor(x: string)             /* 第二个签名 */
  constructor(x: number | string) {  /* 实现签名 */
  }
}
let c1 = new C(123);      // OK，使用第一个签名
let c2 = new C('abc');    // OK，使用第二个签名

如果两个重载签名的名称和参数列表均相同，则为错误。

可见性修饰符

类的方法和属性都可以使用可见性修饰符。

可见性修饰符包括：private、protected 和 public。默认可见性为 public。

Public

public 修饰的类成员（字段、方法、构造函数）在程序的任何可访问该类的地方都是可见的。

Private

private 修饰的成员不能在声明该成员的类之外访问，例如：

class C {
  public x: string = '';
  private y: string = '';
  set_y (new_y: string) {
    this.y = new_y; // OK，因为y在类本身中可以访问
  }
}
let c = new C();
c.x = 'a'; // OK，该字段是公有的
c.y = 'b'; // 编译时错误：'y'不可见

Protected

protected 修饰符的作用与 private 修饰符非常相似，不同点是 protected 修饰的成员允许在派生类中访问，例如：

class Base {
  protected x: string = '';
  private y: string = '';
}
class Derived extends Base {
  foo() {
    this.x = 'a'; // OK，访问受保护成员
    this.y = 'b'; // 编译时错误，'y'不可见，因为它是私有的
  }
}

对象字面量

对象字面量是一个表达式，可用于创建类实例并提供一些初始值。它在某些情况下更方便，可以用来代替 new 表达式。

对象字面量的表示方式是：封闭在花括号对 ({}) 中的 '属性名：值' 的列表。

class C {
  n: number = 0;
  s: string = '';
}

let c: C = {n: 42, s: 'foo'};

ArkTS 是静态类型语言，如上述示例所示，对象字面量只能在可以推导出该字面量类型的上下文中使用。其他正确的例子：

class C {
  n: number = 0;
  s: string = '';
}

function foo(c: C) {}

let c: C

c = {n: 42, s: 'foo'};  // 使用变量的类型
foo({n: 42, s: 'foo'}); // 使用参数的类型

function bar(): C {
  return {n: 42, s: 'foo'}; // 使用返回类型
}

也可以在数组元素类型或类字段类型中使用：

class C {
  n: number = 0;
  s: string = '';
}
let cc: C[] = [{n: 1, s: 'a'}, {n: 2, s: 'b'}];

Record 类型的对象字面量

泛型 Record<K, V> 用于将类型（键类型）的属性映射到另一个类型（值类型）。常用对象字面量来初始化该类型的值：

let map: Record<string, number> = {
  'John': 25,
  'Mary': 21,
}

map['John']; // 25

类型 K 可以是字符串类型或数值类型，而 V 可以是任何类型。

interface PersonInfo {
  age: number;
  salary: number;
}
let map: Record<string, PersonInfo> = {
  'John': { age: 25, salary: 10},
  'Mary': { age: 21, salary: 20}
}

接口

接口声明引入新类型。接口是定义代码协定的常见方式。

任何一个类的实例只要实现了特定接口，就可以通过该接口实现多态。

接口通常包含属性和方法的声明

示例：

interface Style {
  color: string; // 属性
}
interface AreaSize {
  calculateAreaSize(): number; // 方法的声明
  someMethod(): void;     // 方法的声明
}

实现接口的类示例：

// 接口：
interface AreaSize {
  calculateAreaSize(): number; // 方法的声明
  someMethod(): void;     // 方法的声明
}

// 实现：
class RectangleSize implements AreaSize {
  private width: number = 0;
  private height: number = 0;
  someMethod(): void {
    console.log('someMethod called');
  }
  calculateAreaSize(): number {
    this.someMethod(); // 调用另一个方法并返回结果
    return this.width * this.height;
  }
}

接口属性

接口属性可以是字段、getter、setter 或 getter 和 setter 组合的形式。

属性字段只是 getter/setter 对的便捷写法。以下表达方式是等价的：

interface Style {
  color: string;
}

interface Style {
  get color(): string;
  set color(x: string);
}

实现接口的类也可以使用以下两种方式：

interface Style {
  color: string;
}

class StyledRectangle implements Style {
  color: string = '';
}

interface Style {
  color: string;
}

class StyledRectangle implements Style {
  private _color: string = '';
  get color(): string { return this._color; }
  set color(x: string) { this._color = x; }
}

接口继承

接口可以继承其他接口，如下面的示例所示：

interface Style {
  color: string;
}

interface ExtendedStyle extends Style {
  width: number;
}

继承接口包含被继承接口的所有属性和方法，还可以添加自己的属性和方法。

泛型类型和函数

泛型类型和函数允许创建的代码在各种类型上运行，而不仅支持单一类型。

泛型类和接口

类和接口可以定义为泛型，将参数添加到类型定义中，如以下示例中的类型参数 Element：

class CustomStack<Element> {
  public push(e: Element):void {
    // ...
  }
}

要使用类型 CustomStack，必须为每个类型参数指定类型实参：

let s = new CustomStack<string>();
s.push('hello');

编译器在使用泛型类型和函数时会确保类型安全。参见以下示例：

let s = new CustomStack<string>();
s.push(55); // 将会产生编译时错误

泛型约束

泛型类型的类型参数可以被限制只能取某些特定的值。例如，MyHashMap<Key, Value> 这个类中的 Key 类型参数必须具有 hash 方法。

interface Hashable {
  hash(): number;
}
class MyHashMap<Key extends Hashable, Value> {
  public set(k: Key, v: Value) {
    let h = k.hash();
    // ...其他代码...
  }
}

在上面的例子中，Key 类型继承了 Hashable，Hashable 接口的所有方法都可以为 key 调用。

泛型函数

使用泛型函数可编写更通用的代码。比如返回数组最后一个元素的函数：

function last(x: number[]): number {
  return x[x.length - 1];
}
last([1, 2, 3]); // 3

如果需要为任何数组定义相同的函数，使用类型参数将该函数定义为泛型：

function last<T>(x: T[]): T {
  return x[x.length - 1];
}

现在，该函数可以与任何数组一起使用。

在函数调用中，类型实参可以显式或隐式设置：

// 显式设置的类型实参
last<string>(['aa', 'bb']);
last<number>([1, 2, 3]);

// 隐式设置的类型实参
// 编译器根据调用参数的类型来确定类型实参
last([1, 2, 3]);

泛型默认值

泛型类型的类型参数可以设置默认值。这样可以不指定实际的类型实参，而只使用泛型类型名称。下面的示例展示了类和函数的这一点。

class SomeType {}
interface Interface <T1 = SomeType> { }
class Base <T2 = SomeType> { }
class Derived1 extends Base implements Interface { }
// Derived1在语义上等价于Derived2
class Derived2 extends Base<SomeType> implements Interface<SomeType> { }

function foo<T = number>(): T {
  // ...
}
foo();
// 此函数在语义上等价于下面的调用
foo<number>();

空安全

默认情况下，ArkTS 中的所有类型都是不可为空的，因此类型的值不能为空。这类似于 TypeScript 的严格空值检查模式（strictNullChecks），但规则更严格。

在下面的示例中，所有行都会导致编译时错误：

let x: number = null;    // 编译时错误
let y: string = null;    // 编译时错误
let z: number[] = null;  // 编译时错误

可以为空值的变量定义为联合类型T | null。

let x: number | null = null;
x = 1;    // ok
x = null; // ok
if (x != null) { /* do something */ }

非空断言运算符

后缀运算符 ! 可用于断言其操作数为非空。

应用于可空类型的值时，它的编译时类型变为非空类型。例如，类型将从 T | null 更改为 T：

class A {
  value: number = 0;
}

function foo(a: A | null) {
  a.value;   // 编译时错误：无法访问可空值的属性
  a!.value;  // 编译通过，如果运行时a的值非空，可以访问到a的属性；如果运行时a的值为空，则发生运行时异常
}

空值合并运算符

空值合并二元运算符 ?? 用于检查左侧表达式的求值是否等于 null 或者 undefined。如果是，则表达式的结果为右侧表达式；否则，结果为左侧表达式。

换句话说，a ?? b 等价于三元运算符 (a != null && a != undefined) ? a : b。

在以下示例中，getNick 方法如果设置了昵称，则返回昵称；否则，返回空字符串：

class Person {
  // ...
  nick: string | null = null;
  getNick(): string {
    return this.nick ?? '';
  }
}

可选链

在访问对象属性时，如果该属性是 undefined 或者 null，可选链运算符会返回 undefined。

class Person {
  nick: string | null = null;
  spouse?: Person

  setSpouse(spouse: Person): void {
    this.spouse = spouse;
  }

  getSpouseNick(): string | null | undefined {
    return this.spouse?.nick;
  }

  constructor(nick: string) {
    this.nick = nick;
    this.spouse = undefined;
  }
}

说明：getSpouseNick 的返回类型必须为 string | null | undefined，因为该方法可能返回 null 或者 undefined。

可选链可以任意长，可以包含任意数量的 ?. 运算符。

在以下示例中，如果一个 Person 的实例有不为空的 spouse 属性，且 spouse 有不为空的 nick 属性，则输出 spouse.nick。否则，输出 undefined：

class Person {
  nick: string | null = null;
  spouse?: Person;

  constructor(nick: string) {
    this.nick = nick;
    this.spouse = undefined;
  }
}

let p: Person = new Person('Alice');
p.spouse?.nick; // undefined

模块

程序可划分为多组编译单元或模块。

每个模块都有其自己的作用域，即，在模块中创建的任何声明（变量、函数、类等）在该模块之外都不可见，除非它们被显式导出。

与此相对，从另一个模块导出的变量、函数、类、接口等必须首先导入到模块中。

导出

可以使用关键字 export 导出顶层的声明。

未导出的声明名称被视为私有名称，只能在声明该名称的模块中使用。

注意：通过 export 方式导出，在导入时要加 {}。

export class Point {
  x: number = 0;
  y: number = 0;
  constructor(x: number, y: number) {
    this.x = x;
    this.y = y;
  }
}
export let Origin = new Point(0, 0);
export function Distance(p1: Point, p2: Point): number {
  return Math.sqrt((p2.x - p1.x) * (p2.x - p1.x) + (p2.y - p1.y) * (p2.y - p1.y));
}

导入

静态导入

导入声明用于导入从其他模块导出的实体，并在当前模块中提供其绑定。导入声明由两部分组成：

导入路径，用于指定导入的模块；
导入绑定，用于定义导入的模块中的可用实体集和使用形式（限定或不限定使用）。

导入绑定可以有几种形式。

假设模块具有路径 “./utils” 和导出实体 “X” 和 “Y”。

导入绑定 * as A 表示绑定名称 “A”，通过 A.nameopen in new window 可访问从导入路径指定的模块导出的所有实体：

import * as Utils from './utils'
Utils.X // 表示来自Utils的X
Utils.Y // 表示来自Utils的Y

导入绑定 { ident1, ..., identN } 表示将导出的实体与指定名称绑定，该名称可以用作简单名称：

import { X, Y } from './utils'
X // 表示来自utils的X
Y // 表示来自utils的Y

如果标识符列表定义了 ident as alias，则实体 ident 将绑定在名称 alias 下：

import { X as Z, Y } from './utils'
Z // 表示来自Utils的X
Y // 表示来自Utils的Y
X // 编译时错误：'X'不可见

动态导入

应用开发的有些场景中，如果希望根据条件导入模块或者按需导入模块，可以使用动态导入代替静态导入。

import() 语法通常称为动态导入，是一种类似函数的表达式，用来动态导入模块。以这种方式调用，将返回一个 promise。

如下例所示，import(modulePath) 可以加载模块并返回一个 promise，该 promise resolve 为一个包含其所有导出的模块对象。该表达式可以在代码中的任意位置调用。

let modulePath = prompt("Which module to load?");
import(modulePath)
.then(obj => <module object>)
.catch(err => <loading error, e.g. if no such module>)

如果在异步函数中，可以使用 let module = await import(modulePath)。

// say.ts
export function hi() {
  console.log('Hello');
}
export function bye() {
  console.log('Bye');
}

那么，可以像下面这样进行动态导入：

async function test() {
  let ns = await import('./say');
  let hi = ns.hi;
  let bye = ns.bye;
  hi();
  bye();
}

导入 HarmonyOS SDK 的开放能力

HarmonyOS SDK 提供的开放能力（接口）也需要在导入声明后使用。可直接导入接口模块来使用该模块内的所有接口能力，例如：

import UIAbility from '@ohos.app.ability.UIAbility';

从 HarmonyOS NEXT Developer Preview 1 版本开始引入 Kit 概念。SDK 对同一个 Kit 下的接口模块进行了封装，开发者在示例代码中可通过导入 Kit 的方式来使用 Kit 所包含的接口能力。其中，Kit 封装的接口模块可查看 SDK 目录下 Kit 子目录中各 Kit 的定义。

通过导入 Kit 方式使用开放能力有三种方式：

方式一：导入 Kit 下单个模块的接口能力。例如：

import { UIAbility } from '@kit.AbilityKit';

方式二：导入 Kit 下多个模块的接口能力。例如：

import { UIAbility, Ability, Context } from '@kit.AbilityKit';

方式三：导入 Kit 包含的所有模块的接口能力。例如：

import * as module from '@kit.AbilityKit';

其中，“module” 为别名，可自定义，然后通过该名称调用模块的接口。

注意：
方式三可能会导入过多无需使用的模块，导致编译后的 HAP 包太大，占用过多资源，请谨慎使用。

顶层语句

顶层语句是指在模块的最外层直接编写的语句，这些语句不被包裹在任何函数、类、块级作用域中。顶层语句包括变量声明、函数声明、表达式等。

关键字

this

关键字 this 只能在类的实例方法中使用。

示例：

class A {
  count: string = 'a';
  m(i: string): void {
    this.count = i;
  }
}

使用限制：

不支持 this 类型
不支持在函数和类的静态方法中使用 this

示例

class A {
  n: number = 0;
  f1(arg1: this) {} // 编译时错误，不支持this类型
  static f2(arg1: number) {
    this.n = arg1;  // 编译时错误，不支持在类的静态方法中使用this
  }
}

function foo(arg1: number) {
  this.n = i;       // 编译时错误，不支持在函数中使用this
}

关键字 this 的指向:

调用实例方法的对象
正在构造的对象

ArkTS

# ArkTS

# 声明

# 变量声明

# 常量声明

# 自动类型推断

# 类型

# Number

# Boolean

# String

# Void

# Object

# Array

# Enum

# Union

# Aliases

# 运算符

# 赋值运算符

# 比较运算符

# 算术运算符

# 位运算符

# 逻辑运算符

# 语句

# If 语句

# Switch 语句

# 条件表达式

# For 语句

# For-of 语句

# While 语句

# Do-while 语句

# Break 语句

# Continue 语句

# Throw 和 Try 语句

# 函数

# 函数声明

# 可选参数

# Rest 参数

# 返回类型

# 函数的作用域

# 函数调用

# 函数类型

# 箭头函数

# 闭包

# 函数重载

# 类

# 字段

# 实例字段

# 静态字段

# 字段初始化

# getter 和 setter

# 方法

# 实例方法

# 静态方法

# 继承

# 父类访问

# 方法重写

# 方法重载签名

# 构造函数

# 派生类的构造函数

# 构造函数重载签名

# 可见性修饰符

# Public

# Private

# Protected

# 对象字面量

# Record 类型的对象字面量

# 接口

# 接口属性

# 接口继承

# 泛型类型和函数

# 泛型类和接口

# 泛型约束

# 泛型函数

# 泛型默认值

# 空安全

# 非空断言运算符

# 空值合并运算符

# 可选链

# 模块

# 导出

ArkTS

声明

变量声明

常量声明

自动类型推断

类型

Number

Boolean

String

Void

Object

Array

Enum

Union

Aliases

运算符

赋值运算符

比较运算符

算术运算符

位运算符

逻辑运算符

语句

If 语句

Switch 语句

条件表达式

For 语句

For-of 语句

While 语句

Do-while 语句

Break 语句

Continue 语句

Throw 和 Try 语句

函数

函数声明

可选参数

Rest 参数

返回类型

函数的作用域

函数调用

函数类型

箭头函数

闭包

函数重载

类

字段

实例字段

静态字段

字段初始化

getter 和 setter

方法

实例方法

静态方法

继承

父类访问

方法重写

方法重载签名

构造函数

派生类的构造函数

构造函数重载签名

可见性修饰符

Public

Private

Protected

对象字面量

Record 类型的对象字面量

接口

接口属性

接口继承

泛型类型和函数

泛型类和接口

泛型约束

泛型函数

泛型默认值

空安全

非空断言运算符

空值合并运算符

可选链

模块

导出

导入