typescript 类型约束(:普通约束、接口约束、type约束)

当类型被约束后,就拥有了约束类型的所有静态方法

1、普通类型约束
	let a:string=xx

2、指定类型和属性
	(1)指定对象
		let a:{属性1:string,属性2:string}=x    必须是一个对象,且约束了对象属性
		
		对象中约束函数
		{方法名():返回值}
		
		通过对象字面量对象来赋值,数据结构必须和定义的接口相同
			let xx:{属性1:类型,属性2:类型}={属性1:xx,属性2:xx}

		通过变量来赋值,数据结构可以增加额外的属性
			let x={属性1:xx,属性2:xx}
			let xxx:{属性1:类型}=x;  合法
	
	(2)指定元组
		let tuple:[类型1,类型2,类型3]=[类型1元素,类型2元素,类型3元素]
			
	(3)指定数组
		let arr2:类型[]=[...];  
		let arr2:(类型1|类型2)=[]
		通过元组来指定数组内单个数组元素不同类型
		let x:[类型1,类型2,类型3][]=[[类型1元素,类型2元素,类型3元素],[类型1元素,类型2元素,类型3元素]]
		
	(4)指定类
		class X{...}
		let xx:X=new X();    xx是X类的实例对象或数据结构相同的对象
		let xx:X={和类中键相同且数量相同}
		
	(5)指定函数
		方式一
			function xx(x:类型,y:类型):返回值类型{
				...
			}
			函数表达式:
			const fn= function(x:类型,y:类型):返回值类型{
				...
			}
			箭头函数:
			const fn= (x:类型,y:类型):返回值类型=>{
				...
			}
		方式二
			let xx:(x:类型,y:类型)=>返回值类型=function(x:类型,y:类型):返回值类型{
				...
			}
			
		对象中指定函数
		{方法名():返回类型}


3、type约束
	type可以声明基本类型别名，联合类型，元组等类型
	
		(1)基本使用
			type x={
				age:number;
			}
			type xx=Number
			
		(2)交叉(实现类似接口继承)
			type xxx=x&{sex:string}
			
			可以实现接口和接口的交叉,但是只能赋值给type类型
			type x=接口&接口
			
			当接口和type都&时,如果其中一个是基本类型,则&结果为基本类型,都是基本类型&结果为never,都是对象进行属性的添加
			
		(3)交叉接口
			interface y={
				name:string
			}
			type x1=y&x
			
		(4)使用typeof获取实例的类型进行赋值
			let div = document.createElement('div');
			type B = typeof div
			
			function fun(age: number, name: string) {
			    return {
			      age,
			      name
			    };
			interface IObj {
			    id?: typeof fun; 	typeof后只能接变量，不能直接写内容表达式等
			}
			
	
4、interface约束
	interface可以继承
		
		(1)基本使用
			interface x={
				age:number;
			}
			
		(2)继承
			type xxx=x&{sex:string}
			
		(3)继承type
			type x={
				age:number;
			}
			interface y extends x{
				name:string
			}
		(4)继承类
			class X={
				属性:类型
			}	
			interface xx extends X{
				属性2:类型
			}
			let xxx:xx={属性:值,属性2:值};
			
		(5)声明合并
			interface User {
			 name: string
			 age: number
			}
			 
			interface User {
			 sex: string
			}
			
			User 接口为 {
			 name: string
			 age: number
			 sex: string 
			}
			
5、约束充当函数
	type x=(x1:类型,y1:类型):返回类型
	interface y{
	  	(x1:类型,y1:类型):返回类型
	}
	
6、约束充当数组
	type x=[index:索引类型]:返回类型
	interface y{
	    [index:number索引类型]:类型;   索引为数值,元素为指定类型的数组
	}
	
7、解构赋值约束
	let {x,y}:{x:number,y:number}={x:1,y:2}