typescript常用类型

• 数字类型：不仅支持十进制，也支持二进制，八进制，十六进制

  let num: number = 6;
  let hexLiteral: number = 0xf00d;

• 字符串类型：支持模板字符串

  let nameStr: string = "bob";
  nameStr = `smith`;

• 布尔类型

  let isDone: boolean = false;

• 数组类型

  // 第一种，可以在元素类型后面接上 []，表示由此类型元素组成的一个数组：
  let list: number[] = [1, 2, 3];
  let list: string[] = ['1', '2', '3']
  // 第二种方式是使用数组泛型，Array<元素类型>：
  let list: Array<number> = [1, 2, 3];

• 元组类型：元组类型允许表示一个已知元素数量和类型的数组，各元素的类型不必相同

  let tuple: [number, string] = [1, '2']

• 函数类型

  // 函数没有返回值时类型为void
  function welcome(): void {
      console.log(">>>") 
  }
  // 函数存在返回值，标出返回值类型
  function add(x: number, y: number): number {
      return x + y
  }
  
  // 函数表达式写法
  let add2 = (x: number, y: number): number => {
      return x + y
  }
  
  // 可选参数  (可选参数要放在函数入参的最后面)
  let add3 = (x: number, y: number, z?: number): number => {
      return x + y
  }
  add3(1, 2)
  
  // 默认参数 (默认参数可以不放在函数入参的最后面)
  function add4(x: number, y: number = 100) {
      return x + y
  }
  add4(100) // 200
  function add5(x: number = 100, y: number) {
      return x + y
  }
  add5(undefined, 100) // 200 当X要使用默认值时，传参时可传入undefined

• interface：定义一组具体的对象

  // 定义对象类型 对象中的属性必须和类型定义的时候完全一致
  interface Person {
      readonly name: string, // 只读属性 如果希望某个属性不被改变，可以加上readonly
      age: number,
      job?: 'XXX' // 可选属性
  }
  const p1: Person = {
      name: 'lin',
      age: 18
  }
  // 定义函数类型
  interface ISum {
      (x: number, y: number): number
  }
  let add6: ISum = (num1, num2) => {
      return num1 + num2
  }
  // 自定义属性 用于一个对象上有多个不确定的属性
  interface RandomKey {
      [propName: string]: string
  }
  const obj: RandomKey = {
      a: 'hello',
      b: 'lin',
      c: 'welcome'
  }
  // 如果把属性名定义为 number 类型，就是一个类数组了，看上去和数组一模一样, 不是真的数组，数组上的方法它是没有的
  interface LikeArray {
      [propName: number]: string
  }
  const arr: LikeArray = ['hello', 'lin']
  arr[0]  // 可以使用下标来访问值

• 联合类型: 使用type定义联合类型，不可使用interface（type可以定义具体的对象，也可以给类型生成一个新的别名。）

  type Text = string | number
  let str: Text = '1'
  let num:  Text = 1
  
  type Person = {
    name: string,
    age: number
  };
  type Info = {
    area: string,
    hobby: string   
  };
  type PersonInfo1 = Person & Info; // PersonInfo1类型的变量必须包含Person类型和Info类型的全部值
  type PersonInfo2 = Person | Info; // PersonInfo2 类型的变量需要包含Person类型或者Info类型的全部变量和另一个类型的部分或全部变量

• 泛型：解决输入输出要一致的问题

  // 处理函数参数 泛型的语法是 <> 里写类型参数，一般可以用 T 来表示。
  function loggingIdentity<T>(arg: T): T {
      console.log(arg)
      return arg
  }
  // 泛型约束
  interface Lengthwise  {
      length: number
  }
  function loggingIdentity2<T extends Lengthwise>(arg: T): T {
      console.log(arg)
      return arg
  }
  
  // loggingIdentity2(3) // Error, number doesn't have a .length property
  loggingIdentity({length: 10, value: 3});