TypeScript 中的数据类型

1. 布尔类型（boolean）

   let flag: boolean = true;

2. 数字类型（number）

    let num: number = 6;

3. 字符串类型（string）

   let str: string = "str";

4. 数组类型（array）

   var arr: number[] = [11, 22, 33];
   var arr: Array = [11, 22, 33];
   var arr3: any[] = [‘131214’, 22, true];

5. 元组类型（tuple），属于数组的一种，eg：数组中既可有string、又可有number。缺点是，必须指定的位置对应指定的类型，后面这种情况会用到任意类型 any。

   let arr: [number,string] = [123, 'this is ts'];

6. 枚举类型（enum），eg：以下表示错误码，为了易读性强，单词可以用引号也可以不用，一般不写值，就是下表从0开始，但是如果前一个有值，则从前一个的下表往后默认赋值

   enum Err {'undefined' = -1,'null' = -2,'success' = 1};
   var e:Err = Err.success;
   console.log(e);  // 1

7. 任意类型（any），有时需要为那些在编程阶段还不清楚类型的变量指定一个类型。 这些值可能来自于动态的内容，比如来自用户输入或第三方代码库。 这种情况下，我们不希望类型检查器对这些值进行检查而是直接让它们通过编译阶段的检查。 那么我们可以使用 any类型来标记这些变量。

   let msg: any = "hello"
   
   // 修改msg
   msg = 111
   msg = [1, 2, 3]

8. null、undefined

   // 一个元素可能是 number类型 可能是null 可能是undefined
   var num:number | null | undefined;

9. void类型，typescript中的void表示没有任何类型，一般用于定义方法的时候方法没有返回值。

   // 无返回值
   function run(): void {
        console.log('run')
    }
   run();
   
   // 有返回值
   function run(): number {
       return 123;
   }
   run();
   

    
10. never类型，是所有其他类型 （包括 null 和 undefined）的子类型，表示那些永远不会发生的类型。这意味着声明never的变量只能被never类型所赋值。因此，当 TypeScript 推断出某个表达式的类型为 never 时，通常表示出现了类型错误或不可到达的代码路径。

•  函数的返回类型：如果一个函数永远不会返回（例如抛出异常或进入无限循环），可以将其返回类型标注为 never

  function throwError(message: string): never {
    throw new Error(message);
  }
   
  function infiniteLoop(): never {
    while (true) {
      // 无限循环
    }
  }

•  switch 语句的 exhaustive 检查：当针对某个可枚举类型的变量进行 switch 语句时，使用 never 类型可以确保所有可能的情况都被覆盖，避免遗漏情况。

  type Color = "Red" | "Green" | "Blue";
  function getColorValue(color: Color): number {
    switch (color) {
      case "Red":
        return 1;
      case "Green":
        return 2;
      case "Blue":
        return 3;
      default:
        // 当所有情况都已处理时，这里的值不会被赋值到
        const exhaustiveCheck: never = color; 
        throw new Error(`Unhandled color: ${exhaustiveCheck}`);
    }
  }

  11. 泛型，指广泛的类型，多种类型或者任意类型，是一个类型参数或类型变量。泛型就是在我们定义的时候把不明确的类型，变成一个参数，在我们使用的时候再传递这样的一个类型参数，但又不希望定义为any

      1. 泛型函数

// 利用泛型限定函数的参数和返回值
function test <T>(arg: T): T{
  // ... 此处省略代码 10000 行
  return arg
}
test<number>(111) // 返回值是 number 类型

// 也可以设置多个泛型标识符，用哪个字母无所谓
function test <T, U>(arg1: T, arg2: U): [U, T]{
  // ... 此处省略代码 10000 行
  return [ arg2, arg1 ]
}
test<number, string>(100, 'hello world')

      2. 泛型类

class Animal<T> {
  name: T
  constructor(name: T){
   this.name = name
  }
  action<T>(say: T) {
    console.log(say)
  }
 }
 let cat = new Animal<string>('Cookie')
 cat.action<string>('Hello TypeScript!')

      3. 泛型接口

interface User<T> {
  gender: T
}

const p1: User<string> = {
  gender: '男'
}

const p2: User<boolean> = {
  gender: true
}

      4. 泛型约束，泛型参数T类似于any类型,可以表示任意值。但是有些情况下，函数需要处理的数据有一定的约束，比如有一个泛型函数需要访问泛型参数T的length属性，并加1。基于这种需求，必须对泛型参数T进行约束，也就是泛型约束。

泛型约束语法：T extends 接口或者类

// 泛型约束接口示例代码
 Interface iGeneric{ 
    length:number;
 }
 
// 泛型约束类的示例代码
class GenericAdd<T extends Igeneric>{
    arg:T;
    add(arg:T):boolean{
        this.arg = arg;
        arg.length++;
        return true;    
    }
    getLength(){
        return this.arg.length;
    }
}