07 其他补充类型

目录

01 unknown 类型

02 Map类型

03 条件类型

05 映射类型

---

01 unknown 类型

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

• unknown 类型会被称作安全的 any

 

export default {}

// 1.任意类型都可以赋值给unknown类型
let str:unknown
str="张三"
str=20
str=false

// 2.不能将unknown类型赋值给其它类型
let val:unknown=18  //unknown
let num:number  //number
// num=val  //不能将类型“unknown”分配给类型“number”

// 使用类型断言
num=val as number ;

// 使用类型缩小
if (typeof val=="number"){
    num=val
}

// 3.unknown与其它任何类型组成的交叉类型最后都是其它类型
type myType1=number & unknown;  //number
type myType2=unknown & boolean;  //boolean
let a:myType1=18
let b:myType2=true

// 4.unknown除了与any以外，与其它任意类型组成的联合类型最后都是unknown类型
type MyType3=unknown| any   //any
type MyType4=unknown | string   //unknown
type MyType5=unknown| number| string    //unknown

// 5.never类型是unknown类型的子类型
type MyType6=never extends unknown?true:false   //true

02 Map类型

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() - 返回一个Iterator对象，包含了Map对象中每个元素的键。

map.values() - 返回-个新的Iterator对象,包含了Map对象中每个元索的值。

export default {}

let nameMap=new Map()

// 设置 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)   //3

// // 删除
// console.log(nameMap.delete("李四")) //true
// console.log(nameMap.delete("赵六")) //false

// // 移除 Map 对象的所有键/值对
// nameMap.clear()
// console.log(nameMap)    //Map{0}

// // 迭代 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)
}

03 条件类型

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

• T extends U ? TrueType : FalseType

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

export default {}

// 1.条件类型
// 条件类型的形式看起来有点像JavaScript中的条件表达式
// T extends U ? TrueType : FalseType

interface IName {
    name: string
}

interface IAge {
    age: number
}

// function reLoad(name: string): IName; 
// function reLoad(age: number): IAge;
// function reLoad(nameorAge: string | number): IName| IAge;
// function reLoad(nameorAge: string | number): IName| IAge {
//     throw ""
// }

// 条件类型
type MyType<T> = T extends string ? string : any
type res = MyType<string>


// 2.应用场最:解决函数重载问题
type Condition<T> = T extends string ? IName : IAge


function reLoad<T extends number | string> (idorName: T): Condition<T> {
    throw ""
}
let res1 = reLoad("王小明")
let res2 = reLoad(100)

05 映射类型

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

• Readonly / Partial 关键字

• Record / Pick 映射类型

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

export default {}

// 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:3
    }
}

console.log(res)

// Pick映射类型
// 将原有类型中的部分内容映射到新类型中
interface IPerson{
    name:string 
    age: number
}
type MyType=Pick<IPerson, "name">
let res2:MyType={
    name:"崔弗"
}
console.log(res2)