ArkTS基础

ArkTS：是一门用于开发鸿蒙应用的编程语言。
日志输出：console.log('xxx')，例：console.log(‘鸿蒙’, ‘Hello World’)

一 基础数据类型

三种常见的基础数据类型：
① string 字符串：描述信息
② number 数字：计算
③ boolean 布尔：判断 （真、假）

1.1 存储数据（变量、常量）

变量：专门用来存储数据的容器
let title: string

let title: string = '香蕉'
let price: number = 13.7
let isSelect: boolean = false
title = '新鲜香蕉'

常量：用来存储数据 （不可变）
const 常量名: 类型 = 值

const PI: number = 3.1415926

变量常量的注意事项（命名规则）：
① 只能包含数字、字母、下划线、$，不能以数字开头
② 不能使用内置关键字或保留字 （比如 let、const）
③ 严格区分大小写

另var：声明函数作用域的变量，不过在现代 ArkTS 开发中，更推荐使用 let 和 const。

var counter = 0;
function increment() {
    counter++;
}

二 数组

数组：是一个容器，可以存储多个数据

let 数组名: 类型[] = [数据1, 数据2,...]
let names: string[] = ['小红', '小明', '大强']

注意：数组指定的类型和存储的数据类型要必须一致，否则会报错
获得数组元素： 数组名[索引]

let names: string[] = ['小红', '小明', '大强']
console.log('取出小明', names[1])

注意：索引号是从 0 开始的

2.1 静态初始化

可以使用方括号 [] 来创建数组，并在其中直接添加元素。示例代码如下：

// 声明并初始化一个包含数字的数组
let numbers: number[] = [1, 2, 3, 4, 5];

// 声明并初始化一个包含字符串的数组
let fruits: string[] = ["apple", "banana", "cherry"];

上述代码中，分别创建了数字类型和字符串类型的数组。

2.2 动态初始化

使用 new Array() 构造函数可以动态地创建数组。示例如下：

// 创建一个长度为 3 的数组
let emptyArray: number[] = new Array(3);

// 创建一个包含特定元素的数组
let mixedArray: (string | number)[] = new Array("hello", 123);

在第一个示例中，创建了一个长度为 3 的数字类型数组，但元素初始值为 undefined。第二个示例创建了一个包含不同类型元素的数组。

2.3 修改数组元素

通过索引可以修改数组中指定位置的元素。示例如下：

let scores: number[] = [80, 90, 75];
// 修改第二个元素
scores[1] = 95; 
console.log(scores); 

这里将数组中索引为 1 的元素修改为 95。

2.4 数组方法

ArkTS 提供了许多数组方法来操作数组，以下是一些常用方法的示例：
push()
用于在数组末尾添加一个或多个元素，并返回新的数组长度。示例如下：

let animals: string[] = ["dog", "cat"];
let newLength = animals.push("rabbit");
console.log(animals); 
console.log(newLength); 

上述代码在 animals 数组末尾添加了 “rabbit” 元素，并输出了新数组和新长度。
pop()
用于移除数组的最后一个元素，并返回该元素。示例如下：

let numbers: number[] = [1, 2, 3];
let lastNumber = numbers.pop();
console.log(numbers); 
console.log(lastNumber); 

splice()
用于添加或删除数组中的元素。示例如下：

let fruits: string[] = ["apple", "banana", "cherry"];
// 从索引 1 开始删除 1 个元素，并插入 "grape"
fruits.splice(1, 1, "grape");
console.log(fruits); 

2.5 数组遍历

for 循环

let numbers: number[] = [1, 2, 3, 4, 5];
for (let i = 0; i < numbers.length; i++) {
    console.log(numbers[i]);
}

for…of 循环

let fruits: string[] = ["apple", "banana", "cherry"];
for (let fruit of fruits) {
    console.log(fruit);
}

for…of 循环直接遍历数组中的每个元素。
forEach() 方法

let scores: number[] = [80, 90, 75];
scores.forEach((score) => {
    console.log(score);
});

forEach() 方法为数组中的每个元素执行一次提供的函数。

三 函数

ArkTS 是基于 TypeScript 扩展的开发语言，在函数定义上既保留了 TypeScript 的特性，又有自己的一些规范和使用场景。下面为你详细介绍 ArkTS 函数的语法。

3.1 函数声明

ArkTS 函数声明的基本语法如下：

function 函数名(参数1: 类型, 参数2: 类型, ...): 返回值类型 {
    // 函数体
    return 返回值;
}

以下是一个简单的示例，该函数接收两个数字类型的参数，返回它们的和：

function add(a: number, b: number): number {
    return a + b;
}

// 调用函数
let result = add(3, 5);
console.log(result); 

