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

旧城等待， 2021-07-24 15:32 539阅读 0赞

当类型被约束后,就拥有了约束类型的所有静态方法
    
    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}