ArkTS语言(二)
学习ArkTS语言
ArkTS是HarmonyOS的主要应用开发语言，在TypeScript基础上进行了扩展，保留了其基本风格，并通过增强静态检查和分析来提高程序的稳定性和性能。本教程将帮助开发者掌握ArkTS的核心功能、语法及最佳实践，以便高效地构建高性能移动应用。
1.函数
1.1 函数概述
函数是可以被重复使用的代码块，它可以接受输入参数，执行一系列操作，然后返回输出结果。
为了方便大家理解，我想到一个非常形象的生活案例帮助大家理解；如下图所示，有一个包饺子神器，当我们需要包饺子时，准备好饺子皮和饺子馅，放在包饺子神器上一夹，一个完整的饺子就做出来了。
在这个案例中，包饺子神器就是一个可以重复利用的函数，饺子皮和陷就是函数接受的参数，而“夹”这个动作就是函数执行的操作，做出来的饺子就是函数的返回结果。
函数必须先声明才能使用，函数声明包含其名称、参数列表、返回类型和函数体。下面是函数声明的格式
function 函数名(参数名1: 类型, 参数名2: 类型): 返回值类型{
....
return 返回值;
}
例：声明一个函数，能够接受两个整数，执行求和的操作，并返回两个数的和。
function add(x:number, y: number): number{
let z = x+y;
return z;
}
1.2 函数调用
注意函数声明好了，必须调用才能执行。下面演示函数的调用
let s = add(3,4) //调用add函数，求3与4的和，并把和值赋值给变量s
console.log(”两个数的和为：",s)
let s1 = add(4,6) //重复调用add函数
console.log(”两个数的和为：",s1)
1.3 无返回值函数
函数可以没有返回值，此时方法体内不需要写return语句，返回值类型用void代替
例：声明一个函数，能够接受两个整数，执行求最和操作，直接和在函数内打印输出。
//声明函数
function max(x:number, y: number): void{
let z = x+y;
console.log(”两个数的最大：",z)
}
//调用函数
max(3,4)
max(4,6)
1.4 无参数函数
函数可以不接受输入数据，此时()中什么都不写，调用函数时也不用传递参数。
例：声明一个函数，打印10个“Hello HarmonyOS”
//声明函数
function print(){
for (let i=0; i<10;i++){
console.log('Hello HarmonyOS')
}
}
//调用函数
print()
1.5 返回类型推断
如果可以从函数体内推断出函数返回类型，则可在函数声明中省略标注返回类型。
// 显式指定返回类型
function foo(): string {
return 'foo';
}
// 推断返回类型为string
function goo() {
return 'goo';
}
1.6 箭头函数
箭头函数（又名Lambda函数），它是一种比普通函数更加简洁的函数写法。
- 箭头函数的格式
let 函数名 = (参数列表):返回值类型=>{
函数的执行代码
return 结果
}
例：使用箭头函数，矩形的面积
//声明箭头函数
let rectArea = (width: number, height: number): number => { return width * height }
//调用箭头函数
let s1: number = rectArea(100,50)
- 箭头函数的返回值类型可以省略，省略时，返回值通过类型推断；
//声明箭头函数
let rectArea = (width: number, height: number) => { return width * height }
//调用箭头函数
let s1 = rectArea(100,50)
- 如果箭头函数的函数体语句只有一条，{}、return也可以省略
//声明箭头函数
let rectArea = (width: number, height: number) => width * height
//调用箭头函数
let s2 = rectArea(100,50)
1.7 高阶函数
高阶函数是指：接受函数作为参数，或者返回一个函数的函数。
- 通常将箭头函数作为方法的参数使用
// 这是一个高阶函数，它接受一个函数作为参数
function greet(callback:Function) {
callback(); // 调用回调函数
}
// 箭头函数作为参数传递
greet(() => {
console.log("Welcome!");
})
1.8 可选参数
在参数名称后面加上?表示参数是可选的，意思就是调用时可以传递参数，也可以不传递参数。
function buildName(firstName: string, lastName?: string) {
if (lastName)
return firstName + " " + lastName;
else
return firstName+"富贵";
}
let result1 = buildName("李"); // 正确
let result2 = buildName("李", "世明"); // 正确
1.9 可变参数
可变参数指的是可以让函数接受任意数量的参数。可变参数其本质是一个数组。
// 需求：定义函数，求任意几个数据的和
function sum(...numbers: number[]): number {
let sum = 0;
for (let num of numbers) {
sum += num;
}
return sum;
}
// 调用函数，传入任意数量的参数
let res1 = sum(1, 2, 3)
let res2 = sum(1, 2, 3, 4, 5, 6)
2. 面向对象
2.1 对象概述
面向对象是一种编程方式，这种编程方式的核心是把关注点放在对象身上，每个对象包含自身的数据和对数据的处理方式。
如下图所示：
● 学生是一个对象：包含有学生的姓名、语文、数学成绩等数据、以及对这些数据进行处理的函数。
● 汽车是一个对象：包含有汽车的品牌、颜色、价格等数据、以及对这些数据进行处理的函数。
● 手机是一个对象：包含有品牌、价格、CPU型号等数据、以及对这些数据进行处理的函数。
所以，对象可以理解成是一个封装有数据和函数的容器。 数据在哪个对象中，就调用哪个对象的函数来处理数据。
2.2 类与对象
我们知道对象中包含数据以及对数据处理的函数。 那问题来了，对象中封装哪些数据？ 对数据进行怎样的处理？ 这就需要引出类的概念：类。类就是用来描述对象的属性和行为的，类是对象的模版。
- 定义类
定义类的关键字为 class，后面紧跟类名（约定首字母大写），类中的成员一般由属性、构造函数、方法组成；
● 属性：表示字对象拥有的相关数据；
● 构造函数：创建对象时执行，用于给属性初始化值；
● 方法：处理属性数据的行为
示例：
//定义学生类
class Student {
//属性：表示字对象拥有的相关数据；
name: string
chinese: number
math: number
//构造函数：创建对象时执行，用于给属性初始化值；
constructor(name: string, chinese: number, math: number) {
this.name = name
this.chinese = chinese
this.math = math
}
//方法：处理属性数据的行为
printTotal(): void {
console.log(this.name + "的总分："+(this.chinese + this.math))
}
}
- 创建Student对象
有了Student类之后，就可以Student类为模版创建出一个一个的对象实体。
//这里new关键字，用于执行Student类的构造器
let stu1 = new Student('张三', 90, 100)
stu1.printTotal() //张三的总分： 190
//这里new关键字，用于执行Student类的构造器，没传递参数，此时使用的是默认值
let stu3 = new Student()
stu3.printTotal() //Unkonw的总分： 0
2.3 对象字面量
对象字面量是一个表达式，可用于创建类实例并提供一些初始值。它在某些情况下更方便，可以用来代替new表达式。
对象字面量的表示方式是：封闭在花括号对{}中的'属性名：值'的列表。
class Dog{
name: string = ''
age: number = 0
}
//对象字面量
let dog: Dog = {name: '旺财', age: 2}
//调用对象的属性
console.log('狗的姓名',dog.name) //狗的姓名 旺财
console.log('狗的年龄',dog.age) //狗的年龄 0
也可以在数组中用，在数组中存储多个对象字面量
let dogs: Dog[] = [{name: '旺财', age: 2},{name: '大黄', age: 5}]
for (let dog of dogs){
console.log(`狗的名字:${dog.name}, 狗的年龄:${dog.age}`)
}
2.4 继承
继承是面向对象编程（OOP）中的一个非常重要的概念，它允许我们创建一个新类（子类），该子类可以继承现有类（父类）的属性和方法。通过继承，子类可以重用父类的代码，并且可以根据需要进行扩展和修改。
示例:
让Employee员工类继承Person类，同时Employee类扩展了新的dept属性和getEmployeeInfo()方法。
- 定义Person类
//定义类 Person
class Person {
//类中的属性
private name: string
private age: number
//构造器
constructor(name: string, age: number) {
this.name = name;
this.age = age;
}
//方法
public getPersonInfo(): string {
return `My name is ${this.name} and age is ${this.age}`;
}
}
- 定义Employee类
//Employee员工类 继承 Person人类
class Employee extends Person {
//部门
private dept: string
//构造器
constructor(name: string, age: number, dept: string) {
super(name, age); //super(...)
this.dept = dept;
}
//方法
public getEmployeeInfo(): string {
return this.getPersonInfo() + ` and work in ${this.dept}`;
}
}
- 测试创建Employee对象，调用子类和父类方法
let p3 = new Employee('Tom', 28, 'HuaWei');
console.log(p3.getPersonInfo()); //"My name is Tom and age is 28"
console.log(p3.getEmployeeInfo()); //"My name is Tom and age is 28 and work in HuaWei"
2.5 可见性修饰符
类的属性、函数、构造器都叫做类的成员，他们都可以使用可见性修饰符修饰。可见性修饰符包括：private、protected和public。默认可见性为public。
● public（公有）
public修饰的类成员在程序的任何可访问该类的地方都是可见的。
● private（私有）
private修饰的成员不能在声明该成员的类之外访问，例如：
- protected（受保护）
protected修饰符的作用与private修饰符非常相似，不同点是protected修饰的成员允许在派生类（子类）中访问，例如：
2.6 接口
接口是一系列抽象函数和属性的集合，这些属性都应该是抽象的，需要由具体的类去实现。
- 接口定义
接口定义如下：定义一个Animal接口，描述动物的行为有eat()和sleep()
interface Animal{
name: string
age: number
eat():void; //吃，怎么吃不知道
sleep():void; //睡，怎么睡也不知道
}
- 接口实现
接口定义好之后，需要类来实现接口中的抽象方法。这里所说的实现实际上就是方法重写的意思，而且必须重写接口中的全部抽象方法，有属性同时必须给属性赋值。
class Dog implements Animal{
name: string ='大黄';
age: number = 2;
eat(): void {
console.log(`${this.name}今天${this.age}岁了，它坐在家门口吃东西`)
}
sleep(): void {
console.log(`${this.name}今天${this.age}岁了，它坐在家门口睡觉`)
}
}
//创建对象
let dog = new Dog();
dog.eat();
dog.sleep();
- 接口对象
还可以在无需定义接口实现类的情况下，直接通过接口直接创建对象。
//接口
interface IPerson {
firstName: string,
lastName: string,
sayHi: () => string
}
//接口实例
let customer: IPerson = {
firstName: "Tom",
lastName: "Hanks",
sayHi: (): string => {
return `${customer.firstName} ${customer.lastName} Hi I'm here`
}
}
//调用实例方法
let res = customer.sayHi()
console.log(res)
2.7 多态
多态是面向对象编程（OOP）中的核心概念之一，它允许不同类的对象通过相同的接口表现出不同的行为。多态的本质是“同一接口，不同实现”，这使得程序在面对不同类型的对象时，能够根据具体类型自动调用对应的方法，而不需要显式区分对象的类型。
//形状接口
interface IShape{
area():number;
}
//矩形类
class Rect implements IShape{
width:number;
height:number
constructor(widht:number, height:number){
this.width = widht;
this.height = height;
}
public area():number{
return this.width*this.height
}
}
//圆形类
class Circle implements IShape{
radius:number
constructor(radius:number){
this.radius = radius;
}
public area():number{
return this.radius*this.radius*Math.PI;
}
}
//定义一个形状操作类
class ShapeOperation{
//求任意形状的面积
public printShapArrea(shape:IShape):void{ // shape: IShape = new Rect(3,4)
let rest = shape.area();
//判断shape是否为Rect的实例
if(shape instanceof Rect){
console.log("矩形的面积"+rest)
}else if(shape instanceof Circle){
console.log("圆形的面积"+rest)
}
}
}
//创建形状操作类对象
let sop = new ShapeOperation();
//求矩形的面积
sop.printShapArrea(new Rect(3,4));
//求圆形的面积
sop.printShapArrea(new Circle(10));
3. 内置函数
在ArkTS中内置来很多函数可以直接调用，这些函数是全局的，在哪里都能用
3.1 parseInt() 和 parseFloat()
● parseInt() 用于将字符串解析成整数。
● parseFloat() 用于将字符串解析成浮动点数。
parseInt("10"); // 10
parseFloat("10.5"); // 10.5
3.2 decodeURI() 和 encodeURI()
● decodeURI() 用于解码一个已编码的 URI 字符串。
● encodeURI() 用于编码一个 URI 字符串。
encodeURI("https://www.example.com/?name=John Doe"); // "https://www.example.com/?name=John%20Doe"
decodeURI("https://www.example.com/?name=John%20Doe"); // "https://www.example.com/?name=John Doe"
3.3 setTimeout() 和 setInterval()
● setTimeout() 用于在指定的时间延迟后执行某个函数。
● setInterval() 用于每隔一段时间重复执行某个函数。
setTimeout(() => console.log("Hello after 2 seconds"), 2000); // 2秒后输出
setInterval(() => console.log("Hello every 2 seconds"), 2000); // 每2秒输出
3.4 clearTimeout() 和 clearInterval()
- clearTimeout() 用于取消由 setTimeout() 设置的定时器。
- clearInterval() 用于取消由 setInterval() 设置的定时器。
const timeoutId = setTimeout(() => console.log("This won't be logged"), 2000);
clearTimeout(timeoutId); // 取消定时器
const intervalId = setInterval(() => console.log("Hello every 2 seconds"), 2000);
clearInterval(intervalId) //取消定时器
3.5 String()、Number()、Boolean()
- 这些函数用于将其他类型的数据转换为字符串、数字或布尔值。
String(123); // "123"
Number("123"); // 123
Boolean(0); // false ,0为假，非0为真
3.6 JSON.parse() 和 JSON.stringify()
● JSON.parse() 用于将 JSON 字符串解析为 JavaScript 对象。
● JSON.stringify() 用于将 JavaScript 对象转换为 JSON 字符串。
interface Student{
name:string,
age:number
}
let student:Student = {
name:"张三",
age:20
}
let jsonString:string = JSON.stringify(student)
console.log(jsonString) // '{"name":"张三","age":20}'
const student1 = JSON.parse('{"name":"张三","age":20}') as Student
console.log(`${student1.name}`) //张三
console.log(`${student1.age}`) //20
浙公网安备 33010602011771号