3.2 可选参数与默认参数

可选参数
在参数名后面加上 ? 表示该参数是可选的。可选参数必须放在必选参数之后。

function greet(name: string, message?: string): string {
    if (message) {
        return `Hello, ${name}! ${message}`;
    }
    return `Hello, ${name}!`;
}

console.log(greet('Alice')); 
console.log(greet('Bob', 'Have a nice day!')); 

默认参数
可以为参数设置默认值，当调用函数时没有传入该参数，就会使用默认值。

function calculateArea(radius: number, pi: number = 3.14): number {
    return pi * radius * radius;
}

console.log(calculateArea(5)); 
console.log(calculateArea(5, 3.14159)); 

剩余参数
使用 … 语法来定义剩余参数，它允许函数接收任意数量的参数，并将这些参数收集到一个数组中。

function sum(...numbers: number[]): number {
    let total = 0;
    for (let num of numbers) {
        total += num;
    }
    return total;
}

console.log(sum(1, 2, 3)); 
console.log(sum(1, 2, 3, 4, 5)); 

箭头函数
箭头函数是一种简洁的函数定义方式，适合用于简单的函数逻辑。

// 单个参数
const square = (x: number): number => x * x;
console.log(square(4)); 

// 多个参数
const multiply = (a: number, b: number): number => a * b;
console.log(multiply(3, 5)); 

// 无参数
const getRandomNumber = (): number => Math.random();
console.log(getRandomNumber()); 

3.3 函数重载

函数重载允许一个函数根据不同的参数类型和数量提供不同的实现。在 ArkTS 中，先声明多个函数签名，最后实现一个通用的函数。

// 函数重载声明
function add(a: number, b: number): number;
function add(a: string, b: string): string;
// 函数实现
function add(a: number | string, b: number | string): number | string {
    if (typeof a === 'number' && typeof b === 'number') {
        return a + b;
    } else if (typeof a === 'string' && typeof b === 'string') {
        return a + b;
    }
    throw new Error('Invalid argument types');
}

console.log(add(2, 3)); 
console.log(add('Hello, ', 'World!')); 

类中的方法
在 ArkTS 里，函数也可以作为类的方法存在。

class Rectangle {
    width: number;
    height: number;

    constructor(width: number, height: number) {
        this.width = width;
        this.height = height;
    }

    // 类的方法
    getArea(): number {
        return this.width * this.height;
    }
}

let rect = new Rectangle(5, 10);
console.log(rect.getArea()); 

四 联合类型

联合类型是一种灵活的数据类型，它修饰的变量可以存储不同类型的数据。

4.1 语法

let 变量: 类型1 | 类型2 | 类型3 = 值

let judge: number | string = 100
judge = 'A'

基于联合类型，变量可存不同类型数据

1. 如何让变量，可以存储多种类型的数据？
   联合类型：是由多个类型联合组合成的数据类型。

let judge: number | string = 100
judge = 'A'

2. 如何把变量值限定在一组数据范围内选择？

let gender: 'man' | 'woman' | 'secret'

4.2 联合类型作为函数参数和返回值

作为函数参数
联合类型可以用于函数参数，使函数能够接受多种类型的参数。

function printValue(value: string | number) {
    if (typeof value === 'string') {
        console.log(`The string value is: ${value}`);
    } else {
        console.log(`The number value is: ${value}`);
    }
}

printValue("hello"); 
printValue(123); 

作为函数返回值
函数的返回值也可以是联合类型，这表示函数可能返回不同类型的值。

function getValue(): string | number {
    if (Math.random() > 0.5) {
        return "random string";
    } else {
        return Math.floor(Math.random() * 100);
    }
}

let result = getValue();
console.log(result); 

联合类型与数组
联合类型可以和数组结合使用，创建包含多种类型元素的数组。

let array: (string | number)[] = ["apple", 1, "banana", 2];
for (let item of array) {
    if (typeof item === 'string') {
        console.log(`String item: ${item}`);
    } else {
        console.log(`Number item: ${item}`);
    }
}

在这个例子中，array 数组的元素类型可以是字符串或者数字。

类型保护
当使用联合类型时，由于变量可能是多种类型中的某一种，在访问特定类型的属性或方法时需要进行类型检查，这就是类型保护。常见的类型保护方式有 typeof、instanceof 和自定义类型保护函数。
使用 typeof 进行类型保护

function add(a: string | number, b: string | number): string | number {
    if (typeof a === 'string' && typeof b === 'string') {
        return a + b;
    } else if (typeof a === 'number' && typeof b === 'number') {
        return a + b;
    }
    return "Invalid input";
}

console.log(add("hello", " world")); 
console.log(add(1, 2)); 

