小白挑战一周上架元服务——ArkTS03 原创

前端森之鸟

发布于 2025-8-15 19:23

浏览

0收藏

前言

我们前面进行了了解元服务和IDE，目前前期准备工作已经差不了。我们可以进行学习代码阶段了。距离实现元服务上架，是一个里程碑式的进展。奥利给~

一、ArkTS是何方神圣？

ArkTS是HarmonyOS官方的应用开发语言，官方的自然是神圣的。ArkTS是一种设计用于构建高性能应用的编程语言。它在继承TypeScript语法的基础上进行了优化，以提供更高的性能和开发效率。
小白挑战一周上架元服务——ArkTS03-鸿蒙开发者社区

除了高性能以外，还提供了声明式UI范式、状态管理支持。
在开发编码阶段提供了静态检查和分析，这个很有用的，在编码的时候可以提示错误，提高代码的健壮性。
支持TypeScript/JavaScript无缝互通，使开发者可以轻松集成TypeScript和JavaScript代码到应用中，充分利用现有代码和库进行ArkTS开发。
并发能力进行了增强。

二、基本知识，是基础的1234吗？还真是

1.声明（变量/常量）

ArtTS使用let关键字声明变量，使用const关键字声明常量；
声明结构： 关键字 变量/常量名 : 数据类型 = 值
小白挑战一周上架元服务——ArkTS03-鸿蒙开发者社区

    // 声明变量
    let height: number = 168;

    // 声明常量
    const MAX_DAYS: number = 365;

2.数据类型

ArkTS的数据类型分为两类：基本类型（数值类型） 和 引用类型。

基本类型（数值类型）: string，number，boolean，null，undefined

    // 字符串类型
    let name: string = '小北';
    
    // 数字类型
    let age: number = 23;
    
    // 布尔类型
    let isSuccess: boolean = true;

    // 空类型（null）,该类型只有一个值null
    let empty: null = null;

    // 未定义（undefined），该类型也只有一个值undefined
    let unde: undefined = undefined;

引用类型 : 接口（interface）、对象（Object）、函数（Function）、数组（Array）、元组（Tuple）、类（Class）

// 接口（interface），可以定义对象的结构，描述对象的属性（特征）和方法（行为），但不进行实现。
interface Person {                 
  name: string;                    
  age: number;
}

// 对象Object，是所有引用类型的基类。任何值都可以赋予Object类型的对象，基本类型会自动装箱，用于表示除基本类型外的类型。                                                 
let o1: Object = '小明';                                                                                             
let o2: Object = [2, 3];                                                                                           
// 对象字面量方式创建，但必须应对与显示声明的接口interface或者类class,且不适合有方法定义的接口和类。       
let xiaoming: Person = {                                                                                           
  name: '小明',                                                                                                      
  age: 23                                                                                                          
};    

//函数Function：是通过函数调用来执行特定任务的代码块。
function hello(name?: string) {
  if (name == undefined) {
    console.info('Hello!');
  } else {
    console.info(`Hello, ${name}!`);
  }
}

// 数组Array是个有序的组合，用于存储一系列的值                    
let array:Array<Number> = [1,2,3,4,6,9,10];     
let persons:string[] = ['小北','向南','东东','西西'];            
    
// 元组（Tuple），是一种特殊的数组，用于表示固定数量和类型的组合。                       
let tuple: [string, number, string] = ['小明', 23,'自由职业'];    

// 类（class）是一种特殊的对象类型，可以使用关键字new创建对象实例；                       
class User {                                                  
  name: string = '小北';                                        
  age: number = 23;                                           
}                                                                                                                         
let xiaoWang: User = new User();

特殊类型：枚举（Enum）、联合类型（Union）、别名（Type Aliases）

// 枚举类型（Enum)，定义一组固定值，比如三原色黄绿蓝  
enum Colors {                   
  Red,                          
  Green,                        
  Blue                          
}                               
let firstColor = Colors.Red;    

// 联合类型（Union），是允许变量的值有多种类型。          
let luckyNum: number | string = 23;   
luckyNum = 'seven';  

// 别名（Type Aliases），给一个类型或表达式起一个别名，方便理解和复用
type Handler = (s: string, no: number) => string;
type NullableObject = Object | null;

