typescript-补充内容(十一)

unknown类型

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

unknown类型的使用

• 任何类型都可以赋值给unknown类型

let str: unknown
str = 18
str = '数字化'
str = [1,2,4]

• 不能将unknown类型赋值给其他类型

let vts: unknown
let nums: number
vts = 18
// 不能将类型“unknown”分配给类型“number”
// nums = vts
// 如果强制需要将unknown赋值给其他类型
// (1).使用类型断言
nums = vts as number
// (2).使用类型缩小
if(typeof vts == "number"){
  nums = vts
}

• unknown与其他任何类型组成的交叉类型最后都是其他类型 & 交叉类型

// 3.unknown与其他任何类型组成的交叉类型最后都是其他类型   & 交叉类型

type myType1 = number & unknown
type myType2 = boolean & unknown
let st: myType1 = 18
let sts:myType2 = true

• unknown除了与any以外，与其他任何类型组成的联合类型都是unknown类型

type MyType1 = unknown | any
type MyType2 = unknown | number
type MyType3 = unknown | string | boolean



let c: MyType1  // any类型
let b: MyType2  // unknown类型
let e: MyType3  // unknown类型

• never类型都是unknown类型的子类型

type MyType6 = never extends unknown? true:false  // type MyType6 = true

map类型

• Map对象保存键值对，并且能够记住键的原始插入顺序
• 任何值(对象或原始值)都可以作为一个键或一个值

创建map

let myMap = new Map()

使用map

• 设置Map对象

myMap.set("李子龙",12)
myMap.set('李小龙',22)
myMap.set('李耀龙',32)

• 获取键对应的值

myMap.get('李子龙') // 12

• 判断map中是否包含键对应的值

myMap.has('李耀龙') // true

• 返回Map对象键/值对的数量

myMap.size 

• 删除键

myMap.delete('李子龙') // true

• 移除map对象的所有键值对

myMap.clear()

• 迭代map中的key

myMap.delete('李子龙') // true

for (let key of myMap.keys()){
  console.log(key) // 李小龙   /n  李耀龙
}

• 迭代map中的value

for (let value of myMap.values()){
  console.log(value) // 22  /n  32
}

• 迭代map中的键值对

for (let entry of myMap.entries()){
  console.log(entry) // ["李小龙",22]  /n ["李耀龙", 32]
}

• 迭代map的键/值

for (let [key,value] of myMap){
  console.log(key,value) // 李小龙  22   /n 李耀龙  32
}

索引类型

• 可以使用一个索引访问类型来查询另一个类型上的特定属性
• 格式: [key]
• 注意点: 不会返回null/undefined/never类型

使用

class Person{
  name: string
  age: number

  constructor(name: string,age: number){
    this.name = name
    this.age = age
  }
}

type MyType = Person['name']
let nu: MyType = '张三'
console.log(nu) // 张三

案例

// 获取指定对象，他的部分属性，将结果放在数组中返回
let obj = {
  name: '李四',
  age: 18,
  set: true
}

function getValues<T, K extends keyof T>(obj: T,keys: K[]): T[K][] {
  let arr = [] as T[K][]

  keys.forEach(key => {arr.push(obj[key])})
  return arr
}

let res = getValues(obj,['name','age'])  

条件类型

基本使用

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

函数重载

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 ""
}

条件类型优化函数重载

interface IName{
  name: string
}

interface IAge{
  age: number
}

type Condition<T> = T extends string? IName : IAge

function reload<T extends number | string>(nameorAge: T): Condition<T>{
  throw ""
}

分布式条件类型

• 当条件类型作用域一个通用类型时，当给定的一个联合类型时，变成分布式
• 通常情况下，分布性是需要的行为，为了避免这种行为，可以使用方括号包围extends关键字的每一边

基础使用

type MyType<T> = T extends any? T : never
type res = MyType<string | number>  // string | number

• 从T中剔除可以赋值给U的类型 Exclude

type resu = Exclude<string | number | boolean, boolean>   // 将boolean类型剔除

• 从中剔除null和undefined NonNullable

type resul = NonNullable<string | number | boolean | null | undefined>

• 获取函数返回值类型 ReturnType

