TypeScript 2.8

上面的类型意思是，若T能够赋值给U，那么类型是X，否则为Y。

有条件的类型T extends U ? X : Y或者解析为X，或者解析为Y，再或者延迟解析，因为它可能依赖一个或多个类型变量。 是否直接解析或推迟取决于：

  • 首先，令T'和U'分别为T和U的实例，并将所有类型参数替换为any，如果T'不能赋值给U'，则将有条件的类型解析成Y。直观上讲，如果最宽泛的T的实例不能赋值给最宽泛的U的实例，那么我们就可以断定不存在可以赋值的实例，因此可以解析为Y。
  • 其次，针对每个在U内由推断声明引入的类型变量，依据从T推断到U来收集一组候选类型（使用与泛型函数类型推断相同的推断算法）。对于给定的推断类型变量V，如果有候选类型是从协变的位置上推断出来的，那么V的类型是那些候选类型的联合。反之，如果有候选类型是从逆变的位置上推断出来的，那么V的类型是那些候选类型的交叉类型。否则V的类型是never。
  • 然后，令T''为T的一个实例，所有推断的类型变量用上一步的推断结果替换，如果T''明显可赋值给U，那么将有条件的类型解析为X。除去不考虑类型变量的限制之外，明显可赋值的关系与正常的赋值关系一致。直观上，当一个类型明显可赋值给另一个类型，我们就能够知道它可以赋值给那些类型的所有实例。
  • 否则，这个条件依赖于一个或多个类型变量，有条件的类型解析被推迟进行。

例子

  1. type TypeName<T> =
  2.     T extends string ? "string" :
  3.     T extends number ? "number" :
  4.     T extends boolean ? "boolean" :
  5.     T extends undefined ? "undefined" :
  6.     T extends Function ? "function" :
  7.     "object";
  9. type T0 = TypeName<string>;  // "string"
  10. type T1 = TypeName<"a">;  // "string"
  11. type T2 = TypeName<true>;  // "boolean"
  12. type T3 = TypeName<() => void>;  // "function"
  13. type T4 = TypeName<string[]>;  // "object"

如果有条件类型里待检查的类型是naked type parameter，那么它也被称为“分布式有条件类型”。 分布式有条件类型在实例化时会自动分发成联合类型。 例如，实例化T extends U ? X : Y，T的类型为A | B | C，会被解析为(A extends U ? X : Y) | (B extends U ? X : Y) | (C extends U ? X : Y)。

例子

  1. type T10 = TypeName<string | (() => void)>;  // "string" | "function"
  2. type T12 = TypeName<string | string[] | undefined>;  // "string" | "object" | "undefined"
  3. type T11 = TypeName<string[] | number[]>;  // "object"

在T extends U ? X : Y的实例化里，对T的引用被解析为联合类型的一部分（比如，T指向某一单个部分，在有条件类型分布到联合类型之后）。 此外，在X内对T的引用有一个附加的类型参数约束U（例如，T被当成在X内可赋值给U）。

例子

  1. type BoxedValue<T> = { value: T };
  2. type BoxedArray<T> = { array: T[] };
  3. type Boxed<T> = T extends any[] ? BoxedArray<T[number]> : BoxedValue<T>;
  5. type T20 = Boxed<string>;  // BoxedValue<string>;
  6. type T21 = Boxed<number[]>;  // BoxedArray<number>;
  7. type T22 = Boxed<string | number[]>;  // BoxedValue<string> | BoxedArray<number>;

注意在Boxed<T>的true分支里，T有个额外的约束any[]，因此它适用于T[number]数组元素类型。同时也注意一下有条件类型是如何分布成联合类型的。

有条件类型的分布式的属性可以方便地用来过滤联合类型：

  1. type Diff<T, U> = T extends U ? never : T;  // Remove types from T that are assignable to U
  2. type Filter<T, U> = T extends U ? T : never;  // Remove types from T that are not assignable to U
  4. type T30 = Diff<"a" | "b" | "c" | "d", "a" | "c" | "f">;  // "b" | "d"
  5. type T31 = Filter<"a" | "b" | "c" | "d", "a" | "c" | "f">;  // "a" | "c"
  6. type T32 = Diff<string | number | (() => void), Function>;  // string | number
  7. type T33 = Filter<string | number | (() => void), Function>;  // () => void
  9. type NonNullable<T> = Diff<T, null | undefined>;  // Remove null and undefined from T
  11. type T34 = NonNullable<string | number | undefined>;  // string | number
  12. type T35 = NonNullable<string | string[] | null | undefined>;  // string | string[]
  14. function f1<T>(x: T, y: NonNullable<T>) {
  15.     x = y;  // Ok
  16. }
  18. function f2<T extends string | undefined>(x: T, y: NonNullable<T>) {
  19.     x = y;  // Ok
  20.     y = x;  // Error
  21.     let s1: string = x;  // Error
  22.     let s2: string = y;  // Ok
  23. }

