• Typescript 2.8
    • 有条件类型
      • 例子
    • 分布式有条件类型
      • 例子
      • 例子
      • 例子
    • 有条件类型中的类型推断
    • 预定义的有条件类型
      • Example
  • 改进对映射类型修饰符的控制
    • 例子
    • 例子
    • 例子
  • 改进交叉类型上的keyof
    • 例子
  • 更好的处理.js文件中的命名空间模式
    • 立即执行的函数表达式做为命名空间
    • 默认声明
    • 原型赋值
    • 嵌套与合并声明
  • 各文件的JSX工厂
    • 例子
  • 本地范围的JSX命名空间
  • 新的—emitDeclarationsOnly

    Typescript 2.8

    有条件类型

    TypeScript 2.8引入了有条件类型,它能够表示非统一的类型。 有条件的类型会以一个条件表达式进行类型关系检测,从而在两种类型中选择其一:

    1. T extends U ? X : Y

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

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

    • 首先,令T'U'分别为TU的实例,并将所有类型参数替换为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";
    8. type T0 = TypeName<string>; // "string"
    9. type T1 = TypeName<"a">; // "string"
    10. type T2 = TypeName<true>; // "boolean"
    11. type T3 = TypeName<() => void>; // "function"
    12. type T4 = TypeName<string[]>; // "object"

    分布式有条件类型

    如果有条件类型里待检查的类型是naked type parameter,那么它也被称为“分布式有条件类型”。 分布式有条件类型在实例化时会自动分发成联合类型。 例如,实例化T extends U ? X : YT的类型为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>;
    4. type T20 = Boxed<string>; // BoxedValue<string>;
    5. type T21 = Boxed<number[]>; // BoxedArray<number>;
    6. 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
    3. type T30 = Diff<"a" | "b" | "c" | "d", "a" | "c" | "f">; // "b" | "d"
    4. type T31 = Filter<"a" | "b" | "c" | "d", "a" | "c" | "f">; // "a" | "c"
    5. type T32 = Diff<string | number | (() => void), Function>; // string | number
    6. type T33 = Filter<string | number | (() => void), Function>; // () => void
    7. type NonNullable<T> = Diff<T, null | undefined>; // Remove null and undefined from T
    8. type T34 = NonNullable<string | number | undefined>; // string | number
    9. type T35 = NonNullable<string | string[] | null | undefined>; // string | string[]
    10. function f1<T>(x: T, y: NonNullable<T>) {
    11. x = y; // Ok
    12. y = x; // Error
    13. }
    14. function f2<T extends string | undefined>(x: T, y: NonNullable<T>) {
    15. x = y; // Ok
    16. y = x; // Error
    17. let s1: string = x; // Error
    18. let s2: string = y; // Ok
    19. }

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

    1. type FunctionPropertyNames<T> = { [K in keyof T]: T[K] extends Function ? K : never }[keyof T];
    2. type FunctionProperties<T> = Pick<T, FunctionPropertyNames<T>>;
    3. type NonFunctionPropertyNames<T> = { [K in keyof T]: T[K] extends Function ? never : K }[keyof T];
    4. type NonFunctionProperties<T> = Pick<T, NonFunctionPropertyNames<T>>;
    5. interface Part {
    6. id: number;
    7. name: string;
    8. subparts: Part[];
    9. updatePart(newName: string): void;
    10. }
    11. type T40 = FunctionPropertyNames<Part>; // "updatePart"
    12. type T41 = NonFunctionPropertyNames<Part>; // "id" | "name" | "subparts"
    13. type T42 = FunctionProperties<Part>; // { updatePart(newName: string): void }
    14. 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;
    6. type T0 = Unpacked<string>; // string
    7. type T1 = Unpacked<string[]>; // string
    8. type T2 = Unpacked<() => string>; // string
    9. type T3 = Unpacked<Promise<string>>; // string
    10. type T4 = Unpacked<Promise<string>[]>; // Promise<string>
    11. type T5 = Unpacked<Unpacked<Promise<string>[]>>; // string

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

    1. type Foo<T> = T extends { a: infer U, b: infer U } ? U : never;
    2. type T10 = Foo<{ a: string, b: string }>; // string
    3. type T11 = Foo<{ a: string, b: number }>; // string | number

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

    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中剔除nullundefined
    • 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"
    3. type T02 = Exclude<string | number | (() => void), Function>; // string | number
    4. type T03 = Extract<string | number | (() => void), Function>; // () => void
    5. type T04 = NonNullable<string | number | undefined>; // string | number
    6. type T05 = NonNullable<(() => string) | string[] | null | undefined>; // (() => string) | string[]
    7. function f1(s: string) {
    8. return { a: 1, b: s };
    9. }
    10. class C {
    11. x = 0;
    12. y = 0;
    13. }
    14. type T10 = ReturnType<() => string>; // string
    15. type T11 = ReturnType<(s: string) => void>; // void
    16. type T12 = ReturnType<(<T>() => T)>; // {}
    17. type T13 = ReturnType<(<T extends U, U extends number[]>() => T)>; // number[]
    18. type T14 = ReturnType<typeof f1>; // { a: number, b: string }
    19. type T15 = ReturnType<any>; // any
    20. type T16 = ReturnType<never>; // any
    21. type T17 = ReturnType<string>; // Error
    22. type T18 = ReturnType<Function>; // Error
    23. type T20 = InstanceType<typeof C>; // C
    24. type T21 = InstanceType<any>; // any
    25. type T22 = InstanceType<never>; // any
    26. type T23 = InstanceType<string>; // Error
    27. type T24 = InstanceType<Function>; // Error
    注意:Exclude类型是建议的Diff类型的一种实现。我们使用Exclude这个名字是为了避免破坏已经定义了Diff的代码,并且我们感觉这个名字能更好地表达类型的语义。我们没有增加Omit<T, K>类型,因为它可以很容易的用Pick<T, Exclude<keyof T, K>>来表示。

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

    映射类型支持在属性上添加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和?

    利用这个特性,lib.d.ts现在有了一个新的Required<T>类型。 它移除了T的所有属性的?修饰符,因此所有属性都是必需的。

    例子

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

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

    例子

    1. type Foo = { a?: string }; // 等同于 { a?: string | undefined }
    2. type Bar = Required<Foo>; // 等同于 { a: string }

    改进交叉类型上的keyof

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

    例子

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

    顶层的赋值应该有一致的行为;也就是说,varconst声明不是必需的。

    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 { };

    各文件的JSX工厂

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

    例子

    1. /** @jsx dom */
    2. import { dom } from "./renderer"
    3. <h></h>

    生成:

    1. var renderer_1 = require("./renderer");
    2. renderer_1.dom("h", null);

    本地范围的JSX命名空间

    JSX类型检查基于JSX命名空间里的定义,比如JSX.Element用于JSX元素的类型,JSX.IntrinsicElements用于内置的元素。 在TypeScript 2.8之前JSX命名空间被视为全局命名空间,并且一个工程只允许存在一个。 TypeScript 2.8开始,JSX命名空间将在jsxNamespace下面查找(比如React),允许在一次编译中存在多个jsx工厂。 为了向后兼容,全局的JSX命名空间被当做回退选项。 使用独立的@jsx指令,每个文件可以有自己的JSX工厂。

    新的—emitDeclarationsOnly

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