TypeScript 3.4

顶级 this 现在有类型了

顶级 this 的类型现在被分配为 typeof globalThis 而不是 any

因此, 在 noImplicitAny 下访问 this 上的未知值,你可能收到错误提示。

  1. // 在 `noImplicitAny` 下,以前可以,现在不行
  2. this.whargarbl = 10;

请注意,在 noImplicitThis 下编译的代码不会在此处遇到任何更改。

泛型参数的传递

在某些情况下,TypeScript 3.4 的推断改进可能会产生泛型的函数,而不是那些接收并返回其约束的函数(通常是 {})。

  1. declare function compose<T, U, V>(f: (arg: T) => U, g: (arg: U) => V): (arg: T) => V;
  2. function list<T>(x: T) { return [x]; }
  3. function box<T>(value: T) { return { value }; }
  4. let f = compose(list, box);
  5. let x = f(100)
  6. // 在 TypeScript 3.4 中, 'x.value' 的类型为
  7. //
  8. // number[]
  9. //
  10. // 但是在之前的版本中类型为
  11. //
  12. // {}[]
  13. //
  14. // 因此,插入一个 `string` 类型是错误的
  15. x.value.push("hello");

x 上的显式类型注释可以清除这个错误。

上下文返回类型作为上下文参数类型传入

TypeScript 现在使用函数调用时传入的类型(如下例中的 then)作为函数上下文参数类型(如下例中的箭头函数)。

  1. function isEven(prom: Promise<number>): Promise<{ success: boolean }> {
  2. return prom.then<{success: boolean}>((x) => {
  3. return x % 2 === 0 ?
  4. { success: true } :
  5. Promise.resolve({ success: false });
  6. });
  7. }

这通常是一种改进,但在上面的例子中,它导致 truefalse 获取不合需要的字面量类型。

  1. Argument of type '(x: number) => Promise<{ success: false; }> | { success: true; }' is not assignable to parameter of type '(value: number) => { success: false; } | PromiseLike<{ success: false; }>'.
  2. Type 'Promise<{ success: false; }> | { success: true; }' is not assignable to type '{ success: false; } | PromiseLike<{ success: false; }>'.
  3. Type '{ success: true; }' is not assignable to type '{ success: false; } | PromiseLike<{ success: false; }>'.
  4. Type '{ success: true; }' is not assignable to type '{ success: false; }'.
  5. Types of property 'success' are incompatible.

合适的解决方法是将类型参数添加到适当的调用——本例中的 then 方法调用。

  1. function isEven(prom: Promise<number>): Promise<{ success: boolean }> {
  2. // vvvvvvvvvvvvvvvvvv
  3. return prom.then<{success: boolean}>((x) => {
  4. return x % 2 === 0 ?
  5. { success: true } :
  6. Promise.resolve({ success: false });
  7. });
  8. }

strictFunctionTypes 之外一致性推断优先

在 TypeScript 3.3 中,关闭 --strictFunctionTypes 选项时,假定使用 interface 声明的泛型类型在其类型参数方面始终是协变的。对于函数类型,通常无法观察到此行为。

但是,对于带有 keyof 状态的类型参数的泛型 interface 类型——逆变用法——这些类型表现不正确。

在 TypeScript 3.4 中,现在可以在所有情况下正确探测使用 interface 声明的类型的变动。

这导致一个可见的重大变更,只要有类型参数的接口使用了 keyof(包括诸如 Record<K, T> 之类的地方,这是涉及 keyof K 的类型别名)。下例就是这样一个可能的变更。

  1. interface HasX { x: any }
  2. interface HasY { y: any }
  3. declare const source: HasX | HasY;
  4. declare const properties: KeyContainer<HasX>;
  5. interface KeyContainer<T> {
  6. key: keyof T;
  7. }
  8. function readKey<T>(source: T, prop: KeyContainer<T>) {
  9. console.log(source[prop.key])
  10. }
  11. // 这个调用应该被拒绝,因为我们可能会这样做
  12. // 错误地从 'HasY' 中读取 'x'。它现在恰当的提示错误。
  13. readKey(source, properties);

此错误很可能表明原代码存在问题。

参考