1其他补充类型

1.1unknown类型

• unknown类型代表任何值。这与any类型类似，但更安全，因为对未知unknown值做任何事情都是不合法的。

• unknown类型被称作安全的any

export default{}
​
//1.任何类型都可以赋值给unknown类型
let str:unknown;
str = 66;
str = "路飞"
str = true;
​
//2.不能将unknown类型赋值给其他类型
let val:unknown = 66;
let num:number;
//num = val; //报错
​
//使用类型断言
num = val as number;
//使用类型缩小
if(typeof val == "number"){
    num = val;
}
​
//3.unknown与其他任何类型组成的交叉类型最后都是其他类型
type MyType1 = number & unknown;
type MyType2 = unknown & boolean;
let a:MyType1 = 66;
let b:MyType2 = true;
​
//4.unknown除了与any以外，与其他任何类型组成的联合类型最后都是unknown类型
type MyType3 = unknown | any;
type MyType4 = unknown | number;
type MyType5 = unknown | string | boolean;
​
//5.never类型是unknown类型的子类型
type MyType6 = never extends unknown ? true : false

1.2map类型

• Map 对象保存键值对，并且能够记住键的原始插入顺序。

• 任何值(对象或者原始值)都可以作为一个键或一个值。

• Map是ES6中引入的一种新的数据结构

• 可以使用for of 进行迭代

创建map

let myMap = new Map()

Map相关的函数与属性:

• map.clear()-移除Map对象的所有键/值对。

• map.set()-设置键值对，返回该Map对象。

• map.get()-返回键对应的值，如果不存在，则返回undefined。

• map.has()-返回一个布尔值，用于判断Map中是否包含键对应的值。

• map.delete()-删除Map 中的元素，删除成功返回true，失败返回false。

• map.size -返回Map对象键/值对的数量。

• map.keys()-返回一个lterator对象，包含了Map对象中每个元素的键。

• map.values()-返回一个新的lterator对象，包含了Map对象中每个元素的值。

export default{}
​
​
//设置MAp对象
let nameMap = new Map();
nameMap.set("艾斯",1);
nameMap.set("路飞",2);
nameMap.set("索隆",3);
​
// 获取键名对应的值
console.log(nameMap.get("艾斯"));
​
// 判断Map中是否包含键对应的值
 console.log(nameMap.has("路飞")); //存在返回true
 console.log(nameMap.has("娜美")); //不存在返回false
​
// 返回Map对象键/值对
 console.log(nameMap.size);
​
// delete删除
 console.log(nameMap.delete("艾斯"));
 console.log(nameMap.delete("娜美"));
​
// 移除Map对象的所有键/值对
 nameMap.clear();
 console.log(nameMap);
​
// 迭代Map中的key
 for (let key of nameMap.keys()) {
     console.log(key);
 }
​
// 迭代Map中的value
 for (let value of nameMap.values()) {
     console.log(value);
 }
​
// 迭代Map中的 key => value
 for (let entry of nameMap.entries()) {
     console.log(entry[0],entry[1]);
}
​
// 使用对象解析
for (let [key,value] of nameMap) {
    console.log(key,value);
}

1.3条件类型

• 条件类型的形式看起来有点像JavaScript中的条件表达式

• T extends U ? TrueType : FalseType

• 应用场景:解决函数重载问题

export default{}
​
​
// 接口
interface IName{
    name:string
}
interface IAge{
    age:number
}
// 条件类型
type Condition<T>=T extends string ? IName : IAge
​
function reLoad<T extends string | number>(idOrName:T):Condition<T>{
    throw ""
}
let res1 = reLoad("杨超越")
let res2 = reLoad(100)

1.4映射类型

• 当你不想重复定义类型，一个类型可以以另一个类型为基础创建新类型。通俗的说就是，以一个类型为基础，根据它推断出新的类型

• Readonly / Partial关键字

• Record / Pick映射类型

• Readonly，Partial和Pick是同态的，但Record不是。因为Record并不需要输入类型来拷贝属性，所以它不属于同态

export default{}
​
​
​
// Record映射类型
// Record的内部定义，接收两个泛型参数；Record后面的泛型就是对象键和值的类型
// 它会将一个类型的所有属性值都映射到另一个类型上并创造一个新的类型
type Name = "person" | "animal";
type Person = {
    name:string
    age:number
}
​
​
type NewType = Record<Name,Person>
let res:NewType = {
    person:{
        name:"阿飞",
        age:18
    },
    animal:{
        name:"蒙奇",
        age:0.5
    }
}
console.log(res);
​
​
// Pick映射类型
// 将原有类型中的部分内容映射到新类型中
interface IPerson{
    name:string
    age:number
}
​
type MyType=Pick<IPerson,"name">
let res2:MyType={
    name:"团子"
}
console.log(res2);