接口
取接口中的子接口类型
可索引接口
函数类型接口
- 但有时候，type就不适用了。
接口继承 extends
接口实现 implements
- 实现多个接口，这个类需要满足所有接口的属性、方法
构造函数的类型
抽象类 vs 接口
- 都允许扩展
不同点
- type可以而interface不行
interface可以而type不行
- interface 可以多次定义，并能够合并所有重名声明成员
默认导出方式不同

接口一方面在面向对象编程中表示为行为的抽象，也可以用来描述对象的形状。
接口就是把一些类中共有的属性和方法抽象出来，可以用来约束实现次接口的类
一个类可以继承另一个类并实现多个接口
接口像插件一样是用来增强类的，而抽象类是具体类的抽象概念
一个类可以实现多个接口，一个接口也可以被多个类实现，但一个类的可以有多个子类，但只能有一个父类

接口

interface 中可以用分号或者逗号分割每一项，也可以什么都不加。

对象的形状

interface IPerson {    //接口，个人习惯以首字母I开头。当然，也可以随意。
  name:string,
  age:number,
}
// p1对象必须有name、age属性，少属性或者多属性都会报错
let p1:IPerson = {
  name: 'jack',
  age: 10,
}
console.log(p1);  //{name: "jack", age: 10}

也可以直接把接口写进去

let p1:{name:string,age:number} = {
  name: 'jack',
  age: 10,
}

同名接口自动合并

interface IPerson {
  name:string;
  getName():string; //属性值是一个方法的第一种描述方式
}
interface IPerson {
  age:number;
  setAge: (age:number) => void; //属性值是一个方法的第二种描述方式
}
let p:IPerson = {
  name:'jack', 
  age:10,
  getName: function(){
    return this.name;
  },
  setAge: function(age){
    this.age = age;
  }
};
console.log(p); //{name: "jack", age: 10, getName: ƒ, setAge: ƒ}
console.log(p.getName()); //"jack"
p.setAge(20);
console.log(p.age); //20

可选属性 name?:string

interface IAnimal {
  type:string,
  name?:string,    //可选属性
}
let a1:IAnimal = {type: '哺乳动物', name: '猫'};
let a2:IAnimal = {type: '哺乳动物'};
console.log(a1, a2);

任意属性 [key:string]:any

具体可看下面的可索引接口

// 无法预先知道有哪些新的属性的时候，可以使用`[key:string]:any`, key 名字是任意的
interface IPerson {
  readonly id:number;
  name:string;
  [key:string]:any;    //属性名约束：任意字符串：属性值约束：任意类型
}
let p:IPerson = {
  id: 1,
  name: 'jack',
  age: 10,
  home: 'American',
}

只读属性 readonly

用 readonly 定义只读属性，可以避免由于多人协作或者项目较为复杂等因素造成对象的值被重写。

interface IPerson{
  readonly id:number;
  name:string;
}
let p:IPerson = {
  id: 1,
  name: 'jack',
}
p.name = 'lucy';
p.id = 2; //报错，无法为 id 重新赋值，因为它是只读属性

取接口中的子接口类型

接口里的类型，可以通过类名别名的方式拿出来，但是只能用 []，不能用 .

type IArrItem = {name:string, age:number};
interface IPerson {
  arr: IArrItem[],
  address: {
    province: string,
    city: string,
  }
}
type ITest1 = IPerson['address'];
type ITest2 = IPerson['address']['city'];
let t1:ITest1 = {province: '江苏省', city: '苏州市'};
let t2:ITest2 = '苏州市';
console.log(t1, t2);  //{province: "江苏省", city: "苏州市"} "苏州市"

可索引接口

// ILikeArray 约束 key 的类型是 number，值的类型是 string
interface ILikeArray {
  [key:number]:string;
}
// let p1:ILikeArray = { 'name': 'lucy', 'age': '10' }; //报错
let p2:ILikeArray = { 0: 'jack', 1: 'lucy' };
let p3:ILikeArray = ['jack', 'lucy'];  //数组也是类似p2一样的对象，所以匹配约束
// ILikeArray2 约束 key 的类型是 string，值的类型是 string
interface ILikeArray2 {
  [key:string]:string;
}
// let p4:ILikeArray2 = ['jack', 'lucy']; //报错
let p5:ILikeArray2 = { name: 'lucy', age: '10' };

