TypeScript 的核心原则之一是对值所具有的结构进行类型检查。我们使用接口（Interfaces）来定义对象的类型。 接口是对象的状态(属性)和行为(方法)的抽象(描述)

接口定义与使用

  • 接口类型的对象

多了或者少了属性是不允许的
可选属性: ?
只读属性: readonly

  • 需求: 创建人的对象, 需要对人的属性进行一定的约束

id是number类型, 必须有, 只读的
name是string类型, 必须有
age是number类型, 必须有
sex是string类型, 可以没有

  1. (() => {
  2.   // 定义人的接口，改接口作为person对象的类型使用，限定该对象中的属性数据
  3.   interface IPerson {
  4.     // id是只读属性
  5.     readonly id: number
  6.     name: string
  7.     age: number
  8.     // sex可以不存在
  9.     sex?: string
  10.   }
  11.   // 定义一个对象，类型为前面定义的接口IPerson
  12.   const person1: IPerson = {
  13.     id: 1,
  14.     name: 'tom',
  15.     age: 20,
  16.     sex: '男'
  17.   }
  18.   console.log(person1)
  19. })()
  20. // 执行结果
  21. // {id: 1, name: "tom", age: 20, sex: "男"}

函数类型

为了使用接口表示函数类型，需要给接口定义一个调用签名 它就像是一个只有参数列表和返回值类型的函数定义，参数列表中的每个参数都需要名字和类型

  1. (() => {
  2.   // 定义一个接口，作为函数的类型使用
  3.   interface SearchFunc {
  4.     (source: string, subString: string): boolean
  5.   }
  6.   // 定义一个函数，类型为前面定义的接口IPerson
  7.   const mySearch: SearchFunc = function (source: string, sub: string): boolean {
  8.     // 在source字符串中查找是否存在sub字符串
  9.     return source.search(sub) > -1
  10.   }
  11.   // 调用函数
  12.   console.log(mySearch('abcd', 'bc'))
  13. })()
  14. // 输出结果
  15. // true

类类型

与 C# 或 Java 里接口的基本作用一样，TypeScript 也能够用它来明确的强制一个类去符合某种契约。 接口中定义的方法，在类中都要实现

类实现接口

  1. (() => {
  2.   // 定义一个接口，作为类的类型使用
  3.   interface IFly {
  4.     // 该方法没有任何的实现（方法中什么都没有）
  5.     fly()
  6.   }
  8.   // 定义一个类，这个类的类型就是上面定义的接口（IFly接口约束了当前这个类）
  9.   class Person implements IFly {
  10.     // 实现接口中的方法
  11.     fly() {
  12.       console.log('起飞了')
  13.     }
  14.   }
  16.   // 实例化对象
  17.   const person = new Person()
  18.   person.fly()
  19. })()
  20. // 输出结果
  21. // 起飞了

一个类可以实现多个接口

  1. (() => {
  2.   // 定义一个接口，作为类的类型使用
  3.   interface IFly {
  4.     // 该方法没有任何的实现（方法中什么都没有）
  5.     fly()
  6.   }
  8. // 定义另一个接口，作为类的类型使用
  9.   interface ISay {
  10.     // 该方法没有任何的实现（方法中什么都没有）
  11.     say()
  12.   }
  14.   // 定义一个类，这个类的类型就是上面定义的接口（IFly接口约束了当前这个类）
  15.   class Person implements IFly, ISay {
  16.     // 实现接口中的方法
  17.     fly() {
  18.       console.log('起飞了')
  19.     }
  21.     say() {
  22.       console.log('说话了')
  23.     }
  24.   }
  26.   // 实例化对象
  27.   const person = new Person()
  28.   person.fly()
  29.   person.say()
  30. })()
  31. // 输出结果
  32. // 起飞了
  33. // 说话了

接口继承接口

和类一样，接口也可以相互继承。 这让我们能够从一个接口里复制成员到另一个接口里，可以更灵活地将接口分割到可重用的模块里。``

  1. (() => {
  2.   // 定义一个接口，作为类的类型使用
  3.   interface IFly {
  4.     // 该方法没有任何的实现（方法中什么都没有）
  5.     fly()
  6.   }
  8.   // 定义另一个接口，作为类的类型使用
  9.   interface ISay {
  10.     // 该方法没有任何的实现（方法中什么都没有）
  11.     say()
  12.   }
  14.   // 定义一个接口，它继承了前面两个接口
  15.   interface IFlyAndISay extends IFly, ISay {
  16.   }
  18.   // 定义一个类，这个类的类型就是上面定义的继承接口
  19.   class Person implements IFlyAndISay {
  20.     // 实现接口中的方法
  21.     fly() {
  22.       console.log('起飞了')
  23.     }
  25.     say() {
  26.       console.log('说话了')
  27.     }
  28.   }
  30.   // 实例化对象
  31.   const person = new Person()
  32.   person.fly()
  33.   person.say()
  34. })()
  35. // 输出结果
  36. // 起飞了
  37. // 说话了