有条件类型与映射类型结合时特别有用：

  1. type FunctionPropertyNames<T> = { [K in keyof T]: T[K] extends Function ? K : never }[keyof T];
  2. type FunctionProperties<T> = Pick<T, FunctionPropertyNames<T>>;
  4. type NonFunctionPropertyNames<T> = { [K in keyof T]: T[K] extends Function ? never : K }[keyof T];
  5. type NonFunctionProperties<T> = Pick<T, NonFunctionPropertyNames<T>>;
  7. interface Part {
  8.     id: number;
  9.     name: string;
  10.     subparts: Part[];
  11.     updatePart(newName: string): void;
  12. }
  14. type T40 = FunctionPropertyNames<Part>;  // "updatePart"
  15. type T41 = NonFunctionPropertyNames<Part>;  // "id" | "name" | "subparts"
  16. type T42 = FunctionProperties<Part>;  // { updatePart(newName: string): void }
  17. type T43 = NonFunctionProperties<Part>;  // { id: number, name: string, subparts: Part[] }

与联合类型和交叉类型相似，有条件类型不允许递归地引用自己。比如下面的错误。

例子

  1. type ElementType<T> = T extends any[] ? ElementType<T[number]> : T;  // Error

有条件类型中的类型推断

现在在有条件类型的extends子语句中，允许出现infer声明，它会引入一个待推断的类型变量。 这个推断的类型变量可以在有条件类型的true分支中被引用。 允许出现多个同类型变量的infer。

例如，下面代码会提取函数类型的返回值类型：

  1. type ReturnType<T> = T extends (...args: any[]) => infer R ? R : any;
  1. type Unpacked<T> =
  2.     T extends (infer U)[] ? U :
  3.     T extends (...args: any[]) => infer U ? U :
  4.     T extends Promise<infer U> ? U :
  5.     T;
  7. type T0 = Unpacked<string>;  // string
  8. type T1 = Unpacked<string[]>;  // string
  9. type T2 = Unpacked<() => string>;  // string
  10. type T3 = Unpacked<Promise<string>>;  // string
  11. type T4 = Unpacked<Promise<string>[]>;  // Promise<string>
  12. type T5 = Unpacked<Unpacked<Promise<string>[]>>;  // string

下面的例子解释了在协变位置上，同一个类型变量的多个候选类型会被推断为联合类型：

相似地，在抗变位置上，同一个类型变量的多个候选类型会被推断为交叉类型：

  1. type Bar<T> = T extends { a: (x: infer U) => void, b: (x: infer U) => void } ? U : never;
  2. type T20 = Bar<{ a: (x: string) => void, b: (x: string) => void }>;  // string
  3. type T21 = Bar<{ a: (x: string) => void, b: (x: number) => void }>;  // string & number

当推断具有多个调用签名（例如函数重载类型）的类型时，用最后的签名（大概是最自由的包含所有情况的签名）进行推断。 无法根据参数类型列表来解析重载。

  1. declare function foo(x: string): number;
  2. declare function foo(x: number): string;
  3. declare function foo(x: string | number): string | number;
  4. type T30 = ReturnType<typeof foo>;  // string | number

无法在正常类型参数的约束子语句中使用infer声明：

  1. type ReturnType<T extends (...args: any[]) => infer R> = R;  // 错误，不支持

但是，可以这样达到同样的效果，在约束里删掉类型变量，用有条件类型替换：

  1. type AnyFunction = (...args: any[]) => any;
  2. type ReturnType<T extends AnyFunction> = T extends (...args: any[]) => infer R ? R : any;

TypeScript 2.8在lib.d.ts里增加了一些预定义的有条件类型：

  • Exclude<T, U> — 从T中剔除可以赋值给U的类型。
  • Extract<T, U> — 提取T中可以赋值给U的类型。
  • NonNullable<T> — 从T中剔除null和undefined。
  • ReturnType<T> — 获取函数返回值类型。
  • InstanceType<T> — 获取构造函数类型的实例类型。

Example

  1. type T00 = Exclude<"a" | "b" | "c" | "d", "a" | "c" | "f">;  // "b" | "d"
  2. type T01 = Extract<"a" | "b" | "c" | "d", "a" | "c" | "f">;  // "a" | "c"
  4. type T02 = Exclude<string | number | (() => void), Function>;  // string | number
  5. type T03 = Extract<string | number | (() => void), Function>;  // () => void
  7. type T04 = NonNullable<string | number | undefined>;  // string | number
  8. type T05 = NonNullable<(() => string) | string[] | null | undefined>;  // (() => string) | string[]
  10. function f1(s: string) {
  11.     return { a: 1, b: s };
  12. }
  13. class C {
  14.     x = 0;
  15.     y = 0;
  16. }
  18. type T10 = ReturnType<() => string>;  // string
  19. type T11 = ReturnType<(s: string) => void>;  // void
  20. type T12 = ReturnType<(<T>() => T)>;  // {}
  21. type T13 = ReturnType<(<T extends U, U extends number[]>() => T)>;  // number[]
  22. type T14 = ReturnType<typeof f1>;  // { a: number, b: string }
  23. type T15 = ReturnType<any>;  // any
  24. type T16 = ReturnType<never>;  // any
  25. type T17 = ReturnType<string>;  // Error
  26. type T18 = ReturnType<Function>;  // Error
  28. type T20 = InstanceType<typeof C>;  // C
  29. type T21 = InstanceType<any>;  // any
  30. type T22 = InstanceType<never>;  // any
  32. type T24 = InstanceType<Function>;  // Error