3.空安全

空安全，在声明变量不确定初始值时，通常使用联合类型包含null的值。

    let name: string | null = null;                                                                        
    // 空安全机制的三种方式                                                                                          
    // 1.使用if/else进行判空                                                                                     
    if (name != null) {                                                                                    
      console.log('${name}')                                                                               
    }                                                                                                      
    // 2.使用三元运算符                                                                                           
    const res = name ?? "";                                                                                
                                                                                                           
    // 3.使用可选链，访问对象属性时，如果属性是undefined或null，可选链运算符返回undefined。                                              
    let age: string | null = '';                                                                           
    let len: number = age.length;

4.语句

条件语句： if - else
条件表达式：条件？结果1 ：结果2

if (condition1) {
  // 语句1
} else if (condition2) {
  // 语句2
} else {
  // else语句
}                                                                 

let condition ? expression1 : expression2

Switch条件语句

switch (expression) {
  case label1: // 如果label1匹配，则执行
    // ...
    // 语句1
    // ...
    break; // 可省略
  case label2:
  case label3: // 如果label2或label3匹配，则执行
    // ...
    // 语句23
    // ...
    break; // 可省略
  default:
    // 默认语句
}

循环语句：for/for of、while/do while

let sum = 0;
for (let i = 0; i < 10; i += 2) {
  sum += i;
}  

for (let ch of 'a string object') {
  console.info(ch);
}    

let n = 0;
let x = 0;
while (n < 3) {
  n++;
  x += n;
}    

let i = 0;
do {
  i += 1;
} while (i < 10)

三、函数是一元二次方程吗?

函数Function：是通过函数调用来执行特定任务的代码块。

1.函数的声明

结构形式：function关键字 + 函数名 + （参数）+ ： + 返回类型 + { 代码块 }
小白挑战一周上架元服务——ArkTS03-鸿蒙开发者社区

2.函数的参数

参数为空：函数可以没有参数，没有返回值的。
必选参数：必须要传入的参数。
可选参数：参数是可选的，即在调用函数时，可以选择性传入的参数。
默认参数：就是给参数指定了一个默认值，在函数调用时如果未传入该参数，则使用默认值。
剩余参数：允许开发者将函数的多个独立参数收集起来，并打包成一个数组。

  /// 参数为空
  run(): void {
    console.log('跑');
  }

  /// 必选参数
  say(message: string): void {
    console.log('说了${message}');
  }

  /// 可选参数
  eat(food: string, water?: boolean): void {
    if (water) {
      console.log('吃了${food}，喝了水');
    } else {
      console.log('吃了${food}');
    }
  }

  /// 默认参数
  work(days: number = 1): void {
    console.log('工作了{days}天');
  }

  /// 剩余参数
  add(...nums: number[]): number {
    let start = 0;
    for (let value of nums) {
      start += value;
    }
    return start;
  }

3.箭头函数（匿名函数）

匿名函数，顾名思义就是无须显式命名，没有名字，特点就是简洁和及时性，可以使用一个易记住的名称定义来方便复用。
箭头函数，所以最大的特点是要有箭头=>。
可以省略返回类型，由函数体自行推断返回类型。
如果大括号内只有一句代码块，可以省略大括号。
定义在函数内部，即用即走。

    // 匿名函数
    let add = (a: number, b: number): number => {
      return a + b
    };
    add(2, 4);

    // 可以省略返回值
    let less = (max: number, min: number) => {
      return max - min
    };
    less(10, 5);

    // 可以省略大括号和return
    let multiply = (a:number,b:number)=> a * b;
    multiply(3,5);

作用：常用来作为函数的参数、返回值类型、闭包函数。

4.闭包函数

一个函数将另外一个函数当做返回值，且保留了对内部作用域的访问。就是保留了对包含函数内部作用域的访问。

函数内部的函数，保留了函数的作用域。
箭头函数的一种用法。
也就是返回一个函数。

  times(): () => number {
    let cur = 0;
    return () => cur + 1;
  }

5.函数重载

通过编写重载函数，指定函数的不同调用方式。

  foo(a: number, b: number): void {
    let res = a + b;
    console.log('结果${res}')
  };
  foo(a: numer | string): void {
    console.log('结果${a}')
  }