TypeScript 2.4

TypeScript 2.4 版本

动态导入表达式

动态import表达式是 ECMAScript 的一个新功能和一部分，它允许用户在程序中的任意位置异步请求模块。

这意味着你可以有条件和懒惰地导入其他模块和库。例如，以下是一个async只在需要时才导入实用程序库的功能：

async function getZipFile(name: string, files: File[]): Promise<File> {
  const zipUtil = await import('./utils/create-zip-file'
  const zipContents = await zipUtil.getContentAsBlob(files
  return new File(zipContents, name
}

许多捆绑器支持基于这些import表达式自动分割输出捆绑包，因此请考虑在esnext模块目标中使用此新特性。

字符串枚举

TypeScript 2.4 现在允许枚举成员包含字符串初始值设定项。

enum Colors {
  Red = "RED",
  Green = "GREEN",
  Blue = "BLUE",
}

需要注意的是，字符串初始化的枚举不能被反向映射以获得原始的枚举成员名称。换句话说，你不能写信Colors["RED"]来获取字符串"Red"。

泛型的推理改进

TypeScript 2.4 在泛型推断的方式上引入了一些精彩的变化。

返回类型作为推理目标

首先，TypeScript 现在可以针对呼叫的返回类型进行推断。这可以改善您的体验并捕获错误。现在有效的东西：

function arrayMap<T, U>(f: (x: T) => U): (a: T[]) => U[] {
  return a => a.map(f
}

const lengths: (a: string[]) => number[] = arrayMap(s => s.length

作为一个新错误的例子，你可能会发现一个结果：

let x: Promise<string> = new Promise(resolve => {
  resolve(10
  //    ~~ Error!
}

从上下文类型中输入参数推断

在 TypeScript 2.4 之前，在下面的例子中

let f: <T>(x: T) => T = y => y;

y会有这种类型any。这意味着程序将进行类型检查，但是您可以在技术上做任何事情y，例如以下内容：

let f: <T>(x: T) => T = y => y() + y.foo.bar;

最后一个例子实际上不是类型安全的。

在 TypeScript 2.4 中，右侧的函数隐含地获取类型参数，并且y被推断为具有该类型参数的类型。

如果y以类型参数的约束不支持的方式使用，则会正确地得到错误。在这种情况下，约束T是（隐式地）{}，所以最后一个例子会适当地失败。

更严格地检查泛型函数

当比较两个单一签名类型时，TypeScript 现在试图统一类型参数。因此，在涉及两个通用签名时会得到更严格的检查，并且可能会捕获一些错误。

type A = <T, U>(x: T, y: U) => [T, U];
type B = <S>(x: S, y: S) => [S, S];

function f(a: A, b: B) {
  a = b;  // Error
  b = a;  // Ok
}

回调参数的严格反转

TypeScript 一直以双变量的方式比较参数。这有很多原因，但总体而言，这对我们的用户来说并不是一个大问题，除非我们看到它对Promises和Observables的一些不利影响。

当涉及两种回调类型时，TypeScript 2.4 引入了这一点。例如：

interface Mappable<T> {
  map<U>(f: (x: T) => U): Mappable<U>;
}

declare let a: Mappable<number>;
declare let b: Mappable<string | number>;

a = b;
b = a;

在 TypeScript 2.4 之前，这个例子会成功。当关联map类型时，TypeScript会双向关联它们的参数（即类型f）。在将每个参数f相关联时，TypeScript也会双向关联这些参数的类型。

当涉及 TS 2.4 中的map类型时，语言将检查每个参数是否是回调类型，如果是这样，它将确保这些参数以与当前关系相反的方式进行检查。

换句话说，TypeScript 现在捕获了上述错误，这可能是一些用户的重大改变，但在很大程度上会有所帮助。

弱类型检测

TypeScript 2.4 引入了“弱类型”的概念。任何只包含一组全部可选属性的类型被认为是弱的。例如，这种Options类型是一种弱类型：

interface Options {
  data?: string,
  timeout?: number,
  maxRetries?: number,
}

在 TypeScript 2.4 中，当属性没有重叠时，现在将错误类型分配给一个错误。例如：

function sendMessage(options: Options) {
  // ...
}

const opts = {
  payload: "hello world!",
  retryOnFail: true,
}

// Error!
sendMessage(opts
// No overlap between the type of 'opts' and 'Options' itself.
// Maybe we meant to use 'data'/'maxRetries' instead of 'payload'/'retryOnFail'.

您可以将此视为 TypeScript“增强”这些类型的弱保证，以捕获否则会导致沉默的错误。

由于这是一次重大更改，因此您可能需要了解与严格对象字面值检查相同的解决方法：

如果它们真的存在，则声明这些属性。

2. 为弱类型（即[propName: string]: {}）添加索引签名。

3. 使用类型断言（即opts as Options）。