改进对映射类型修饰符的控制

映射类型支持在属性上添加readonly或?修饰符，但是它们不支持移除修饰符。 这对于同态映射类型有些影响，因为同态映射类型默认保留底层类型的修饰符。

TypeScript 2.8为映射类型增加了增加或移除特定修饰符的能力。 特别地，映射类型里的readonly或?属性修饰符现在可以使用+或-前缀，来表示修饰符是添加还是移除。

例子

  1. type MutableRequired<T> = { -readonly [P in keyof T]-?: T[P] };  // 移除readonly和?
  2. type ReadonlyPartial<T> = { +readonly [P in keyof T]+?: T[P] };  // 添加readonly和?

不带+或-前缀的修饰符与带+前缀的修饰符具有相同的作用。因此上面的ReadonlyPartial<T>类型与下面的一致

  1. type ReadonlyPartial<T> = { readonly [P in keyof T]?: T[P] };  // 添加readonly和?

例子

  1. type Required<T> = { [P in keyof T]-?: T[P] };

注意在--strictNullChecks模式下，当同态映射类型移除了属性底层类型的?修饰符，它同时也移除了那个属性上的undefined类型：

例子

TypeScript 2.8作用于交叉类型的keyof被转换成作用于交叉成员的keyof的联合。 换句话说，keyof (A & B)会被转换成keyof A | keyof B。 这个改动应该能够解决keyof表达式推断不一致的问题。

例子

  1. type A = { a: string };
  2. type B = { b: string };
  4. type T1 = keyof (A & B);  // "a" | "b"
  5. type T2<T> = keyof (T & B);  // keyof T | "b"
  6. type T3<U> = keyof (A & U);  // "a" | keyof U
  7. type T4<T, U> = keyof (T & U);  // keyof T | keyof U
  8. type T5 = T2<A>;  // "a" | "b"
  9. type T6 = T3<B>;  // "a" | "b"
  10. type T7 = T4<A, B>;  // "a" | "b"

更好的处理.js文件中的命名空间模式

TypeScript 2.8加强了识别.js文件里的命名空间模式。 JavaScript顶层的空对象字面量声明，就像函数和类，会被识别成命名空间声明。

  1. var ns = {};     // recognized as a declaration for a namespace `ns`
  2. ns.constant = 1; // recognized as a declaration for var `constant`

顶层的赋值应该有一致的行为；也就是说，var或const声明不是必需的。

  1. app = {}; // does NOT need to be `var app = {}`
  2. app.C = class {
  3. };
  4. app.f = function() {
  5. };
  6. app.prop = 1;

立即执行的函数表达式做为命名空间

立即执行的函数表达式返回一个函数，类或空的对象字面量，也会被识别为命名空间：

  1. var C = (function () {
  2.   function C(n) {
  3.     this.p = n;
  4.   }
  5.   return C;
  6. })();
  7. C.staticProperty = 1;

“默认声明”允许引用了声明的名称的初始化器出现在逻辑或的左边：

  1. my = window.my || {};
  2. my.app = my.app || {};

原型赋值

你可以把一个对象字面量直接赋值给原型属性。独立的原型赋值也可以：

  1. var C = function (p) {
  2.   this.p = p;
  3. };
  4. C.prototype = {
  5.   m() {
  6.     console.log(this.p);
  7.   }
  8. };
  9. C.prototype.q = function(r) {
  10.   return this.p === r;
  11. };

现在嵌套的层次不受限制，并且多文件之间的声明合并也没有问题。以前不是这样的。

  1. var app = window.app || {};
  2. app.C = class { };

TypeScript 2.8增加了使用@jsx dom指令为每个文件设置JSX工厂名。 JSX工厂也可以使用--jsxFactory编译参数设置（默认值为React.createElement）。TypeScript 2.8你可以基于文件进行覆写。

例子

  1. /** @jsx dom */
  2. import { dom } from "./renderer"

生成：

本地范围的JSX命名空间

--emitDeclarationsOnly允许仅生成声明文件；使用这个标记.js/输出会被跳过。当使用其它的转换工具如Babel处理.js输出的时候，可以使用这个标记。