TS

• 使用declare 创建第三方库的声明文件，一般第三方库都有官方维护的声明文件，可通过npm 安装，比如@types/jquery

  枚举

  ```typescript enum Direction{ Up, Down, Left, Right } const value = ‘UP’ if(value === Direction.Up){ console.log(‘go up’) } //使用常量枚举可以提升性能 const enum Direction{

}

<a name="Jn7p6"></a>
### type  类型别名/类型断言
```typescript
type PlusType = (x:number,y:number) =>number
function sum(x:number,y:number):number{
  return x+y
}
const sum2:PlusType =sum
type NameResolver = ()=>string
type NameOrResolver = string | NameResolver
function getName(n:NameOrResolver):string{
  if(typeof n === 'string'){
     return n
  }else{
    return n()
  }
}
//类型断言
function getLength(input:string | number):number{
  if((<string>input).length){
    return (<string>input).length
  }else{
    return input.toString().length
  }
}

interface

用来描述类，函数，数组等等；描述类的形状，对类进行抽象，鸭子类型

只读属性，可选属性

interface Person{
  readonly id:number; //只读
  name:string;
  age?:number//可选
}

函数

const add = function(x:number,y:number,z:number=10):number{
  if(typeof z ==='number'){
    return x +y +z
  }
  return x+y+z
}
const add2:(x:number,y:number,z?:number) => number = add

类

• 定义一切事物的抽象特点
• 对象就是类的实例
• 面向对象（封装、继承：（）、多态）

  //ts-node 插件直接运行ts文件
  //readonly
  //static
  //pravite  ：自身
  //protected：自身+ 子类
  //public ：自身 + 实例+ 子类 都可调用
  //implement
  interface Radio {
  switchRadio():void
  }
  interface Battery{
  checkBatteryStatus()
  }
  interface RadioWithBattery extends Radio{
  checkBatteryStatus()
  }
  class Car implements Radio{
  switchRadio(){
  }
  }
  class Cellphone implements RadioWithBattery{
  switchRadio(){
  }
  checkBatteryStatus(){}
  }
  class Cellphone implements Radio,Battery{
  switchRadio(){
  }
  checkBatteryStatus(){}
  }

  联合类型

  //基础联合类型
  let  a:string |number
  a =1
  a="123"
  //对象联合类型
  interface Women{
  age:number;
  sex:string;
  cry():void
  }
  interface Man{
  age:number;
  sex:string
  }
  declare function People():Women|man;
  let p = People();
  p.age = 18
  p.cry() //报错

  交叉类型

  ```typescript interface People{ age:number; height:number } interface Man{ sex:string } const rt = (man:People & Man) =>{

} rt({age:18,heigt:160,sex:’women’})

<a name="AgeiE"></a>
### 泛型 Generics
```typescript
//使用函数、接口或者类的时候才指定类型 (参数返回值)
function echo<T>(arg:T):T{
  return arg
}
const res = echo(123)
function swap<T,U>(tuple:[T,U]):[U,T]{ //tuple元祖
  return [tuple[1],tuple[0]]
}
const res2 = swap(['string',123])
//泛型可以看做占位符，使用的时候动态填入确定的类型值
interface IWithLength{
  length:number
}
function echoWithLength<T extends IWithLength>(arg:T):T{
  console.log(arg.length)
  return arg
}
const str = echoWithLength('334')
const obj = echoWithLength({length:10,width:100})
const arr = echoWithLength([1,2,3])
//类中使用泛型
class Queue<T>{
  private data = [];
  push(item:T){
    return this.data.push(item)
  }
  pop():T{
    return this.data.shift()
  }
}
const q1 = new Queue<number>()
const q2 = new Queue<string>()
interface KeyPair<T,U>{
  key:T;
  value:U
}
let k1:KeyPair<number,string> = {key:123,value:'str'}
let k2:KeyPair<string,number> = {key:'test',value:2}
let arrNew: Array<number> = [1,2,3]
//描述函数
interface IPlus<T>{
  (a:T,b:T):T
}
function plus(a:number,b:number):number{
  return a +b;
}
function connect (a:string,b:string):string{
  return a +b
}
const a:IPlus<number> = plus
const b:IPlus<string> = plus

为什么使用？

• ts是js 的超集，加强版，

promise.cache //promise 缓存 ，，，缓存装饰器

react-window

react-placeholder

• 缓存装饰器