声明
变量声明
let s: string = 'hello';
s = 'hello world';
常量声明
const s:string = 'hello world';
自动类型推断
ArkTs声明变量的时候，如果存在初始值，那么就可以省略变量类型，ArkTs会根据初始值自动推断变量类型。ArkTs是静态类型语言，变量类型在编译时就已经确定，不允许在代码中动态修改变量类型。
let s: string = 'hello';
let s = 'hello';
类型
基础类型
Number
ArkTs提供number和Number类型， 任何整数和浮点数都可以被赋予这两种类型。
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
let isDone: boolean = false;
String
string类型可以用单引号’或者双引号“来包裹，如果要使用字符串模板，那么字符串需要用反引号`来包裹。
let s1 = 'hello';
let s2 = "hello";
let s3 = `hello ${a}`;
引用类型
Void
void一般用于表示函数没有返回值，也可以用于泛型中。
Object
Object是所有类型的基类，任何类型都可以被赋予Object类型的变量。
Array
数组
Enum
枚举类型
enum ClolrSet {Red, Green, Black}
let color : ColorSet = ColorSet.Red;
也可以给枚举常量显示赋值
enum ColorSet {Red = 0xff}
Union
union，联合类型，由多个类型联合组成的引用类型，联合类型的变量，可能是联合类型中任意一种类型。联合类型需要用type关键字来进行定义。
type A = number | string
let a : A = 3;
a = 'abc';
据鸿蒙官方文档，在联合类型中，可以用instanceof关键字来进行类型判断
if (a instanceof string) {
//do something
} else if (a instanceof number) {
//do something
}
实际在DevEco studio中实测，instanceof关键字不可用，会报错提示instanceof左侧类型必须为any
实际上arkTs中也没有any类型，只有Object类型
实测，可以用typeof关键字来确认联合类型中的具体类型
Aliases
aliases类型主要是为匿名函数、联合类型或者已有类型进行新的命名，使用type关键字
type Matrix = number[][]
type Callback = (s: string, num: number) => string //回调函数
type Callback1<T> = (x: T) => boolean; //带泛型的回调函数
type nullableString = string | null //联合类型，定义可空字符串
语句
if语句
switch语句
条件表达式 ?:
for语句
for of语句
for of 语句可以用来遍历数组、map、字符串等。
let arr = [10, 20, 30];
for(let a of arr) {
console.log(a);
}
while语句
do while语句
break
continue
throw和try catch finally语句
函数
函数声明
一个函数包括关键字、函数名称、参数、返回值、方法体。
function add(a:number, b:number) : number {
return a + b;
}
可选参数
可选参数有两种形式，name?: Type 或者 a : number = 2
function a (name?:string) {
if(name == undefined) {
console.log('没有传入可选参数');
} else {
console,log(name);
}
}
function b (name : string = 'abc') {
console.log(name);
}
b(); //输出abc
b('def');//输出def
Rest参数
函数的最后一个参数可以是rest参数，允许函数接收任意数量的实参。
// rest参数由... 参数名称：数组形式的参数类型组成
function c (... s : string[]) {
}
返回类型
ArkTs允许函数省略返回类型，由编译器从函数中推断返回类型
function a() : string {return 'abc';}
等价于
function b() {return 'abc';}
function c() :void {console.log('abc');}
等价于
function d() {console.log('abc');}
函数的作用域
函数内定义的变量仅能从函数内部方位，无法从函数外部访问。如果函数内部定义的变量与函数外部定义的函数同名，则函数内部定义的变量将会覆盖外部定义。
函数类型
函数类型通常用于定义回调
//定义了一个Callback类型，该类型是一个接收string入参，没有返回值的函数
type Callback = (message : string) => void;
//创建一个使用回调的函数
function doSomething(callback: Callback) {
callback('abc');
}
//使用回调函数,打印出abc
doSomething((message) => {
console.log(message);
}
箭头函数
箭头函数又称为lambda函数，例如
// 箭头函数可以通过将函数赋值给一个变量，可以省略function关键字
// 用`=>`连接函数体
let a = (a:number, b:number) : number => { return a+b;}
//同时也可以省略返回类型，由编译器进行类型推断，等价于
let b = (a:number, b:number) => {return a+b;}
//如果函数只有一行的话，花括号和return也可以省略，等价于
let c = (a:number,b:number) => a+b;
闭包
在一个函数内部调用/创建另一个函数。把内嵌的函数称为闭包，它可以访问外部函数的局部变量。
闭包通常用于回调函数。
闭包的使用场景
用来返回某个值
function a() {
let s = 'hello';
return () => s; //arkTs没有函数表达式，只能使用箭头函数
}
let c = a();
let d = c();
console.log(d); //打印d的结果为hello，实际调用的是b函数（d是c()的返回结果，c是a()的引用，a()实际返回的是b()，b()的返回值是a()内部的变量s）
函数赋值，在函数内部定义函数表达式，ArkTs不支持该使用方式
将闭包作为函数的参数，形成回调函数
let a = (num: number,) => {
return console.log(num.toString());
}
function b(number1: number, number2: number, callback: (num: number) => void) {
let sum = number1 + number2;
callback(sum);
}
b(1, 2, a)
与函数类型结合使用，演进为
type Callback = (num: number) => void;
let a = (num: number,) => {
return console.log(num.toString());
}
function c(number1: number, number2: number, callback: Callback) {
let sum = number1 + number2;
callback(sum);
}
c(1, 2, a)
进而演进,形成我们经常使用的回调函数
type Callback = (num: number) => void;
function d(number1: number, number2: number, callback: Callback) {
let sum = number1 + number2;
callback(sum);
}
d(1, 2, (num) => {
console.log(num.toString())
})
函数重载
我们可以通过编写重载，指定函数的不同调用方式。具体方法为，为同一个函数写入多个同名但签名不同的函数头，函数实现紧随其后，函数定义和实现需要跟在一起
function foo(x: number): void; /* 第一个函数定义 */
function foo(x: string): void; /* 第二个函数定义 */
function foo(x: number | string): void { /* 函数实现 */
consolo.log(x.toString());
}
foo(123); // OK，使用第一个定义
foo('aa'); // OK，使用第二个定义
类
类初始化、字段、创建实例
以下是一个示例
class Person {
private name: string
private age: number
constructor(name: string, age: number) {
this.name = name
this.age = age
}
say() {
console.log(`my name is ${this.name}, i am ${this.age}`)
}
}
arkTs中，类中的方法直接定义，不需要function关键字。
arkTs中，类的属性值默认情况下是需要在定义的时候进行赋值，或者在构造函数中进行赋值。以保证尽可能少的返回undefined的情况，如果确实需要有undefined情况，可以按照如下写法
class Person1 {
private name?: string
getName(): string | undefined {
return this.name
}
}
let person1 = new Person1()
person1.getName()?.length
在上述示例中，字段上边使用?:关键字，表示该字段可以是undefined，这样可以不用进行初始化。
此时该字段的实际类型为联合类型stirng|undefined，可以看到get方法中的返回值。
在实例化该对象后，调用getName方法时，需要进行判空或者使用?.可选链语法
arkTs不支持多构造函数，会报错,仅允许相同参数数量，但多种类型的构造方法重载，与函数重载类似
创建对象需要用到new关键字
let person = new Person("name",15);
person.say();
也可以用字面量的方式来创建对象，仅限于简单类型，没有自定义方法的类
class Point {
x: number = 0
y: number = 0
}
let p: Point = {x: 42, y: 42};
get和set方法
class Person {
private name: string
private _age: number
static a: string
constructor(name: string, age: number) {
this.name = name
this._age = age
}
get age() : number {
return this._age;
}
set age(num:number) {
//可以在这里做一些校验类的操作
this._age = num;
}
say() {
console.log(`my name is ${this.name}, i am ${this.age}`)
}
}
let person = new Person("name", 15);
person.say();
person.age;//输出15
person.age = 100;
上述例子中，我们对age属性设置了get和set方法，arkTs中，get和set方法，最终也是通过字段的形式去读取和设置的，所以在定义get和set方法的时候，虽然有前置的get和set关键字，但是方法名还是不能和字段名重复，否则会报错重复定义。
同时，加上前置的get和set关键字后，该方法就可以直接用字段的形式进行访问，方法名字和对应的字段名之间没有具体的关联，可以随意设置，但不能相同。
继承
class extends A implements b {
}
可见性修饰符
private protected public 默认为public
泛型默认值
泛型类型的类型参数可以设置默认值。这样可以不指定实际的类型实参，而只使用泛型类型名称。
空安全
默认情况下，arkTs中的所有类型都是不可为空的。 不经处理的情况下，直接赋值null会报错。
可选链
arkTs中使用?.来表示可选链，在访问对象属性时，如果该属性是null或者undefined时，可选链上后续代码将不在执行，直接返回undefined
非空断言
在调用链中，我们可以使用!.的方式来进行非空断言，此时编译器将不在对可空对象进行校验。在实际运行中，如果使用断言的位置出现了null，将抛出异常。
空值合并运算符
在arkTs中，使用??作为空值合并运算符，当??左侧的值为null或者undefined时，返回右侧结果，否则返回左侧结果，等价于使用三元运算符进行判断。
模块
一个程序中，可以被划分为多组编译单元或者模块。
每个模块都有自己的作用域，在模块中创建的任何声明，在模块外都不可见，除非他们被显示的导出。
使用另一个模块中的声明，也需要进行显示的导入操作。
导出
导出使用export关键字
导入
静态导入
导入声明分为两部分
导入路径：用于指定导入的模块
导入绑定：用于定义导入的模块中的可用实体集及使用形式
导入绑定
导入绑定可以有几种形式
假设模块具有路径./utils和导出实体X和Y
import * as Utils from './utils'
表示将路径中所有导出的实体都引入进来，并且设置了别名Utils，可以直接使用别名访问对应导出实体。
import {X, Y} from './utils'
引入实体X和Y，可在当前模块中直接使用X和Y
import {X as Z, Y} from './utils'
引入实体X和Y，同时对X设置了别名Z，此时在模块中可以直接使用Y和Z，但不能使用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();
}
导入kit
从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包含的所有模块的接口能力。例如：
其中，“module”为别名，可自定义，然后通过该名称调用模块的接口。import * as module from '@kit.AbilityKit';
特别注意：方式三可能会导入过多无需使用的模块，导致编译后的HAP包太大，占用过多资源，请谨慎使用。