TypeScript学习

1 any和unknow

unknow只能作为父属性，unknow不能访问对象的属性和方法

2 在对象中引入任意属性

interface p={
	age:1
	[propName:string]:any
}

3 IArguments类数组

function add(...args:any):void{
	let arr:IArguments=arguments
}

4 通过接口定义数组

interface A{
	[index:number]:number
}

5 函数重载

function fn(name:string,age:number):void
function fn(name:number):void

function fn(name:any,age?:number):void{
}

6 当返回值类型为boolean，而值类型为number时，使用！！将类型进行强制转换

7 联合类型

interface People={}
interface Man={}

const peter=(man:Prople&Man):void=>{}

8 类型断言

（type as string）或<string>type

9 protected和private的区别

protected内部和子类可以访问，private子类不可以访问

10 设置为static的变量使用类名访问，不需要实例化

class Person{
	static age:number=1
}

console(Person.age)

设置为static的方法只能访问设置为static的变量

class Person{
	public name:string='xie'
	static age:number=1
	static show(){
		console(this.age)	
	}
}

11 继承抽象类，抽象方法需要重写

12 函数泛型

为什么要使用函数泛型？

function add(a:number,b:number):Array<number>{}
function add(a:string,b:string):Array<string>{}

这样就很麻烦，需要写两遍

function add<T>(a:T,b:T):Array<T>{}

add<number>(1,2)

一般我们使用extends来实现继承，我们还可以使用extends来约束泛型

interface len{
	name:string
}
//对传入参数进行限制，传入参数必须要有name属性
function add<T extends len>(a:T,b:T):Array<T>{}

另外一种约束泛型的实战用法，当我们需要遍历map对象时，需要代码提示传入键名是否正确

let obj={'a':1,'b':2,'c':3}
function prop<T>(obj:T,key):any{
	return obj[key]
}

prop(obj,'d')	//代码不会提示错误

//需要对输入键名进行约束
function prop<T>(obj:T,key extends keyof T):any{
	return obj[key]
}
//keyof返回T的键名作为联合类型，key值因为这个联合类型的子类型

13 命名空间（避免全局变量的污染）

namespace A{
	export const B=4
}

14 引入ts文件

///<reference path="index.ts"/>

//引入声明文件
///<reference type=""/>

15 为什么要使用声明文件？

有一些库并不是为ts编写的，为了可以使用ts检验数据类型，需要为它们编写声明文件，需要新建一个.d.ts文件

例如：
有一个test.js文件

const num=123
function add(a,b){
	return a+b
}

那么需要配置一个test.d.ts文件

declare const num:number
declare function add<T>(a:T,b:T):T