type result = ReturnType<() => string>

• 获取一个类的构造函数组成的元组类型 ConstructorParamters

class Person {
  constructor(name: string,age: number){}
}
type r = ConstructorParameters<typeof Person> // [name: string,age: number]

• 获取函数的参数类型组成的元组类型 Parameters

function show(name: string,age: number,sex: boolean){}

type re = Parameters<typeof show> // [name: string,age: number,sex: boolean] 

infer关键字推断

• 条件类型提供了一种方法来推断，在真实分支中使用infer关键字进行对比的类型
• 可以使用infer关键字编写一些有用的辅助类别名

infer简化操作

type ID = number[]
type IName = string[]

type Unpacked<T> = T extends IName? string : T extends ID? number : T
type nameType = Unpacked<IName>



// 操作  同上
type ElementOf<T> = T extends Array<infer E>? E : T
type res = ElementOf<string[]> // string
type res1 = ElementOf<number[]> // number
type res2 = ElementOf<boolean> // boolean

infer可以推断出联合类型

type Foo<T> = T extends {a: infer U;b: infer U} ? U : never
type res3 = Foo<{a: string;b: number}> // res3 = string | number

映射类型

• 当不想重复定义类型，一个类型可以以另一个类型为基础创建新类型
• Readonly / Partial关键字
• Record / Pick映射类型
• Readonly，Partial和Pick是同态的，但Record不是，因为Record并不需要输入类型来拷贝属性，所以它不属于同态

映射类型—只读

interface IPerson{
  name: string
  age: number
}

// 只读
type ReadonlyTest<T> = {
  // 遍历指定类型所愿地key，并添加到当前类型上
  readonly [P in keyof T]: T[P]
}
type res = ReadonlyTest<IPerson>

映射类型—可选

interface IPerson{
  name: string
  age: number
}

type PartialTest<T> = {
  [P in keyof T]?: T[P]
}
type res1 = PartialTest<IPerson>

映射类型 +/-指定添加或删除

interface IPerson2 {
  readonly name?: string
  readonly age?: number
}

type Test<T> = {
  -readonly [P in keyof T]-?: T[P]
}
type res2 = Test<IPerson2>

映射类型— Readonly/Partial

interface IPerson3 {
  name: string
  age: number
}
type res3 = Readonly<IPerson3>
type res4 = Partial<IPerson3>

映射类型—Record

// 将一个类型的所有属性值都映射到另一个类型上，并创造一个新的类型
type Name = "person" | "animal"
type Person = {
  name: string
  age: number
}
// 注意点: 想要谁作为名称，谁就写在前面
type NewType = Record<Name,Person>
let res: NewType = {
  person: {
    name: '法外狂徒张三',
    age: 22
  },
  animal: {
    name: '小白白',
    age: 3
  }
}

映射类型—Pick

// 将原有类型中的部分内容映射到新类型中

interface IInfo{
  name: string
  age: number
}
type PartProp = Pick<IInfo,"name">
let res1: PartProp = {
  name: '法外狂徒张三'
}

其他公共类型

其他公共类型—Required

// 构建一个由Type的所有属性组成的类型，设置为必填，与Partial相反
interface IPerson{
  name?: string
  age?: number
}
let res: IPerson = {
  name: '法外狂徒张三'
}
let res1: Required<IPerson> = {
  name: '法外狂徒张三',
  age: 22
}

其他公共类型—Omit<Type,Keys>

// 通过从Type中选取所有属性，然后删除Keys(属性名或属性名的联合)来构造一个类型
interface Student{
  name: string
  age: number
  score: number
  sex: boolean
}
type SProps = Omit<Student,"name">
let res2: SProps = {
  age: 18,
  score: 99,
  sex: true
}

其他公共类型—OmitThisParameter

// 从类型T中剔除this参数类型，并构造一个新类型
function add(x: number):void {
  console.log(x)
}
function f0(this: object,x: number){}
function f1(x: number){}

// (x: number) => void
type T0 = OmitThisParameter<typeof f0>
// (x: number) => void
type T1 = OmitThisParameter<typeof f1>
// string
type T2 = OmitThisParameter<string>