ArkTS（方舟编程语言）

一、ArkTS语法学习

ArkTS是鸿蒙生态的应用开发语言

1、初始ArkTS语言

ArkTS是HarmonyOS优选的主力应用开发语言。ArkTS围绕应用开发在TypeScript（简称TS）生态基础上做了进一步扩展，保持了TS的基本风格，同时通过规范定义强化开发期静态检查和分析，提升程序执行稳定性和性能

2、ArkTS语言介绍

1）基础知识

①声明

• 变量声明
  以关键字let开头的声明引入变量，该变量在程序执行期间可以具有不同的值

  let hi: string = 'hellow';
  hi = 'hello,world';
  

• 常量声明
  以关键字const开头的声明引入只读常量，该常量只能被赋值一次

  const hello: string = 'hellow';
  

  对常量重新赋值会造成编译时错误
• 自动类型推断
  由于ArkTS是一种静态类型语言，所有数据的类型都必须在编译时确定。
  但是如果一个变量或常量的声明包含了初始值，那么开发者就不需要显示指定其类型。
  以下实例中，两条声明语句都是有效的，两个变量都是string类型：
  let hi1: string = ‘hellow’;
  let hi2 = ‘hellow,world’;

②类型

• Number类型
  ArkTS提供number和Number类型，任何整数和浮点数都可以被赋给该类型的变量。
  数字字面量包含数字面量和十进制浮点数字面量
  整数字面量包含以下类型：

  • 由数字序列组成的十进制整数。例如：0、117、-345
  • 以0x或OX开头的十六进制整数，可以含数字（0-9）和字母a-f或A-F。例如0x1123、0x00111、-0xF1A7
  • 以0o（或0O）开头的八进制整数，只能包含数字（0-7）。例如：0o777
  • 以0b（或0B）开头的二进制整数，只能含数字0和1。例如 0b111、0b0011、-0b11

  浮点字面量包含以下：

  • 十进制，可为有符号数（即，前缀为“+”或“-”）
  • 小数点（“.”）
  • 小数部分（由十进制数字字符串表示）
  • 以“e”或“E”开头的指数部分

  let ni = 3.14;
  let n2 = 3.1415926;
  let n3 = .5;
  let n4 = le2;
  

• Boolean类型
  boolean 类型由 true 和 false 两个逻辑值组成

  let isDone: boolean = false;
  if(isDone){
       
       
  	console.log('Done!');
  }
  

• String类型
  string 代表字符序列；可以使用转义字符来表示字符；

  let s1 = 'Hello, world!\n';
  let s2 = 'this is a string';
  let a = 'Success';
  let s3 = `The result is ${
         
         a}`;
  

• Void类型
  void 类型用于指定函数没有返回值
  此类型只有一个值，同样是void。由于void 是引用类型，因此他们可以用于泛型类型参数

  class Class<T> {
       
       
  }
  let instance: Class <void>
  

• Object类型
  Object类型是所有引用类型的基类型。任何值，包括基本类型的值（它们会被自动装箱），都可以直接被赋给Object类型的变量。object类型则用于表示除非基本类型外的类型。

• Array类型
  array，即数组，是由可赋值给数组声明中指定的元素类型的数据组成的对象。

  let names: string[] = ['Alice', 'Bob', 'Carol'];
  

• Enum类型
  enum类型，又称枚举类型，是预先定义的一组命名值的值类型，其中命名值又称为枚举常量。
  使用枚举常量时必须以枚举类型名称为前缀。

  enum ColorSet {
       
        Red, Green, Blue }
  let c: ColorSet = ColorSet.Red;
  

  常量表达式可以用于显式设置枚举常量的值。

  enum ColorSet {
       
        White = 0xFF, Grey = 0x7F, Black = 0x00 }
  let c: ColorSet = ColorSet.Black;
  

• Union类型
  union类型，即联合类型，是由多个类型组合成的引用类型。联合类型包含了变量可能的所有类型

  class Cat {
       
       
    name: string = 'cat';
    // ...
  }
  class Dog {
       
       
    name: string = 'dog';
    // ...
  }
  class Frog {
       
       
    name: string = 'frog';
    // ...
  }
  type Animal = Cat | Dog | Frog | number;
  // Cat、Dog、Frog是一些类型（类或接口）
  
  let animal: Animal = new Cat();
  animal = new Frog();
  animal = 42;
  // 可以将类型为联合类型的变量赋值为任何组成类型的有效值
  

  可以用不同的机制获取联合类型中特定类型的值。

  class Cat {
       
        sleep () {
       
       }; meow () {
       
       } }
  class Dog {
       
        sleep () {
       
       }; bark () {
       
       } }
  class Frog {
       
        sleep () {
       
       }; leap () {
       
       } }
  
  type Animal = Cat | Dog | Frog;
  
  function foo(animal: Animal) {
       
       
    if (animal instanceof Frog) {
       
       
      animal.leap();  // animal在这里是Frog类型
    }
    animal.sleep(); // Animal具有sleep方法
  }
  

