一、交叉类性和联合类性
交叉类型：两个类性合并为一个类性
let fm = <T,U>(x:T,y:U):(T & U)=>{
let res = {} as (T & U)
res = Object.assign(x,y)
return res
}
联合类性：存在多个类性可以使用
let a:(number|string) = 1
let a:(number|string) = 'www'
二、类型保护
存在联合类型时，其结果存在多种类型，使用时存在类型问题。
let getRandomNumber = ():(number|string)=> {
let res = Math.random();
return res>0.5?123.123:"abc"
}
let value = getRandomNumber()
if(value.length){//报错
console.log((value).length);//报错
}else{
console.log((value).toFixed());//报错
}
解决方法1
使用as断言。
缺点：冗余代码多
// 类型保护
let getRandomNumber = ():(number|string)=> {
let res = Math.random();
return res>0.5?123.123:"abc"
}
let value = getRandomNumber()
if((value as string).length){
console.log((value as string).length);
}else{
console.log((value as number).toFixed());
}
解决方法2
使用类型保护函数。
返回类型为value + is +类型，返回值为布尔类型，
let getRandomNumber = ():(number|string)=> {
let res = Math.random();
return res>0.5?123.123:"abc"
}
let value = getRandomNumber()
//类型保护函数
function isString(value): value is string{
return typeof value === 'string'
}
if(isString(value)){
console.log((value).length);
}else{
console.log((value).toFixed());
}
解决方法3
使用typeof + value === 'string'进行判断，但是只能判断number、string、boolean、undefine类型，对象类型无法判断。
let getRandomNumber = ():(number|string)=> {
let res = Math.random();
return res>0.5?123.123:"abc"
}
let value = getRandomNumber()
if(typeof value === 'string'){
console.log((value).length);
}else{
console.log((value).toFixed());
}
解决方法4
涉及对象的类型保护
值 + instanceof + 对象
lass Person {
name:string = 'wds'
}
class Animal{
age:number=18
}
let getRandomNumber = ():(Person|Animal)=> {
let res = Math.random();
return res>0.5?new Person():new Animal();
}
let value = getRandomNumber()
if(value instanceof Animal){
console.log(value.age);
}else{
console.log(value.name);
}
三、null和undefined类型以及监测
两种类型可以赋值给任意类型，null和undefined可以相互赋值，但可以通过tsconfig.json中的"strictNullChecks": true, 来限制。
如果开启了strictNullChecks，可以通过联合类型进行相互赋值。
let value1 = undefined;
let value2 = null;
let value3 :(number | null | undefined) = undefined;
value3 = value1
value3 = value2
// value1 = value2
可选参数默认为联合undefined类型
function aaa(x?:number) {
// (number | undefined)
}
去除null和undefined监测
在value后添加！即可
function getString(value:(string | null | undefined)){
value = 'abc'
return ()=>{
return value!.length
}
}
四、类型别名
使用类型赋值到某一变量中，达到替换类型的作用
1、基础类型别名
type MyString = string;
let value:MyString = '123';
value = 1//报错
2、泛型类型别名
type MyType<T>={x:T,y:T};
let value:MyType<number> = {x:1,y:2}
3、使用类型别名作为其中的某一属性的类型
type MyType = {
x: number,
children?:MyType
}
let value : MyType ={
x:123,
children:{
x:2
}
}
4、接口和类型别名相互兼容
type MyType = {
x:number;
}
interface MyInterface{
x:number
}
let value : MyInterface={x:2}
let value1 : MyType={x:2}
value = value1;
value1 = value
5、接口和类型别名的异同点
相同点
- 都可以进行描述方法和属性
type Mytype = {
name :string,
age : number
};
interface MyInterfaced{
name :string,
age : number
};
- 都可以进行扩展也就是继承
type Mytype = {
name :string,
age : number
};
type Mytype2 =Mytype& {
name :string,
age : number
};
interface MyInterfaced{
name :string,
age : number
};
interface MyInterfaced2 extends MyInterfaced{
say():number
};
异同点
- 类型别名可以替代基本类型、联合类型、元组类型而接口却不行
type Mytype = number;
interface MyInterfaced = number//报错
- 类型别名不能进行合并
type Mype = {//报错
name:number
}
type Mype = {//报错
name:number
}
