目录 (8)
[Typescript] Type Narrow & CFA
TypeScript 会针对 "string" | "number" 这样的联合类型,通过 CFA(Control Flow Analysis)和用户自定义函数进行 Type Narrow,并把结果展示给开发者。
Control Flow 翻译成中文就是控制流,指的是程序中各个语句、指令或函数被调用执行的顺序。表示控制流的语句会根据某种条件决定是执行还是跳过,从而帮助改变调用顺序或流程,这类语句叫做控制语句。典型的 boolean logic 控制语句有 if、switch、try 等。这和分析纯 JavaScript 代码是一样的。
用户自定义函数是指使用 "is"、"assert"、"infer"、"as" 这类关键字或类型 Generic 的类型或类型函数。它与通过 CFA 决定类型的不同之处在于:TypeScript 的这些关键字在编译后会全部消失。
核心在于:CFA 通过 JavaScript 代码本身也能控制类型,所以会影响运行时;而通过用户自定义函数得到的类型则不会影响运行时。
1. Type Narrow by natural javascript [If 控制语句]
最简单的类型收窄方法是使用 JavaScript 的 If 语句和 JavaScript 的类型运算符。类型运算符大致有 3 种:typeof、in、instanceof。它们分别用于区分 Primitive + built-in Type、Object、Class。根据要区分的变量种类不同,收窄类型的方法也不同。
1.1 Primitive & built-in Type Narrow(typeof 运算符)
Primitive 值有 string、number、boolean、symbol 等。这些类型可以用 typeof 运算符查出变量的类型,再通过 if 语句来收窄类型。像 "object" 这样的 built-in JavaScript 类型也
declare const getUserAge: () => undefined | number;const age = getUserAge(); // undefined | number;if (typeof age === 'undefined') return; // 如果 age 是 undefined 就 return => 从下一行开始它会从 union 类型中被移除。const koreanAge = age + 1; // number;1.2 Object Type Narrow(in 运算符)
当有两个 Object 时,要确认这两个 Object 是否相同,就需要确认它们是否有相同的 Property。在 JavaScript 中要确认这一点,就得直接检查是否拥有对应的 Property Key 值。用于这个功能的运算符就是 in。
// 1. 比较不同对象的 key 值declare const getUserAge: () => {value: number} | {error: Error};const age = getUserAge(); // {value: number} | {error: Error};if ("error" in age) return; // "error" 作为 property 存在时就结束。const koreanAge = age.value + 1; // {value: number}// 2. 比较不同对象的 key & value type。declare const getUserAge: () => | {value: number} | {value: undefined} | {error: Error};const age = getUserAge(); // {value: number} | {value: undefined} | {error: Error};if ("error" in age) return; if (typeof age.value === 'undefined') return; // {value: number} | {value: undefined}const koreanAge = age.value + 1; // {value: number}1.3 Class Type Narrow(instanceof 运算符)
类可以通过继承来扩展。继承别人的类是 SubClass,被继承的类是 SuperClass。用这个 SubClass 创建的对象既是 SubClass 的实例,也可以是 SuperClass 的实例。instanceof 运算符会检查实例的原型链中是否存在与 Class 的原型相同的对象,因此与实例的构造函数类的所有 SuperClass 进行比较时,结果都会是 true。TypeScript 会分析 instanceof 和 if 来执行 Type Narrow。
instanceof 判断标准辅助代码.ts
class User { age: number; constructor(age: number) { this.age = age; }}class MVPUser extends User { money: number; constructor(age: number, money: number) { super(age); this.money = money; }}const commonUser = new User(20);const richUser = new MVPUser(21, 1000);if (richUser instanceof User) { console.log("i am user") // 输出}if (commonUser instanceof User) { console.log("i also user") // 输出}if (commonUser instanceof MVPUser) { console.log("am i rich user?") // X}if (richUser instanceof MVPUser) { console.log("i am rich user") // 输出}if (commonUser instanceof Object) { console.log("i also Object") // 输出}if ('age' in richUser) { console.log("i also object2") // 输出}declare const getNumberOrNumbers: () => number | number[];const value = getNumberOrNumbers(); // number | number[]if (value instanceof Array) { console.log(value .length); // number[]} else { console.log(value .toPrecision(0)) // number}1.4 JavaScript 内置 type-guard 函数
Array 类和 isArray 函数就是内置 type-guard 函数的例子之一。
declare const getNumberOrNumbers: () => number | number[];const myNum = getNumberOrNumbers(); // number | number[] ;if (Array.isArray(myNum)) { console.log(myNum.length); // number[]} else { console.log(myNum.toPrecision(0)) // number}1.5 用比较运算符收窄 Union type
第一个例子是用 if 语句和比较运算符对 literal type 进行 narrow;第二个例子是在共享 name 这个相同 key 的多个 Object 中,利用其 literal 值进行 type narrow。
litral type narrow.ts
declare const getSomething: () => "中文1" | "中文2" | 3;const something = getSomething(); // number | number[] ;switch (something) { case "中文1": console.log(something + "字符串"); // "中文1" break; case "中文2": console.log(something + "字符串2"); // "中文2" break; default: console.log(something + 10); // 3}if (something === 3) { console.log("数字", something) // 3} else { console.log("字符", something + "字符串3") // "中文1" | "中文2"}Discriminated Unions.ts
type Circle = { name: "circle"; radius: number;}type Square = { name: "square"; width: number;}type Diagram = Circle | Squarefunction getArea(diagram:Diagram) { switch(diagram.name) { case "circle": return diagram.radius * diagram.radius * 3.14; // Circle case "square": return diagram.width * diagram.width; // Square default: return 0; }}2. 类型守卫(Type Guards)、类型断言(Assertion)
目录 1 中讲的其实全都是类型守卫。类型守卫就是在可能有多种类型的变量中逐步收窄其类型。
下面要介绍的类型守卫是用户自定义类型守卫,使用 type predicate(类型判别)关键字 "is"。
类型断言(表明)是声明某个值必须是某种类型。代码也应该检查对应的变量,如果不是想要的类型就果断抛出 Error,这样才能稳固地管理类型。可以使用 as 或 assert 指令来进行断言。在使用 ThirdParty 时,经常会因为没有类型定义而不得不使用它。另外,如果类型变得太复杂,我觉得直接用 as 也有助于降低开发成本。
Type Guard(用户自定义)
其实如果使用 instanceof,就算不写 obj is LayoutError,也会通过 CFA 自动推断出来。
declare const getError: () => NetworkError | LayoutError;class NetworkError extends Error { retryCount: number;};class LayoutError extends Error { target: string;};function isLayoutError(obj: Error): obj is LayoutError { return obj instanceof LayoutError;}const error = getError(); // NetworkError | LayoutErrorif (isLayoutError(error)) { console.error(error.target,"这里是布局错误") //LayoutError} else { console.error("重试次数 :", error.retryCount) //NetworkError}令人困惑的 Type Guard
类型守卫本应写成 LayoutError,却写错了,结果类型被换掉了。而且不会出现任何 TS Error,照样能运行。
declare const getError: () => NetworkError | LayoutError;class NetworkError extends Error { retryCount: number;};class LayoutError extends Error { target: string;};function isLayoutError(obj: Error): obj is NetworkError { return obj instanceof LayoutError;}const error = getError(); // NetworkError | LayoutErrorif (isLayoutError(error)) { console.error(error.target,"这里是布局错误") // NetworkError开发者写成了 obj is NetworkError,导致类型推断结果被改变,变成了 NetworkError 类型。} else { console.error("重试次数 :", error.retryCount) // LayoutError}Assertion Function (asserts)
使用 assert 后,在该函数执行之后,类型一定会被自动推断为 assert 的那个类型。因此,我加入了在 JavaScript 检查结果不符合时直接抛出 Error 的代码。没有这段代码也能运行,但就像上面那样,无法保证类型安全。
declare const getError: () => NetworkError | LayoutError;class NetworkError extends Error { retryCount: number;};class LayoutError extends Error { target: string;};function assertLayoutError(obj: Error): asserts obj is LayoutError { if (!(obj instanceof LayoutError)) throw new Error("不是说好一定会传 LayoutError 进来的嘛!!")}const error = getError(); // NetworkError | LayoutErrorassertLayoutError(error); console.log(error.target) // LayoutError;Assertion (as)
// 示例 1 一般的类型断言。interface fruite { name: string; price: number;}var apple = {} as fruite;// 示例 2 MouseEvent 是 Event 的 Subclass。这是 TypeScript 认可的类型断言,所以不会显示错误。(DownCasting)function onClick (event: Event) { let mouseEvent = event as MouseEvent;}// 示例 3 既不是向下转型也不是向上转型,所以直接转换类型会出现 TS Error 信息。必须借助 unknown 绕一下再转换。// 当然,这取决于 tsConfig 的设置interface Message { content : string;}function onReceive(msg: Message) { let messageReceived = event as unkown as string;}as const
as const 的作用是防止 Object 的属性被扩展为 non-literal 的 key-value 类型。简单来说,就是把 Object 变成 literal 版本。
const data1 = { name: "carrot"};const data2 = { name: "carrot"} as const;type Common = typeof data1[keyof typeof data1]; // stringtype Litral = typeof data2[keyof typeof data2]; // "carrot"