HarmonyOS 鸿蒙Next ArkTS语言详解

比较运算符

算术运算符

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

二元运算符列举如下：

位运算符

逻辑运算符

语句

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匹配，则执行
  // 可省略
  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 = 1label: while (true) {switch (x) {case 1:// statementsbreak 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);  // 返回22
multiply(2, 3); // 返回23

function sum(…numbers: number[]): number {
  let res = 0;
  for (let n of numbers)
  res += n;
  return res;
}
sum() // 返回0sum(1, 2, 3) // 返回6

// 显式指定返回类型
function foo(): string { 
 return ‘foo’; 
 }// 推断返回类型为string
 function goo() { return ‘goo’; }

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;
}

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

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，使用第二个定义

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

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

class Point {x: number = 0y: 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();

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

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

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, 没有运行时异常

class Person {name?: string // 可能为undefinedsetName(n:string): void {this.name = n;}// 编译时错误：name可以是"undefined”，所以将这个API的返回值类型标记为stringgetNameWrong(): 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; // 编译成功，没有运行时错误

class Person {name: string = ''private _age: number = 0get 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; // 输出0p.age = -42; // 设置无效age值会抛出错误

class RectangleSize {private height: number = 0private width: number = 0constructor(height: number, width: number) {// …}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 = 0get age(): number {return this._age;}}class Employee extends Person {salary: number = 0calculateTaxes(): number {return this.salary  0.42;}}

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

class RectangleSize {protected height: number = 0protected width: number = 0constructor (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 = 0area(): 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 = 0y: 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 = 0s: string = ‘’}let c: C = {n: 42, s: ‘foo’};

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

class C {n: number = 0s: string = ‘’}function foo(c: C) {}let c: Cc = {n: 42, s: ‘foo’};  // 使用变量的类型foo({n: 42, s: ‘foo’}); // 使用参数的类型function bar(): C {return {n: 42, s: ‘foo’}; // 使用返回类型}

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

class C {n: number = 0s: 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: numbersalary: 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 = 0private height: number = 0someMethod(): void {console.log(‘someMethod called’);}calculateAreaSize(): number {this.someMethod(); // 调用另一个方法并返回结果return this.width  this.height;}}

interface Style {color: string}

interface Style {get color(): stringset 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}

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

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

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

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

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在语义上等价于Derived2class Derived2 extends Base<SomeType> implements Interface<SomeType> { }function foo<T = number>(): T {// …}foo();// 此函数在语义上等价于下面的调用foo<number>();

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

let x: number | null = null;x = 1;    // okx = null; // okif (x != null) { / do something / }

class C {value: number | null = 1;}let c = new C();let y: number;y = c.value + 1;  // 编译时错误：无法对可空值作做加法y = c.value! + 1; // ok，值为2

class Person {// …nick: string | null = nullgetNick(): string {return this.nick ?? ‘’;}}

class Person {nick: string | null = nullspouse?: PersonsetSpouse(spouse: Person): void {this.spouse = spouse;}getSpouseNick(): string | null | undefined {return this.spouse?.nick;}constructor(nick: string) {this.nick = nick;this.spouse = undefined;}}

class Person {nick: string | null = nullspouse?: Personconstructor(nick: string) {this.nick = nick;this.spouse = undefined;}}let p: Person = new Person(‘Alice’);p.spouse?.nick; // undefined

export class Point {x: number = 0y: number = 0constructor(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));}

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

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

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

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

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

// say.tsexport 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();
}

import UIAbility from ‘@ohos.app.ability.UIAbility’;

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

  import { UIAbility } from ‘@kit.AbilityKit’;

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

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

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

  import  as module from ‘@kit.AbilityKit’;

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

  说明

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

顶层语句

模块可以包含除return语句外的任何模块级语句。

如果模块包含主函数（程序入口），则模块的顶层语句将在此函数函数体之前执行。否则，这些语句将在执行模块的其他功能之前执行。

程序入口

程序（应用）的入口是顶层主函数。主函数应具有空参数列表或只有string[]类型的参数。

function main() {
 console.log(‘this is the program entry’);
}

关键字

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的指向:

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