函数类型接口

对方法传入的参数和返回值进行约束

// type ISum = (a:number, b:number) => number;
// 等同于
interface ISum {
  (a:number, b:number):number;  //(约束参数1, 约束参数2):约束函数返回值
}
let sum:ISum = (a, b) => a+b;
console.log(sum(1, 2));    //3

但有时候，type就不适用了。

// 约束一个函数，函数自身有个count属性，用于计数器。
interface ICount {
  ():number;
  count:number;
}
const fn:ICount = (() => {    //函数返回函数，一般要用as标识一下函数的类型，这样子不会报错。
  return ++fn.count;
}) as ICount;
fn.count = 0;
console.log(fn());  //1
console.log(fn());    //2
console.log(fn());    //3

// 约束一个对象，对象有一个 sum 属性是一个函数
interface IObj {
  sum: (a:number, b:number) => number;
}
let obj:IObj = {
  sum: (a, b) => a+b,
}

接口继承 extends

interface IAnimal {
  type:string;
}
interface ICat extends IAnimal {
  name: string;
}
class Cat implements ICat {
  type='哺乳动物';
  name='cat';
}
let cat = new Cat();
console.log(cat); //Cat {type: "哺乳动物", name: "cat"}

接口实现 implements

接口可以被类来实现。接口中的方法都是抽象(没有具体实现)的。

// 类的实例类型
interface Speakable {
  name: string;
  //用接口来形容类的时候，void 表示不关心返回值
  speak(words: string): void,    //描述当前实例上的方法，或者原型上的方法
}
//类本身需要实现接口中的所有属性、方法
class Dog implements Speakable {
  name!: string;
  speak(words:string) {
    console.log(words);
  };
    // 用接口来形容类的时候，void 表示不关心返回值。所以下面这样也可以。
    //speak(words:string):string{return 'abc'};
}
let dog = new Dog();
dog.speak('汪汪汪');  //汪汪汪

实现多个接口，这个类需要满足所有接口的属性、方法

interface ISpeak {
  type:string;
  speak():void;
}
interface IEat {
  eat():void;
}
class Animal implements ISpeak, IEat {
  type='哺乳动物';
  speak(){
    console.log('说话');
  };
  eat(){
    console.log('吃');
  }
}
let ani = new Animal();
console.log(ani.type);  // 哺乳动物
ani.speak();  // 说话
ani.eat();  // 吃

构造函数的类型

在 typescript 中，可以用 interface 来描述类
也可以使用 interface 里特殊的 new() 关键字来描述类构造函数的类型 ```typescript // 加上new之后，就是用来描述类构造函数的类型（约束类）, // 分别是 new实例函数的参数类型：返回值类型 type IPerson1 = new (name:string) => Person;

// 等同于 interface IPerson { new(name:string):Person; //这里返回值的类型“Person” 指 “Person实例的类型” }

// WithClassName 就是构造函数clazz 的约束类型 let instance:Person; function createInstance(clazz:IPerson, name:string){ if (instance) return instance; return new clazz(name); }

class Person{ constructor(public name:string){} }

let p = createInstance(Person, ‘jack’); console.log(p); //Person {name: “jack”}

<a name="Tm3wD"></a>
##### 那如果想传什么类，就返回什么类实例的类型，怎么做？泛型
```typescript
interface IPerson<T> {
  new(name:string):T;
}
// let instance:Person;
function createInstance<T>(clazz:IPerson<T>, name:string){
  // if (instance) return instance;
  return new clazz(name);
}
class Person{
  constructor(public name:string){}
}
let p = createInstance<Person>(Person, 'jack');
console.log(p); //Person {name: "jack"}

抽象类 vs 接口

