ts 学习

继承 缺省 只读

// 接口继承的格式 特点是 具有父接口的属性类型
interface NameItf {
	name:string;
}
interface AgeItf {
	age:number;
}
interface PersonItf extends NameItf,AgeItf{
	height:number;
}

let p:PersonItf;
p={
	name:'小红',
	age:18,
	height:160
}

同名

// 接口可以同名 特点是合并了(都具有)所有属性类型
interface AItf {
	age:number;
}
interface AItf {
	name:string;
}
let p:AItf;
p={
	age:18,
	name:'小红'
}

缺省

// 属性名? 表示这个属性可以缺省 (定义数据的时候不写也没问题)
interface ATf {
	name:string;
	age?:number;
}
let p:ATf;
p={
	name:'小红'	
}

只读

// readonly属性名  表示这个属性只允许读取 不能修改 修改就报错
interface ATf {
	readonly name:string;
}
let p:ATf;
p={
	name:'小红'	
}

联合交叉类型

// & 优先于 |
let obj:{age:number;}&{name:string}|{age:string;}&{name:number}
obj={
	age:1,
	name:'小红'
}
obj={
	age:'小红',
	name:1
}

类型别名

//interface和type的区别
// 都可以用来自定义类型
// 类型别名支持联合和交叉类型定义
// 类型别名不支持重复定义 接口可以
type StrOrNum = string|number
let str:StrOrNum='1'
str=1

type ObjType = {a:number&2;b:string}
let objs={
	a:2,
	b:'11'
}

promise

interface DataItf{
	a:number;
	b:number;
}
interface ResItf{
	code:number;
	data: DataItf[]; //{a:number;b:number}[];
	msg:string;
}
let p:Promise<ResItf> = new Promise((resolve,reject)=>{
	resolve({
		code:0,
		data:[{a:1,b:2},{a,3,b:23}],
		msg:successs'
	})
})
p.then(res=>{
	if(res.code===0){
		// 逻辑判断
	}
})

ts 函数

// 接口定义函数类型
interface fnIt{
	(n:string):number
}
const fn:fnIt=(n:string)=>{
	return 1	
}
fn('')

// 类型别名定义函数类型

type fnTyp = (n:string)=>void
const fn2:fnTyp = (n:string)=>{}


// 函数作为对象属性出现的时候
interface FnIt{
	(n:string):number
}
interface ObjTtf{
	fn: FnIt
}
const obi:ObjItf={
	fn:(str)=>{
		renturn 1
	}
}
obj.fn('')

const types: Record<string, string> = {
  R: "tab1",
  "888": "tab2",
};