• Aliases类型
  Aliases类型为匿名类型（数组、函数、对象字面量或联合类型）提供名称，或为已有类型提供替代名称。

  type Matrix = number[][];
  type Handler = (s: string, no: number) => string;
  type Predicate <T> = (x: T) => boolean;
  type NullableObject = Object | null;
  

③运算符

• 赋值运算符
  赋值运算符 = ， 使用方式 如 x=y
  复合赋值运算符将赋值与运算符组合在一起，其中 x op = y 等于 x = x op y
  复合赋值运算符列举如下：+=、-=、*=、/=、%=、<<=、>>=、>>>=、&=、|=、^=。

• 比较运算符

  运算符	说明
  ===	如果两个操作数严格相等（对于不同类型的操作数认为是不相等的），则返回true。
  !==	如果两个操作数严格不相等（对于不同类型的操作数认为是不相等的），则返回true。
  ==	如果两个操作数相等，则返回true。
  !=	如果两个操作数不相等，则返回true。
  >	如果左操作数大于右操作数，则返回true。
  >=	如果左操作数大于或等于右操作数，则返回true。
  <	如果左操作数小于右操作数，则返回true。
  <=	如果左操作数小于或等于右操作数，则返回true。。

• 算数运算符
  一元运算符： - 、+ 、-- 、++
  二元运算符：

  运算符	说明
  +	加法
  -	减法
  *	乘法
  /	除法
  %	除法后取余

  位运算符：

  运算符	说明
  a&b	按位与：如果两个操作数的对应位都为1，则将这个位设置为1，否则设置为0。
  a|b	按位或：如果两个操作数的相应位中至少有一个为1，则将这个位设置为1，否则设置为0。
  a^b	按位异或：如果两个操作数的对应位不同，则将这个位设置为1，否则设置为0
  ~a	按位非：反转操作数的位。
  a << b	左移：将a的二进制表示向左移b位。
  a >> b	算术右移：将a的二进制表示向右移b位，带符号扩展。
  a >>> b	逻辑右移：将a的二进制表示向右移b位，左边补0。

  逻辑运算符：

  运算符	说明
  a && b	逻辑与
  a || b	逻辑或
  !a	逻辑非

④语句

• if语句

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

  条件表达式可以是任何类型。但是对于boolean以外的类型，会进行隐式类型转换：

  let s1 = 'Hello';
  if (s1) {
       
       
    console.log(s1); // 打印“Hello”
  }
  
  let s2 = 'World';
  if (s2.length != 0) {
       
       
    console.log(s2); // 打印“World”
  }
  

• switch语句

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

• 条件表达式

  let isValid = Math.random() > 0.5 ? true : false;
  let message = isValid ? 'Valid' : 'Failed';
  

• for语句

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

• for-of语句

  for (let ch of 'a string object') {
       
       
    /* process ch */
  }
  

• while语句

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

• do-while语句

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

• Break语句
  使用break语句可以终止循环语句或switch。

  let x = 0;
  while (true) {
       
       
    x++;
    if (x > 5) {
       
       
      break;
    }
  }
  

  如果break语句后带有标识符，则将控制流转移到该标识符所包含的语句块之外。

  let x = 1;
  label: while (true) {
       
       
    switch (x) {
       
       
      case 1:
        // statements
        break label; // 中断while语句
    }
  }
  

• Continue语句
  continue语句会停止当前循环迭代的执行，并将控制传递给下一个迭代。

  let sum = 0;
  for (let x = 0; x < 100; x++) {
       
       
    if (x % 2 == 0) {
       
       
      continue;
    }
    sum += x;
  }
  

• Throw 和 Try语句
  throw语句用于抛出异常或错误：

  throw new Error('this error')
  

  try语句用于捕获和处理异常或错误：

  try {
       
       
    // 可能发生异常的语句块
  } catch (e) {
       
       
    // 异常处理
  }
  

2）函数

①函数声明

函数声明引入一个函数，包含其名称、参数列表、返回类型和函数体。

function add(x:string,y:string) : string{
   
   
	let z : string = `${
     
     x} ${
     
     y}`
	return z