8、鸿蒙/ArkTS数据类型

声明:
ArkTS通过声明引入变量、常量、函数和类型。

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

  let str: string = '张三'
  str = '李四'
  

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

  const name: string = '哈哈'
  console.log('name == ', name);
  

• 自动类型推断（如果一个变量或常量的声明包含了初始值，那么开发者就不需要显式指定其类型）

  let str2: string = '王五'
  let str3 = '赵六' // 声明即赋值自动推断类型
  console.log('str2 == ', str2);
  console.log('str3 == ', str3);
  

Number类型：

• ArkTS提供number和Number类型，任何整数和浮点数都可以被赋给此类型的变量

  let age: number = 20;
  let money: Number = 32.51;
  console.log('age, moeny == ', age, money);
  

Boolean类型：

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

  let isshow: boolean = false
  console.log('isshow == ', isshow);
  

String类型：

• string代表字符序列；可以使用转义字符来表示字符;
• 字符串字面量由单引号（'）或双引号（"）之间括起来的零个或多个字符组成。字符串字面量还有一特殊形式，是用反向单引号（`）括起来的模板字面量。

  let name: string = '哈哈'
  console.log('name == ', name);
  let strstr: string = `result = \n ${str}`;
  console.log('strstr === ', strstr);
  

Void类型：

• void类型用于指定函数没有返回值

  function fun(): void{
    console.log('fun函数被调用!');
  }
  

Object类型：

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

  let obj: object = [1,2,3,4, '王五']
  console.log('obj === ', obj);
  

Array类型：

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

    let array: number[] = [1, 2, 3, 4]
    let array2: Array<string> = ['张三', '李四']
    console.log('array === ', array);
    console.log('array2 == ', array2, array2[1]);
  

Enum类型：

• enum类型，又称枚举类型，是预先定义的一组命名值的值类型，其中命名值又称为枚举常量

    // 定义枚举类型
  enum ColorSet {
    red ='#ff0000',
    yellow = '#ffff00',
    blue = '#0000ff'
  }
  // 获取枚举值
  let c: ColorSet = ColorSet.red
  console.log('c === ', c);
  

Union类型：

• union类型，即联合类型(使用 | 分割)，是由多个类型组合成的引用类型。联合类型包含了变量可能的所有类型

    let unival: string | number | boolean = 123
    unival = '哈哈哈'
    unival = true
    console.log('unival === ', unival);
  

Aliases类型：

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

    // 定义num替代number
    type num = number;
    // 变量定义为num类型
    let numval: num = 789
    console.log('numval == ', numval);
  

赋值运算符：

• 赋值运算符：赋值运算符=，使用方式如x=y

    let str: string = 'abc'
  

• 比较运算符

  
  比较运算符.png

• 算术运算符

  
  算术运算符.png

• 位运算符

  
  位运算符.png

• 逻辑运算符

  
  逻辑运算符.png

• If语句：if语句用于需要根据逻辑条件执行不同语句的场景

   let ishid: boolean = true;
   if(ishid){
     console.log('显示');
   }else{
     console.log('隐藏');
   }
  

• Switch语句：使用switch语句来执行与switch表达式值匹配的代码块

     let num2: number = 10;
     switch (num2) {
       case 1:
         console.log('一');
         break;
       case 2:
         console.log('二');
         break;
       case 3:
         console.log('三');
       break;
       default :
         console.log('未知');
     }
  

• 条件表达式：条件表达式由第一个表达式的布尔值来决定返回其它两个表达式中的哪一个。

     // 格式：condition ? expression1 : expression2
     let num3: number = 2;
     console.log('num3 == ', num3 == 1 ? '一' : '未知');
  

• For语句：for语句会被重复执行，直到循环退出语句值为false

     let sum: number = 0;
     for(let i=0; i<=10; i++){
       sum+= i;
     }
     console.log('sum == ', sum);
  

• For-of语句:使用for-of语句可遍历数组或字符串

   for(let str of 'aabbccdd'){
     console.log('str == ', str);
   }
  

• While语句:只要condition为真值（转换后为true的值），while语句就会执行statements语句

   let num4: number = 0
   while (num4 <= 5){
     console.log('num4 == ', num4);
       num4 = num4+1;
   }
  

• Do-while语句:如果condition的值为真值（转换后为true的值），那么statements语句会重复执行,总会执行一次

    do{
      console.log('num4 == ', num4);
      num4 = num4+1;
    }while (num4 <=5)
  

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

    for(let i=0; i<=10; i++){
      if(i == 5){
        break;
      }
      console.log('i == ', i); // 结果 0 --- 4
    }
  

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

     for(let i=0; i<=10; i++){
      if(i == 5){
        continue;
      }
      console.log('i == ', i); // 结果不包含5
    }
  

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

   function fun2(){
     throw new Error('错误了')
   }
   try{
     fun2();
   }catch (e){
     console.log('fun2函数出错了 ', e);
   } finally {
     console.log('finally释放资源 ');
   }
  

函数：

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

  function add(val1: number, val2: number): number{
     return val1 + val2
  }
  console.log('add === ', add(1, 2));
  // 可选参数 ?
  function fun3(val1: string, val2?: string){
    console.log('val1, val2 == ', val1, val2);
  }
  fun3('h1')
  fun3('h1', 'h2')
  

• Rest参数:函数的最后一个参数可以是rest参数。使用rest参数时，允许函数或方法接受任意数量的实参

  function fun4(...num: number[]): number {
    let result = 0;
    for(let i of num){
      result+=i;
    }
    return result;
  }
  console.log('fun4() == ', fun4());
  console.log('fun4([1, 2, 3, 4, 5]) === ', fun4(1, 2, 3, 4, 5));
  

• 箭头函数

   let fun5 = (val1: number, val2: number): number=>{
      return val1 + val2;
   }
   console.log('fun5 === ', fun5(3, 4));
  

• 函数重载: 可以通过编写重载，指定函数的不同调用方式

  function foo(val: number): void;
  function foo(val: string): void;
  function foo(val: string | number): void {
    console.log('val type', typeof val);
  }
  foo(1);
  foo('abc');
  

类(Class)：

• 类声明引入一个新类型，并定义其字段、方法和构造函数

    class Persion {
      name: string;
      age: number;
  
      constructor(n: string, a: number) {
        this.name = n;
        this.age = a;
      }
      getInfo(): void {
      console.log('Persion name, val === ', this.name, this.age);
     }
  }
  let p = new Persion('zs', 20);
  p.getInfo();
  

接口：

• 接口声明引入新类型。接口是定义代码协定的常见方式

   // 接口
  interface Style {
    getName(): string
  }
  // 接口实现
  class Perison2 implements  Style {
      getName(): string {
        return 'zs'
    }
  }
  let p2 =  new Perison2();
  console.log('getName === ', p2.getName());
  

模块：

• 程序可划分为多组编译单元或模块。每个模块都有其自己的作用域，即，在模块中创建的任何声明（变量、函数、类等）在该模块之外都不可见，除非它们被显式导出。

   import * as ts from '../aaa'  // 换成ts文件也可以
   console.log('ts ==== ', ts.aaa());
    //aaa.ets文件
   export function aaa(): void{
     console.log('aaa === ', 1111);
   }
  

关键字：

• 关键字this只能在类的实例方法中使用
• 不支持this类型
• 不支持在函数和类的静态方法中使用this
• 关键字this的指向:
  • 调用实例方法的对象
  • 正在构造的对象