一、交叉类性和联合类性

交叉类型：两个类性合并为一个类性

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
}