自定义类型保护函数

function isString(value: string | number): value is string {
    return typeof value === 'string';
}

function processValue(value: string | number) {
    if (isString(value)) {
        console.log(`The string length is: ${value.length}`);
    } else {
        console.log(`The number squared is: ${value * value}`);
    }
}

processValue("hello"); 
processValue(5); 

4.3 联合类型的应用场景

**处理不同数据源：**当数据可能来自不同的接口，格式有所差异时，使用联合类型能使代码更具灵活性。
**实现可选参数：**函数参数可能有多种类型，使用联合类型可以让函数接受不同类型的参数。
通过使用联合类型，能让代码更加灵活，增强类型系统的表达能力，处理各种复杂的情况。

五 枚举类型

在 ArkTS 中，枚举类型（enum）是一种用于定义一组命名常量的数据类型。它允许你为一组相关的值赋予有意义的名称，从而提高代码的可读性和可维护性。以下是关于 ArkTS 枚举类型的详细介绍：

5.1 基本语法

ArkTS 支持数字枚举和字符串枚举，下面分别介绍它们的语法和使用方式。

• 数字枚举
  数字枚举是最常见的枚举类型，枚举成员会被自动赋予从 0 开始递增的数字值，也可以手动指定初始值。

  // 定义一个数字枚举
  enum Direction {
  	North,
  	South,
  	East,
  	West
  }
  
  // 使用枚举成员
  let myDirection: Direction = Direction.North;
  console.log(myDirection); // 输出: 0
  
  // 手动指定初始值
  enum Color {
  	Red = 1,
  	Green,
  	Blue
  }
  
  console.log(Color.Red);   // 输出: 1
  console.log(Color.Green); // 输出: 2
  console.log(Color.Blue);  // 输出: 3
  

• 字符串枚举
  字符串枚举的每个成员都必须用字符串字面量或另一个字符串枚举成员进行初始化

  // 定义一个字符串枚举
  enum Language {
  	English = "EN",
  	Chinese = "ZH",
  	Spanish = "ES"
  }
  
  // 使用字符串枚举成员
  let myLanguage: Language = Language.Chinese;
  console.log(myLanguage); // 输出: "ZH"
  

• 异构枚举
  异构枚举是指枚举中同时包含数字和字符串成员。不过，这种用法相对较少，因为它可能会使代码变得复杂。

  // 定义一个异构枚举
  	enum Result {
  	Success = 1,
  	Error = "ERROR"
  }
  
  console.log(Result.Success); // 输出: 1
  console.log(Result.Error);   // 输出: "ERROR"
  

• 枚举成员的访问
  可以通过枚举名和成员名来访问枚举成员的值，也可以通过值来反向查找枚举成员的名称。

  	enum Size {
  	Small = "S",
  	Medium = "M",
  	Large = "L"
  }
  
  // 通过成员名访问值
  let sizeValue: string = Size.Medium;
  console.log(sizeValue); // 输出: "M"
  
  // 通过值反向查找成员名
  let sizeName: string | undefined = Object.keys(Size).find(key => Size[key as keyof typeof Size] === "L");
  console.log(sizeName); // 输出: "Large"
  

5.2 枚举的应用场景

状态管理：在处理状态时，使用枚举可以清晰地表示不同的状态。

enum LoadingState {
    Idle,
    Loading,
    Success,
    Error
}

function handleLoadingState(state: LoadingState) {
    switch (state) {
        case LoadingState.Idle:
            console.log("当前状态：空闲");
            break;
        case LoadingState.Loading:
            console.log("当前状态：加载中");
            break;
        case LoadingState.Success:
            console.log("当前状态：加载成功");
            break;
        case LoadingState.Error:
            console.log("当前状态：加载失败");
            break;
    }
}

handleLoadingState(LoadingState.Loading); // 输出: "当前状态：加载中"

选项配置：在配置选项时，枚举可以提供一组固定的可选值。

enum Alignment {
    Left,
    Center,
    Right
}

function setAlignment(alignment: Alignment) {
    switch (alignment) {
        case Alignment.Left:
            console.log("文本左对齐");
            break;
        case Alignment.Center:
            console.log("文本居中对齐");
            break;
        case Alignment.Right:
            console.log("文本右对齐");
            break;
    }
}

setAlignment(Alignment.Center); // 输出: "文本居中对齐"

5.3 注意事项

• 枚举成员的值是只读的：一旦定义了枚举成员的值，就不能在运行时修改它。
• 枚举的作用域：枚举成员的作用域是全局的，因此要避免不同枚举中使用相同的成员名。

通过使用枚举类型，你可以使代码更加清晰、易读，并且减少因拼写错误或使用不合法值而导致的错误。