TypeScript条件类型与内置条件类型怎么使用

其他教程   发布日期:2023年08月09日   浏览次数:433

这篇文章主要讲解了“TypeScript条件类型与内置条件类型怎么使用”,文中的讲解内容简单清晰,易于学习与理解,下面请大家跟着小编的思路慢慢深入,一起来研究和学习“TypeScript条件类型与内置条件类型怎么使用”吧!

一、TS中条件类型是什么

TS中的条件类型就是在类型中添加条件分支,以支持更加灵活的泛型,满足更多的使用场景。内置条件类型是TS内部封装好的一些类型处理,使用起来更加便利。

二、条件类型

1.在类型中添加条件分支

代码如下(示例):

  1. namespace a {
  2. interface Fish {
  3. name1: string
  4. }
  5. interface Water {
  6. name2: string
  7. }
  8. interface Bird {
  9. name3: string
  10. }
  11. interface Sky {
  12. name4: string
  13. }
  14. // 1.在类型中添加条件分支,以支持更加灵活的泛型
  15. type Condition<T> = T extends Fish ? Water : Sky;
  16. let con1: Condition<Bird> = { name4: '天空' };
  17. }

2.条件类型的分发

  1. namespace a {
  2. interface Fish {
  3. name1: string
  4. }
  5. interface Water {
  6. name2: string
  7. }
  8. interface Bird {
  9. name3: string
  10. }
  11. interface Sky {
  12. name4: string
  13. }
  14. // 2.条件类型的分发
  15. // 因为是联合类型因此会返回Water和Sky两种类型
  16. let con2: Condition<Fish | Bird> = { name2: '' };
  17. let con3: Condition<Fish | Bird> = { name4: '' };
  18. }

3.分布式的条件分发

  1. namespace b {
  2. interface Fish {
  3. name1: string
  4. }
  5. interface Water {
  6. name2: string
  7. }
  8. interface Bird {
  9. name3: string
  10. }
  11. interface Sky {
  12. name4: string
  13. }
  14. // 分布式的条件分发
  15. // 找出不包含Fish的部分,下面这三种写法都可以
  16. type Condition<T> = [T] extends [Fish] ? Water : Sky;
  17. // type Condition<T> = T[] extends Fish[] ? Water : Sky;
  18. // type Condition<T> = {t: T} extends {t: Fish} ? Water : Sky;
  19. // 条件类型的分发
  20. // 因为是联合类型找到不包含Fish的部分,因此返回的还是Sky
  21. let con2: Condition<Fish | Bird> = { name4: '' };
  22. }

4.更多示例

  1. namespace c {
  2. // 找出T中不包含U的部分
  3. type Diff<T, U> = T extends U ? never : T;
  4. type R1 = Diff<'a' | 'b' | 'c' | 'd', 'a' | 'b' | 'c'>; // R1: 'd'
  5. // 由于U中的'a','b','c'都是T中的子类型,因此R1的类型就是'd'
  6. // 找出T中包含U的部分
  7. type Filter<T, U> = T extends U ? T : never;
  8. type R2 = Filter<'a' | 'b' | 'c' | 'd', 'a' | 'b' | 'c'>; // R2: 'a' | 'b' | 'c'
  9. // 由于U中的'a','b','c'都是T中的子类型,因此R2的类型就是'a' | 'b' | 'c'
  10. }

三、内置条件类型

1.Exclude

从T中排除掉U,和上面的Diff相同

  1. type Exclude<T, U> = T extends U ? never : T;
  2. type R3 = Exclude<'a' | 'b' | 'c' | 'd', 'a' | 'b' | 'c'>; // R3: 'd'

2.Extract

从T中找出包含U的部分,和上面的filter相同

  1. type Extract<T, U> = T extends U ? T : never;
  2. type R4 = Extract<'a' | 'b' | 'c' | 'd', 'a' | 'b' | 'c'>; // R4: 'a' | 'b' | 'c'

3.NonNullable

从T中找出不为null和undefined的参数

  1. type NonNullable<T> = T extends null | undefined ? never : T;
  2. type R5 = NonNullable<'a' | null | undefined | 'd'>; // R5: 'a' | 'd'

4.ReturnType和Parameters

  • infer:推断的意思,是一个关键字

  • ReturnType 获取函数的返回类型

  • Parameters 获取函数参数类型,返回一个元组

  1. namespace d {
  2. // 1.1
  3. // ReturnType 获取函数的返回类型
  4. type ReturnType<T> = T extends (...args: any[]) => infer R ? R : T;
  5. function getUser() {
  6. return {
  7. name: '张三',
  8. age: 10
  9. }
  10. }
  11. // TS可以从参数中推断返回值类型
  12. type ReturnUser = ReturnType<typeof getUser>; // type ReturnUser = {name: string;age: number;}
  13. // 1.2
  14. // Parameters 获取函数参数类型,返回一个元组
  15. type Parameters<T> = T extends (...args: infer P) => any ? P : never;
  16. function getPerson(a: string, b: number) {
  17. return {
  18. name: '李四',
  19. age: 18
  20. }
  21. }
  22. type ParamsType = Parameters<typeof getPerson>; // type ParamsType = [a: string, b: number]
  23. }

5.InstanceType和ConstructorParameters

  • InstanceType 获取构造函数的实例类型

  • ConstructorParameters 获取类的构造函数的参数类型

  1. namespace e {
  2. class Person {
  3. name: string;
  4. constructor(name: string) {
  5. this.name = name;
  6. }
  7. getName() {
  8. console.log(this.name);
  9. }
  10. }
  11. // ConstructorParameters 获取类的构造函数的参数类型
  12. type ConstructorParameters<T extends abstract new (...args: any) => any> = T extends abstract new (
  13. ...args: infer P) => any ? P : never;
  14. type Params = ConstructorParameters<typeof Person> // type Params = [name: string]
  15. // InstanceType 获取构造函数的实例类型
  16. type Instance = InstanceType<typeof Person>;
  17. let instance: Instance = {
  18. name: '张三',
  19. getName() {}
  20. }
  21. }

四、拓展infer的使用

示例如下:

1.tuple转union

元组转为联合类型

  1. type ElementOf<T> = T extends Array<infer P> ? P : never;
  2. type Tuple = [string, number];
  3. type TupleToUnion = ElementOf<Tuple>; // type TupleToUnion = string | number

2.联合类型转成交叉类型

string | number =》string & number

  1. type T1 = { name: string };
  2. type T2 = { age: number };
  3. type ToIntersection<T> = T extends { a: (x: infer U) => void, b: (x: infer U) => void } ? U : never;
  4. // 由于U需要同时满足T1的定义、T2的定义,因此U需要包含T1、T2所有的类型,因此T3就是T1 & T2
  5. type T3 = ToIntersection<{ a: (x: T1) => void, b: (x: T2) => void }>; // type T3 = T1 & T2

以上就是TypeScript条件类型与内置条件类型怎么使用的详细内容,更多关于TypeScript条件类型与内置条件类型怎么使用的资料请关注九品源码其它相关文章!