3、ArkTS语言介绍

基础知识

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

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语句（在 JavaScript/TypeScript 中，finally 是 try-catch 语句中的一个可选代码块，它的核心作用是无论是否发生异常，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参数的格式为…restArgs。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'); }

箭头函数（又名Lambda函数）

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

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

第一行代码的解释：() => number表示的是函数f返回的是一个函数，该函数不接受任何参数，返回一个number类型的数。

类

字段

字段是直接在类中声明的某种类型的变量。类可以具有实例字段或者静态字段。

字段初始化

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

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

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

class Person {name: string; // undefinedsetName(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值会抛出错误

继承

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

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，使用第二个签名

可见性修饰符（Public、Private、protected）

类的方法和属性都可以使用可见性修饰符。可见性修饰符包括：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'不可见，因为它是私有的}
}