高级类型

类

1
const <name>=class {
2
    // 成员初始化
3
    <name1> : <type>
4
    <name2> = <value>
5
    // 构造函数
6
    constructor(<name1> : <type>,<name2> : <type>) {
7
        this.<name1>=<name1>
8
        this.<name2>=<name2>
9
    }
10
    //方法
11
    <functionName>(<name>:<type>):<type>{}
12
}

继承父类

1
class <class1>{}
2
class <class2> extends <class1> {}

接口实现

1
class <class> implements <interface>{}

1. 类里面必须提供接口中的所有方法和属性

可见性修饰符

1. 公有的：public​
2. ​pertected​：受保护的，仅对其声明所在类和子类中（非实例对象）可见
3. ​private​：私有的，只在当前类可见

• 在类属性或方法前面添加关键词
• ​public​是默认,可以省略

只读修饰符

​readonly​

• 在类属性前面添加关键词,只能修饰类属性,对象
• 为了防止在构造函数之外的属性进行赋值
• 如果属性有默认值，没有类型注释就会变成自变量类型
• 只能在接口中使用

类型系统

• 结构化类型系统（鸭子类型）

  类型检测关注的是值所具有的形状

• 表明类型系统

  检测的是名称

类型兼容型

• 类

  1
  class a {x:number;y:number}
  2
  class b {x:number;y:number;z:number}
  3
  const c:a = new b()

  在结构化系统中成员多的可以赋值可成员少

• 接口 和类一样

• 函数

  1. 参数个数

     参数少的可以赋值参数多的

     1
     type F1=(a:number,b:number,c:number)=>number
     2
     type F2=(a:number,b:number)=>number
     3
     let f1:F1
     4
     let f2:F2=f1

  2. 参数类型

     相同位置的参数类型要相同(原始类型)或兼容(对象类型)

  3. 返回值类型

     • 如果对象是原始类型,两个类型要相同
     • 如果是对象成员多的可以赋值可成员少

交叉类型

1
interface <interface1>{<name1>:<type>}
2
interface <interface2>{<name2>:<type>}
3
type <interface3> = <interface1> & <interface2>

1. 用 &​ 符号，将多个类型组合为一个
2. 如果两个同名类型冲突，会将同时兼容两种类型

泛型

泛型函数

1
function <functionName><<Type>>(<nmae>:<Type>): <Type> {return <value>}
2
const <name>=<functionName><type>(<value>)

1. 语法：在函数名称后面添加<变量名>​，这个变量名代表指定的类型，在调用时传入
2. 可以利用类型参数推断省略调用时添加类型

泛型约束

1. 指定更加具体的类型

2. 添加约束

   1
   interface <interfaceName> {<name>:<type>}
   2
   function <functionName><<Type> extends <interfaceName>>(<nmae>:<Type>): <Type> {return <value>}

   传入的参数必须具有继承中的属性

3. 可以传入多个属性

   1
   function <functionName><<Type1>,<Type2> extends keyof <Type1>>(<nmae1>:<Type1>,<nmae2>:<Type2>): <Type> {return <value>}

   创建了两个泛型，第二个泛型继承第一个泛型

   ​keyof​ 是获取所有键的联合

泛型接口

1. 在接口名称后添加泛型

泛型类

1. 在class名称后添加泛型，在创建时可以不传入泛型
2. 在构造函数中，明确了类型，使用了泛型，会类型推断明确类型

泛型工具

• Partial

  1
  interface <interfaceName>{
  2
      <name1>:<type>
  3
      <name2>:<type>
  4
  }
  5
  type <name> = Partial<interfaceName>

  构造出来的新类型结构不变，所有属性都变成可选（?​）

• Readonly

  1
  type <name> = Readonly<interfaceName>

  构造出来的新类型结构不变，所有属性都变成只读，除了在创建时能传入

• Pick

  1
  interface <interfaceName>{
  2
      <name1>:<type>
  3
      <name2>:<type>
  4
      <name3>:<type>
  5
  }
  6
  type <name> = Pick<interfaceName,'<name1>' | '<name2>'>

  从传入的类中选出需要的属性，构造新的类型

• Record

  1
  type <typeName> = Record<'name1' | 'name2',<type>>
  2
  let <name>:<typeName> = {
  3
      'name1' // <type>
  4
      'name2' // <type>
  5
  }

  创建一个对象，可以同时创建几个对象指定一个类型

索引签名

1
interface <interfaceName>{
2
    [<name>:<type>]:<name>
3
}

1. js{}​中的键都是string​类型
2. 指定了索引的类型

映射类型

• 根据联合类型

  1
  type <type1> = <type1> | <type2>
  2
  type <type2> = { [<key> in <type1>]:<type> }

• 根据对象类型

  1
  type <obj> = {'name1':<type>;'name2'<type>}
  2
  type <type2> = { [<key> in keyof <obj>]:<type> }