本文关键字：

interface
as
type
public
private
protected
readonly
static
implements

接口定义对象 变量 数组等

interface List {
  readonly id:number; // 只读  属性
  name:string,
  [x:string]:any,   // 用任意的字符串去索引List，可以得到任意的结果
  age?:number,    // 可选属性
}

interface Result {
  data:List[]
}

function render(result: Result){
  result:data.forEach(value => {
    console.log(value.id,value.name)
  })
}

// 后端接口返回
let result = {
  data:[
    {id:2,name:'A',sex:'man'}, // sex:不可控字段 莫名其妙传来
    {id:3,name:'B'}
  ]
}

render(result);

类型断言

// 方式1:
render({
  data:[
    {id:2,name:'A',sex:'man'}, // sex:不可控字段 莫名其妙传来
    {id:3,name:'B'}
  ]
} as Result)

// 方式2:
render(<Result>{
  data:[
    {id:2,name:'A',sex:'man'}, // sex:不可控字段 莫名其妙传来
    {id:3,name:'B'}
  ]
})

不确定一个接口有多少属性的时候，使用可索引接口

• 数字索引

interface StringArray {
  [index: number]: string   // 用任意的数字去索引StringArray 都会得到一个string 声明了一个字符串类型的数组
}

let chars: StringArray = ['A','B'];

• 字符串索引

interface Names {
  [index: string]: string,   // 用任意的字符串去索引Names 都会得到一个string 声明了一个字符串类型的数组
  [z: number]: string,      // 用数字去索引Names  兼容number的类型
  [z: number]: any,        // 用数字去索引Names  兼容number的类型
  // y: number,           // 报错
}

let chars: Names = ['A','B'];

接口定义函数

 // 方式一：
  let add: (x: number, y: number) => number;

  // 方式二：
  interface Add {
    (x: number, y: number) : number
  }

  // 方式三： 类型别名
  type Add = (x: number, y: numner) => number

  // 方式四：
  let add: Add = (a,b) => a+b

  function (x: number, y: number) {
    return x + y;
  }

  // 混合定义接口
  interface Lib {
    (): void;
    version: string;
    doSomething: void;
  }

  // 可选参数必须位于必选参数之后
  function (x: number, y?: number) { 
    return y? x + y : x ;
  }

成员修饰符

class Dog{
  constructor(name: string){
    this.name = name
  }
  public name: string = 'dog'
  private pro(){}
  protected pro(){}
  readonly leg: number = 4  // 只读属性一定要被初始化
  static food: string = 'bones'
}

抽象类 只能被继承 无法实例化

 abstract class Animal{
   eat(){
     console.log('eat')
   }
 }
 class Dog extend Animal{
   constructor(name: string){
     super(name)
     this.name = name
   }
   name: string
   run(){}
 }

类与接口的关系

• 必须实现接口中所有的属性
• 接口只能约束类的公 有成员

• 接口可以相互继承 一个接口可以继承多个接口

  
  

interface Human{
  name: string,
  eat(): void
}

//类与接口继承
class Asiam implements Human {
  constructor(name: string){
    this.name = name
  }
  name: string
  // private name: string   报错
  eat(){}
  sleep(){}
}

//接口继承接口
interface Man extends Human{
  run(): void
}

interface Child{
  cry(): void 
}

//接口继承接口
interface Boy extends Man,Child{}

let boy: Boy = {
  name:'',
  run(),
  eat(),
  cry()
}

class Auto {
  state = 1
}
// 接口继承类
interface AutoInterface extends Auto {

}

// 接口只能约束类的共有成员
class C implements AutoInterface{
  state = 1
}

// Auto的子类 不必实现state属性 继承类state属性   实现AutoInterface接口 
class Bus extends Auto implements AutoInterface{

}