ArkTS 基础入门
本篇文章将带你快速入门 ArkTS 的基础知识,包括变量声明、数据类型、运算符、控制流语句以及空安全处理,为鸿蒙应用开发打下坚实的基础。
目录
七:函数与方法
1. 函数声明
函数声明用于定义一个函数,包含函数名称、参数列表、返回类型和函数体。
function add(x: string, y: string): string {
let z: string = `${x} ${y}`;
return z;
}
1.1 可选参数
可选参数的格式为 name?: Type,允许在调用时省略这些参数。
function greet(name?: string) {
if (name === undefined) {
console.log('Hello!');
} else {
console.log(`Hello, ${name}!`);
}
}
1.2 默认值参数
参数可以有默认值。在调用时若省略该参数,则使用默认值。
function multiply(n: number, coeff: number = 2): number {
return n * coeff;
}
multiply(2); // 返回 4
multiply(2, 3); // 返回 6
1.3 Rest 参数
Rest 参数允许函数接受任意数量的参数,并将它们收集到一个数组中。Rest 参数必须位于参数列表的末尾,通常用于处理不定参数,例如计算不定数量的数字和。
- 语法为
...paramName: Type[]。 - Rest 参数可与其他参数一起使用,但必须放在最后。
function sum(...numbers: number[]): number {
return numbers.reduce((acc, curr) => acc + curr, 0);
}
console.log(sum(1, 2, 3)); // 输出:6
console.log(sum()); // 输出:0
Rest 参数与其他参数结合使用
可以在函数中将 Rest 参数与其他参数搭配使用,以接受固定参数和任意数量的可变参数。
function introduce(greeting: string, ...names: string[]): void {
for (let name of names) {
console.log(`${greeting}, ${name}!`);
}
}
introduce("Hello", "Alice", "Bob", "Carol");
// 输出:
// Hello, Alice!
// Hello, Bob!
// Hello, Carol!
在上例中,greeting 是固定参数,names 是 Rest 参数,可以接受任意数量的名字。
2. 返回类型
如果可以从函数体内推断出返回类型,则可以省略返回类型标注。无返回值的函数类型可以显式指定为 void 或省略。
function display(): void { console.log('Displaying...'); }
function getMessage() { return 'Hello'; } // 推断为 string 类型
3. 函数作用域与调用
函数中定义的变量只能在函数内部访问,外部无法访问这些变量。调用函数会执行其函数体,并将实参赋值给形参。
function join(x: string, y: string): string {
let z: string = `${x} ${y}`;
return z;
}
let message = join('hello', 'world');
console.log(message); // 输出 "hello world"
4. 函数类型
函数类型可以用于定义回调函数或作为类型标注。
type MathFunc = (x: number) => number;
function applyFunc(func: MathFunc) {
console.log(func(3.14));
}
applyFunc(Math.sin); // 将 Math.sin 作为参数传入
5. 箭头函数(Lambda 函数)
箭头函数可以用简洁的语法定义匿名函数。可以省略花括号和返回类型,让表达更简短。
let sum = (x: number, y: number): number => x + y;
let multiply = (x: number, y: number) => x * y; // 自动推断返回类型
6. 闭包
闭包是由函数及其声明时的环境组成的。闭包捕获并保留函数创建时作用域内的变量,使得这些变量在闭包函数中可以继续访问。
function createCounter(): () => number {
let count = 0;
return () => { count++; return count; };
}
let counter = createCounter();
console.log(counter()); // 输出 1
console.log(counter()); // 输出 2
在上例中,counter 是一个闭包,它捕获了 count 变量,并在每次调用时保留并更新其值。
7. 函数重载
函数重载允许定义多个具有相同名称但参数类型或数量不同的函数,常用于需要对不同数据类型执行相似操作的情况。ArkTS 通过重载签名声明不同的参数类型,最后在实现部分使用联合类型处理不同的情况。
重载签名
重载签名是函数定义的不同版本,仅声明参数和返回类型,不包含实现。
function format(value: string): string;
function format(value: number): string;
实现签名
在实现中,使用联合类型涵盖所有可能的参数类型,并添加逻辑来区分参数类型。
function format(value: string | number): string {
if (typeof value === "string") {
return `String: ${value}`;
} else {
return `Number: ${value}`;
}
}
console.log(format("ArkTS")); // 输出:"String: ArkTS"
console.log(format(123)); // 输出:"Number: 123"
重载规则
- 重载函数可以有多个同名定义,但参数类型或数量必须不同。
- 重载实现必须涵盖所有可能的参数类型。
- 在实现部分使用联合类型和类型检查,以适应不同的调用情况。
通过重载,开发者可以在不编写多个不同函数的情况下,为同一个函数名提供多种调用方式,确保代码的简洁性和复用性。
八:类与对象
在编程中,类是定义对象属性和方法的模板或蓝图,而对象是类的具体实例。实例则是通过类创建的一个具体对象。可以将类看作对象的设计图,而对象是类的具体实现。
1. 类的声明与创建
在 ArkTS 中,类用于定义对象的属性和方法。以下示例定义了 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()); // 输出:John Smith
此外,ArkTS 允许通过简洁的方式直接创建对象实例,例如:
class Point {
x: number = 0;
y: number = 0;
}
let p: Point = { x: 42, y: 42 }; // 使用对象的简洁形式创建 Point 实例
2. 字段
字段是在类中声明的变量。类可以有实例字段和静态字段。
实例字段
实例字段属于类的每个实例,独立存储在不同实例中。通过实例来访问这些字段:
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);
console.log(p1.name); // 输出:Alice
静态字段
使用 static 关键字将字段声明为静态。静态字段属于类本身,所有实例共享:
class Person {
static numberOfPersons = 0;
constructor() {
Person.numberOfPersons++;
}
}
console.log(Person.numberOfPersons); // 输出创建的实例数
字段初始化
为避免运行时错误,ArkTS 要求所有字段在声明时或构造函数中显式初始化:
class Person {
name: string = ''; // 初始化为非空字符串
setName(n: string): void {
this.name = n;
}
getName(): string {
return this.name;
}
}
若字段允许为 undefined,需在类型中显式声明:
class Person {
name?: string; // 允许 name 为 undefined
setName(n: string): void {
this.name = n;
}
getName(): string | undefined {
return this.name;
}
}
3. Getter 和 Setter
在 ArkTS 中,get 和 set 方法并非强制要求,但它们提供了访问和操作类属性的受控方式,尤其在以下场景中很有帮助:
- 验证和限制:在
set方法中可以加入验证逻辑,例如限制年龄字段不能为负值。 - 隐藏内部实现:使用
get和set方法可以让属性访问更灵活,便于在不改变接口的情况下修改内部实现。 - 自动计算属性:
get方法可以用于定义计算属性,使得访问属性时可以自动计算或处理。
以下代码通过 get 和 set 方法来控制对 _age 属性的访问,并确保 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'); // 确保 age 值合法
}
this._age = x;
}
}
let p = new Person();
p.age = 25; // 设置年龄
console.log(p.age); // 输出:25
4. 方法
类可以定义实例方法和静态方法。实例方法可访问实例和静态字段,而静态方法只能访问静态字段。
实例方法
实例方法属于类的每个实例,可通过实例调用。以下方法 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);
console.log(square.calculateArea()); // 输出:100
静态方法
使用 static 声明静态方法。静态方法属于类本身,直接通过类名调用:
class Cl {
static staticMethod(): string {
return 'This is a static method.';
}
}
console.log(Cl.staticMethod());
5. 继承
类可以继承另一个类,并可以实现接口。继承使得子类能够复用父类的字段和方法:
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;
}
}
父类访问
关键字 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(); // 调用父类方法
/* 填充矩形 */
}
}
6. 方法重写与重载
方法重写
子类可以重写父类中定义的方法,以提供不同的实现:
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); // 使用第一个签名
c.foo('abc'); // 使用第二个签名
7. 构造函数
构造函数用于初始化对象的状态。未定义构造函数时,会自动生成一个默认构造函数:
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);
}
}
8. 可见性修饰符
类的成员可使用 public、private 和 protected 修饰符来控制访问权限:
public:所有地方可见,默认修饰符private:仅在类内部可见protected:在类和子类中可见
使用建议:在设计类的接口时,推荐将不希望外部访问的成员设为 private 或 protected,以增强封装性,确保类的内部实现细节不暴露。通过 public 的方法和字段提供必要的访问接口。
class C {
public x: string = '';
private y: string = '';
protected z: string = '';
setY(newY: string) {
this.y = newY;
}
}
9. this 关键字
在类和对象的上下文中,this 关键字指代当前对象的实例。它在方法中用于引用该对象的属性或其他方法,以确保操作的是当前实例的数据。
this 关键字的用法
在类方法中,this 关键字通常用于访问类的实例属性和方法。下面是一个基本的示例,展示如何在方法中使用 this:
class Counter {
count: number = 0;
increment() {
this.count += 1; // 使用 this 引用当前对象的 count 属性
return this.count;
}
displayCount() {
console.log(`Count is: ${this.count}`); // 输出当前 count 值
}
}
let counter = new Counter();
counter.increment(); // 调用 increment 方法,count 值增加
counter.displayCount(); // 输出 "Count is: 1"
在 increment 方法中,this.count 引用当前对象的 count 属性,而不是全局的变量或其他对象的属性。
this 在继承中的使用
在继承中,this 可以在子类中访问父类的属性和方法。通过调用 super 可以在子类构造函数或方法中调用父类的构造函数或方法,而 this 指向子类实例本身:
class Animal {
name: string;
constructor(name: string) {
this.name = name;
}
speak() {
console.log(`${this.name} makes a noise.`);
}
}
class Dog extends Animal {
constructor(name: string) {
super(name); // 调用父类构造函数
}
speak() {
console.log(`${this.name} barks.`); // 使用 this 访问父类 name 属性
}
}
let dog = new Dog("Buddy");
dog.speak(); // 输出 "Buddy barks."
在 Dog 类的 speak 方法中,this.name 访问了 Animal 类中定义的 name 属性,因为 Dog 继承了 Animal。
注意事项
- 在类的静态方法中不能使用
this关键字来访问实例属性。 this的使用可能会随着上下文的不同而指向不同的对象,在箭头函数中,this会自动绑定到定义它的上下文中。
九:接口及其与类的关系
在 ArkTS 中,接口用于定义对象或类的结构,规定了对象应具有的属性和方法,但不包含具体实现。接口提供了一种强制约定机制,使类在实现接口时必须包含接口中定义的属性和方法。这种结构化的方式提升了代码的可读性和维护性。
1. 接口的基本定义
接口主要用于约束对象的结构。以下示例定义了 Person 接口,规定了对象 Person 应包含的字段和方法:
interface Person {
name: string;
age: number;
greet(): string;
}
let person: Person = {
name: 'Alice',
age: 25,
greet() {
return `Hello, my name is ${this.name}`;
}
};
console.log(person.greet()); // 输出:"Hello, my name is Alice"
2. 类实现接口
类可以通过 implements 关键字来实现接口,确保类提供接口中定义的所有属性和方法。接口中定义的仅是方法签名和字段类型,具体实现由类提供:
interface Drivable {
start(): void;
stop(): void;
}
class Car implements Drivable {
start(): void {
console.log("Car started.");
}
stop(): void {
console.log("Car stopped.");
}
}
let myCar = new Car();
myCar.start(); // 输出:"Car started."
3. 既继承类又实现接口
在 ArkTS 中,类可以继承其他类并实现多个接口,这使得类可以在继承的基础上进一步扩展功能。以下示例展示了 ElectricCar 类如何继承 Vehicle 类的基础属性和方法,同时实现 Rechargeable 接口,增加了新的行为:
interface Rechargeable {
recharge(): void;
}
class Vehicle {
fuelLevel: number = 100;
drive(): void {
console.log("Vehicle is driving.");
}
}
class ElectricCar extends Vehicle implements Drivable, Rechargeable {
start(): void {
console.log("Electric car started.");
}
stop(): void {
console.log("Electric car stopped.");
}
recharge(): void {
console.log("Electric car is recharging.");
}
}
let myElectricCar = new ElectricCar();
myElectricCar.start(); // 输出:"Electric car started."
myElectricCar.drive(); // 输出:"Vehicle is driving."
myElectricCar.recharge(); // 输出:"Electric car is recharging."
4. 多重实现
一个类可以实现多个接口,但 ArkTS 中类不支持多重继承(即一个类不能继承多个类)。例如,以下代码展示了一个 Airplane 类,同时实现了 Drivable 和 Flyable 接口:
interface Flyable {
takeOff(): void;
land(): void;
}
class Airplane implements Drivable, Flyable {
start(): void {
console.log("Airplane engines started.");
}
stop(): void {
console.log("Airplane engines stopped.");
}
takeOff(): void {
console.log("Airplane is taking off.");
}
land(): void {
console.log("Airplane is landing.");
}
}
let myPlane = new Airplane();
myPlane.start(); // 输出:"Airplane engines started."
myPlane.takeOff(); // 输出:"Airplane is taking off."
5. 接口、类、继承和实现的关系
接口、类、继承和实现的关系可以总结如下:
- 接口(Interface):定义一组属性和方法,不提供具体实现,作为类的结构约束。
- 类(Class):定义对象的属性和行为,描述其状态和方法。
- 继承(Inheritance):类可以继承另一个类的属性和方法,但 ArkTS 中一个类只能继承一个父类。
- 实现(Implements):类可以实现一个或多个接口,必须提供接口中所有属性和方法的具体实现。
6. 使用接口约束类行为
接口还可以用于约束函数参数类型或返回类型。例如,如果一个函数的参数必须符合某个接口结构,我们可以这样使用接口:
interface Logger {
log(message: string): void;
}
function performLogging(logger: Logger) {
logger.log("This is a log message");
}
class ConsoleLogger implements Logger {
log(message: string): void {
console.log(message);
}
}
let logger = new ConsoleLogger();
performLogging(logger); // 输出:"This is a log message"
在 performLogging 函数中,logger 参数必须符合 Logger 接口,保证了函数的类型安全性和可维护性。
7. 总结
- 接口为类提供了行为契约,约定了类必须实现的属性和方法。
- 继承用于复用已有的类结构,使得子类能够继承父类的属性和方法。
- 实现使类可以扩展多个接口的功能,但类只能继承一个父类。
通过合理利用接口、继承和实现,我们可以在 ArkTS 中构建结构良好、易于维护的代码。
十: 泛型类型和函数
泛型(Generic)允许创建在各种类型上运行的代码,而不仅限于单一类型。这可以提高代码的复用性和类型安全性,特别适用于处理集合或其他复杂数据类型。
1 泛型类和接口
类和接口可以使用泛型参数来定义,以便在实例化时指定具体的类型。下面是一个定义了泛型参数 Element 的示例类 CustomStack:
class CustomStack<Element> {
private items: Element[] = [];
public push(e: Element): void {
this.items.push(e);
}
public pop(): Element | undefined {
return this.items.pop();
}
}
使用泛型类时,必须为类型参数提供实际类型:
let stack = new CustomStack<string>();
stack.push('hello');
// stack.push(55); // 编译时错误,类型不匹配
2 泛型约束
可以为泛型参数添加约束,以确保该参数符合特定的接口。例如,下面的 MyHashMap 类限制 Key 类型必须实现 Hashable 接口,确保调用 hash() 方法不会出错:
interface Hashable {
hash(): number;
}
class MyHashMap<Key extends Hashable, Value> {
private map = new Map<number, Value>();
public set(k: Key, v: Value): void {
this.map.set(k.hash(), v);
}
}
在这个例子中,Key 类型必须具有 hash 方法,编译器将会验证传入的类型是否满足这一条件。
3 泛型函数
函数也可以定义为泛型,以处理不同类型的数据。例如,下面的 last 函数可以返回数组的最后一个元素,而不限定数组的元素类型:
function last<T>(items: T[]): T {
return items[items.length - 1];
}
last([1, 2, 3]); // 返回 3
last(['a', 'b', 'c']); // 返回 'c'
调用泛型函数时,类型参数可以显式或隐式指定:
// 显式指定类型参数
last<string>(['apple', 'banana']);
last<number>([10, 20, 30]);
// 隐式推断类型参数
last([true, false, true]);
4 泛型默认值
在泛型中可以为类型参数设置默认值,如果未提供实际类型实参,则使用默认类型:
class Box<T = string> {
contents: T;
constructor(value: T) {
this.contents = value;
}
}
let box1 = new Box<number>(42); // T 为 number
let box2 = new Box(); // T 使用默认类型 string
对于函数,泛型参数的默认值同样可用:
function createArray<T = number>(length: number, value: T): T[] {
return Array(length).fill(value);
}
createArray(3, 'hello'); // 返回 ['hello', 'hello', 'hello']
createArray(3, 42); // 返回 [42, 42, 42]
泛型默认值提高了泛型的灵活性,让代码适配更多场景。
十一:模块和导入导出
在 ArkTS 中,程序可以划分为多个模块。模块为每个部分提供独立的作用域,模块中的声明在其他模块中不可见,除非显式导出。通过导入,其他模块可以访问导出的内容。以下为模块的基础用法,包括导出和导入的多种形式。
1. 导出
可以使用 export 关键字导出模块内的顶层声明。导出后,声明名称可以在其他模块中导入和使用。未导出的声明在模块外部不可见。
// point.ts
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) ** 2 + (p2.y - p1.y) ** 2);
}
2. 静态导入
在其他模块中,使用 import 关键字导入需要的内容:
// main.ts
import { Point, Origin, Distance } from './point';
let p1 = new Point(3, 4);
console.log(Distance(Origin, p1)); // 输出:5
3. 导入绑定
可以使用不同的导入形式以灵活地绑定导出内容。
-
导入全部:
import * as Utils导入模块所有内容,并通过Utils引用。import * as Utils from './point'; console.log(Utils.Origin); -
选择性导入:
import { X, Y }仅导入特定内容。import { Origin, Distance } from './point'; -
重命名导入:可以为导入的内容定义别名,避免命名冲突。
import { Distance as CalculateDistance } from './point';
4. 动态导入
动态导入允许按需加载模块,这种方式更适合条件导入或延迟加载的场景。import() 会返回一个 Promise。
async function testDynamicImport() {
let module = await import('./say');
module.hi();
module.bye();
}
5. HarmonyOS SDK的开放能力导入
在 HarmonyOS 开发中,SDK 提供的开放能力(接口)可通过导入 SDK 模块来使用。HarmonyOS 引入了 Kit 概念以便开发者调用所需的接口模块。
- 导入 Kit 单个模块:
import { UIAbility } from '@kit.AbilityKit'; - 导入 Kit 多个模块:
import { UIAbility, Ability } from '@kit.AbilityKit'; - 导入 Kit 全部模块:
import * as module from '@kit.AbilityKit';(慎用,避免导入无用模块)
6. 顶层语句
顶层语句指的是不包裹在函数、类或块级作用域中的模块最外层语句,通常包括变量声明、函数声明等。
// 顶层变量
let topLevelVariable = 'Hello';
// 顶层函数
function topLevelFunction() {
console.log(topLevelVariable);
}
模块化使程序更易于维护和调试,同时提高代码的复用性与安全性。在 HarmonyOS SDK 中,合理使用静态导入和动态导入能够优化资源占用,避免包体积过大。
1973



被折叠的 条评论
为什么被折叠?