不同类之间公有的属性或方法，可以抽象成一个接口。
抽象类是供其他类继承的基类，抽象类不允许被实例化。抽象类中的抽象方法必须在子类中实现
抽象类本质是一个无法被实例化的类，其中能够实现方法和初始化属性，而接口仅能够用于描述，既不提供方法的实现，也不为属性进行初始化
一个类只可以继承一个类或抽象类，但可以实现（implements）多个接口
抽象类也可以实现接口 ``typescript // 抽象类：可以部分实现，部分由子类实现 abstract class Animal{ name:string; constructor(name:string){ this.name = name; } eat(fruit:string){ //有具体实现，不需要子类实现 console.log(${this.name} eat ${fruit}`); } abstract speak():void; //没有具体实现，需要子类实现 }

// 接口: 全部没有具体实现，需要子类去实现 interface Flying{ fly():void; } class Duck extends Animal implements Flying{ speak(){ console.log(‘汪汪汪’); } fly(){ console.log(‘我会飞’); } } let duck = new Duck(‘zhufeng’); duck.eat(‘bananer’); //zhufeng eat bananer duck.speak(); //汪汪汪 duck.fly(); //我会飞


<a name="HVwVZ"></a>
# type vs interface
- interface 和 type 很相似，类型定义上，很多时候，用两种方式都能实现。
- 如果不清楚什么时候用interface/type，能用 interface 实现，尽量就用 interface , 如果不能就用 type 。
<a name="0SlnD"></a>
## 相同点
<a name="9Ze1u"></a>
##### 都可以描述一个对象或者函数
```typescript
//描述对象
interface User{
  name:string;
  age:number;
}
//描述函数
interface setUser{
  (name:string, age:number):number;
}

type User = {
  name:string;
  age:number;
}
type setUser = (name:string, age:number) => number;

都允许扩展

扩展（extends）与交叉类型（Intersection Types）。
interface 可以 extends，type 不允许 extends 和 implements 的，但是 type 却可以通过交叉类型实现 interface 的 extends 行为，并且两者并不是相互独立的。
也就是说 interface 可以 extends type，type 也可以与 interface 类型交叉。
虽然效果差不多，但是两者语法不同。

interface extends interface

interface Name{
  name:string;
}
interface User extends Name{
  age:number;
}

interface extends type

type Name = {
  name:string;
}
interface User extends Name{
  age:number;
}

type 与 type 交叉

type Name = {
  name:string;
}
type User = Name & {
  age:number;
}

type 与 interface 交叉

interface Name{
  name:string;
}
type User = Name & {
  age:number;
}

不同点

type可以而interface不行

type可以声明基本类型别名、联合类型、元祖等类型

// 基本类型别名
type Name = string;
// 联合类型
type PartialPointX = {x:number};
type PartialPointY = {y:number};
type PartialPoint = PartialPointX | PartialPointY;
// 元祖类型
type Data = [PartialPointX, PartialPointY];

type语句中还可以使用 typeof 获取实例的类型进行赋值

// 当你想获取一个变量的类型时，使用 typeof
let div = document.createElement('div');
type B = typeof div;

type能使用 in 关键字生成映射类型

type Keys = 'firstname' | 'surname';
type FullName = {
  [key in Keys]:string;
}
let x:FullName = {
  firstname: 'Chaoyang',
  surname: 'Zhu',
}

type Person = {
  name:string;
  age:number;
}
type Full = {
  // 遍历Person类型所有的key
  [key in keyof Person]:string;
}
let x:Full = {
  name: 'jack',
  age: '10',  //ok
  // age: 10, //error
}

其它

type StringOrNumber = string | number;  
type Text = string | { text: string };  
type NameLookup = Dictionary<string, Person>;  
type Callback<T> = (data: T) => void;  
type Pair<T> = [T, T];  
type Coordinates = Pair<number>;  
type Tree<T> = T | { left: Tree<T>, right: Tree<T> };

interface可以而type不行

interface 可以多次定义，并能够合并所有重名声明成员


interface User {
  name: string
  age: number
}
interface User {
  sex: string
}
//合并后，等同于
interface User {
  name: string
  age: number
  sex: string 
}

默认导出方式不同

// inerface 支持同时声明、默认导出
export default interface Config {
  name: string;
}
// type必须先声明后导出
type Config2 = {name: string}
export default Config2