TypeScript 2.1

keyof和查找类型

在JavaScript中属性名称作为参数的API是相当普遍的，但是到目前为止还没有表达在那些API中出现的类型关系。

输入索引类型查询或keyof，索引类型查询keyof T产生的类型是T的属性名称。keyof T的类型被认为是string的子类型。

示例

  1. interface Person {
  2.     name: string;
  3.     age: number;
  4.     location: string;
  5. }
  7. type K1 = keyof Person; // "name" | "age" | "location"
  8. type K2 = keyof Person[];  // "length" | "push" | "pop" | "concat" | ...
  9. type K3 = keyof { [x: string]: Person };  // string

与之相对应的是索引访问类型，也称为查找类型。在语法上，它们看起来像元素访问，但是写成类型：

示例

  1. type P1 = Person["name"];  // string
  2. type P2 = Person["name" | "age"];  // string | number
  3. type P3 = string["charAt"];  // (pos: number) => string
  4. type P4 = string[]["push"];  // (...items: string[]) => number
  5. type P5 = string[][0];  // string

你可以将这种模式和类型系统的其它部分一起使用，以获取类型安全的查找。

  1. function getProperty<T, K extends keyof T>(obj: T, key: K) {
  2.     return obj[key];  // 推断类型是T[K]
  3. }
  5. function setProperty<T, K extends keyof T>(obj: T, key: K, value: T[K]) {
  6.     obj[key] = value;
  7. }
  9. let x = { foo: 10, bar: "hello!" };
  11. let foo = getProperty(x, "foo"); // number
  12. let bar = getProperty(x, "bar"); // string
  14. let oops = getProperty(x, "wargarbl"); // 错误！"wargarbl"不存在"foo" | "bar"中
  16. setProperty(x, "foo", "string"); // 错误！, 类型是number而非string

映射类型

一个常见的任务是使用现有类型并使其每个属性完全可选。假设我们有一个Person：

  1. interface Person {
  2.     name: string;
  3.     age: number;
  4.     location: string;
  5. }

Person的可选属性类型将是这样：

  1. interface PartialPerson {
  2.     name?: string;
  3.     age?: number;
  4.     location?: string;
  5. }

使用映射类型，PartialPerson可以写成是Person类型的广义变换：

  1. type Partial<T> = {
  2.     [P in keyof T]?: T[P];
  3. };
  5. type PartialPerson = Partial<Person>;

映射类型是通过使用字面量类型的集合而生成的，并为新对象类型计算一组属性。它们就像Python中的列表推导式，但不是在列表中产生新的元素，而是在类型中产生新的属性。

除Partial外，映射类型可以表示许多有用的类型转换：

  1. // 保持类型相同，但每个属性是只读的。
  2. type Readonly<T> = {
  3.     readonly [P in keyof T]: T[P];
  4. };
  6. // 相同的属性名称，但使值是一个Promise，而不是一个具体的值
  7. type Deferred<T> = {
  8.     [P in keyof T]: Promise<T[P]>;
  9. };
  11. // 为T的属性添加代理
  12. type Proxify<T> = {
  13.     [P in keyof T]: { get(): T[P]; set(v: T[P]): void }
  14. };

Partial,Readonly,Record和Pick

Partial和Readonly，如前所述，是非常有用的结构。你可以使用它们来描述像一些常见的JS程序：

  1. function assign<T>(obj: T, props: Partial<T>): void;
  2. function freeze<T>(obj: T): Readonly<T>;

因此，它们现在默认包含在标准库中。

我们还包括两个其他实用程序类型：Record和Pick。

  1. // 从T中选取一组属性K
  2. declare function pick<T, K extends keyof T>(obj: T, ...keys: K[]): Pick<T, K>;
  4. const nameAndAgeOnly = pick(person, "name", "age");  // { name: string, age: number }
  1. // 对于类型T的每个属性K，将其转换为U
  2. function mapObject<K extends string | number, T, U>(obj: Record<K, T>, f: (x: T) => U): Record<K, U>
  4. const names = { foo: "hello", bar: "world", baz: "bye" };
  5. const lengths = mapObject(names, s => s.length);  // { foo: number, bar: number, baz: number }

对象扩展运算符和rest运算符

TypeScript 2.1带来了ESnext扩展运算符和rest运算符的支持。

类似于数组扩展，展开对象可以方便得到浅拷贝：

  1. let copy = { ...original };

同样，您可以合并几个不同的对象。在以下示例中，合并将具有来自foo，bar和baz的属性。

  1. let merged = { ...foo, ...bar, ...baz };

还可以重写现有属性并添加新属性.：

  1. let obj = { x: 1, y: "string" };
  2. var newObj = {...obj, z: 3, y: 4}; // { x: number, y: number, z: number }

指定展开操作的顺序确定哪些属性在最终的结果对象中。相同的属性，后面的属性会“覆盖”前面的属性。

与对象扩展运算符相对的是对象rest运算符，因为它可以提取解构元素中剩余的元素：

  1. let obj = { x: 1, y: 1, z: 1 };
  2. let { z, ...obj1 } = obj;
  3. obj1; // {x: number, y: number};

低版本异步函数

该特性在TypeScript 2.1之前就已经支持了，但是只能编译为ES6或者ES2015。TypeScript 2.1使其该特性可以在ES3和ES5运行时上使用，这意味着无论您使用什么环境，都可以使用它。

注：首先，我们需要确保我们的运行时提供全局的ECMAScript兼容性Promise。这可能需要获取Promise的polyfill，或者依赖运行时的版本。我们还需要通过设置lib编译参数，比如"dom","es2015"或"dom","es2015.promise","es5"来确保TypeScript知道Promise可用。

示例

tsconfig.json
  1. {
  2.     "compilerOptions": {
  3.         "lib": ["dom", "es2015.promise", "es5"]
  4.     }
  5. }
dramaticWelcome.ts
  1. function delay(milliseconds: number) {
  2.     return new Promise<void>(resolve => {
  3.         setTimeout(resolve, milliseconds);
  4.     });
  5. }
  7. async function dramaticWelcome() {
  8.     console.log("Hello");
  10.     for (let i = 0; i < 3; i++) {
  11.         await delay(500);
  12.         console.log(".");
  13.     }
  15.     console.log("World!");
  16. }
  18. dramaticWelcome();

编译和运行输出应该会在ES3/ES5引擎上产生正确的行为。

支持外部辅助库（tslib）

TypeScript注入了一些辅助函数，如继承_extends、JSX中的展开运算符assign和异步函数awaiter。

以前有两个选择：

  • 在每一个需要辅助库的文件都注入辅助库或者
  • 使用—noEmitHelpers编译参数完全不使用辅助库。这两项还有待改进。将帮助文件捆绑在每个文件中对于试图保持其包尺寸小的客户而言是一个痛点。不使用辅助库，那么客户就必须自己维护辅助库。

TypeScript 2.1 允许这些辅助库作为单独的模块一次性添加到项目中，并且编译器根据需求导入它们。

首先，安装tslib：

  1. npm install tslib

然后，使用—importHelpers编译你的文件：

  1. tsc --module commonjs --importHelpers a.ts

因此下面的输入，生成的.js文件将包含tslib的导入和使用__assign辅助函数替代内联操作。

  1. export const o = { a: 1, name: "o" };
  2. export const copy = { ...o };
  1. "use strict";
  2. var tslib_1 = require("tslib");
  3. exports.o = { a: 1, name: "o" };
  4. exports.copy = tslib_1.__assign({}, exports.o);

无类型导入

TypeScript历来对于如何导入模块过于严格。这是为了避免输入错误，并防止用户错误地使用模块。

但是，很多时候你可能只想导入的现有模块，但是这些模块可能没有.d.ts文件。以前这是错误的。从TypeScript 2.1开始，这更容易了。

使用TypeScript 2.1，您可以导入JavaScript模块，而不需要类型声明。如果类型声明（如declare module "foo" { … }或node_modules/@types/foo）存在，则仍然优先。

对于没有声明文件的模块的导入，在使用了—noImplicitAny编译参数后仍将被标记为错误。

  1. // Succeeds if `node_modules/asdf/index.js` exists
  2. import { x } from "asdf";

支持—target ES2016,—target ES2017和—target ESNext

TypeScript 2.1支持三个新的编译版本值—target ES2016,—target ES2017和—target ESNext。

使用target—target ES2016将指示编译器不要编译ES2016特有的特性，比如**操作符。

同样，—target ES2017将指示编译器不要编译ES2017特有的特性像async/await。

—target ESNext则对应最新的ES提议特性支持.

改进any类型推断

以前，如果TypeScript无法确定变量的类型，它将选择any类型。

  1. let x;      // 隐式 'any'
  2. let y = []; // 隐式 'any[]'
  4. let z: any; // 显式 'any'.

使用TypeScript 2.1，TypeScript不是仅仅选择any类型，而是基于你后面的赋值来推断类型。

仅当设置了—noImplicitAny编译参数时，才会启用此选项。

示例

  1. let x;
  3. // 你仍然可以给'x'赋值任何你需要的任何值。
  4. x = () => 42;
  6. // 在刚赋值后，TypeScript 2.1 知道'x'的类型是'() => number'。
  7. let y = x();
  9. // 感谢，现在它会告诉你，你不能添加一个数字到一个函数！
  10. console.log(x + y);
  11. //          ~~~~~
  12. // 错误！运算符 '+' 不能应用于类型`() => number`和'number'。
  14. // TypeScript仍然允许你给'x'赋值你需要的任何值。
  15. x = "Hello world!";
  17. // 并且现在它也知道'x'是'string'类型的！
  18. x.toLowerCase();

现在对空数组也进行同样的跟踪。

没有类型注解并且初始值为[]的变量被认为是一个隐式的any[]变量。变量会根据下面这些操作x.push(value)、x.unshift(value)或x[n] = value向其中添加的元素来不断改变自身的类型。

  1. function f1() {
  2.     let x = [];
  3.     x.push(5);
  4.     x[1] = "hello";
  5.     x.unshift(true);
  6.     return x;  // (string | number | boolean)[]
  7. }
  9. function f2() {
  10.     let x = null;
  11.     if (cond()) {
  12.         x = [];
  13.         while (cond()) {
  14.             x.push("hello");
  15.         }
  16.     }
  17.     return x;  // string[] | null
  18. }

隐式any错误

这样做的一个很大的好处是，当使用—noImplicitAny运行时，你将看到较少的隐式any错误。隐式any错误只会在编译器无法知道一个没有类型注解的变量的类型时才会报告。

示例

  1. function f3() {
  2.     let x = [];  // 错误：当变量'x'类型无法确定时，它隐式具有'any[]'类型。
  3.     x.push(5);
  4.     function g() {
  5.         x;    // 错误：变量'x'隐式具有'any【】'类型。
  6.     }
  7. }

更好的字面量类型推断

字符串、数字和布尔字面量类型（如："abc"，1和true）之前仅在存在显式类型注释时才被推断。从TypeScript 2.1开始，字面量类型总是推断为默认值。

不带类型注解的const变量或readonly属性的类型推断为字面量初始化的类型。已经初始化且不带类型注解的let变量、var变量、形参或非readonly属性的类型推断为初始值的扩展字面量类型。字符串字面量扩展类型是string，数字字面量扩展类型是number,true或false的字面量类型是boolean，还有枚举字面量扩展类型是枚举。

示例

  1. const c1 = 1;  // Type 1
  2. const c2 = c1;  // Type 1
  3. const c3 = "abc";  // Type "abc"
  4. const c4 = true;  // Type true
  5. const c5 = cond ? 1 : "abc";  // Type 1 | "abc"
  7. let v1 = 1;  // Type number
  8. let v2 = c2;  // Type number
  9. let v3 = c3;  // Type string
  10. let v4 = c4;  // Type boolean
  11. let v5 = c5;  // Type number | string

字面量类型扩展可以通过显式类型注解来控制。具体来说，当为不带类型注解的const局部变量推断字面量类型的表达式时，var变量获得扩展字面量类型推断。但是当const局部变量有显式字面量类型注解时，var变量获得非扩展字面量类型。

示例

  1. const c1 = "hello";  // Widening type "hello"
  2. let v1 = c1;  // Type string
  4. const c2: "hello" = "hello";  // Type "hello"
  5. let v2 = c2;  // Type "hello"

将基类构造函数的返回值作为'this'

在ES2015中，构造函数的返回值（它是一个对象）隐式地将this的值替换为super()的任何调用者。因此，有必要捕获任何潜在的super()的返回值并替换为this。此更改允许使用自定义元素，利用此元素可以使用用户编写的构造函数初始化浏览器分配的元素。

示例

  1. class Base {
  2.     x: number;
  3.     constructor() {
  4.         // 返回一个除“this”之外的新对象
  5.         return {
  6.             x: 1,
  7.         };
  8.     }
  9. }
  11. class Derived extends Base {
  12.     constructor() {
  13.         super();
  14.         this.x = 2;
  15.     }
  16. }

生成：

  1. var Derived = (function (_super) {
  2.     __extends(Derived, _super);
  3.     function Derived() {
  4.         var _this = _super.call(this) || this;
  5.         _this.x = 2;
  6.         return _this;
  7.     }
  8.     return Derived;
  9. }(Base));

这在继承内置类如Error，Array，Map等的行为上有了破坏性的改变。请阅读extending built-ins breaking change documnetation。

配置继承

通常一个项目有多个输出版本，比如ES5和ES2015，调试和生产或Commonjs和System。只有几个配置选项在这两个版本之间改变，并且维护多个tsconfig.json文件是麻烦的。

TypeScript 2.1支持使用extends来继承配置，其中：

  • extends在tsconfig.json是新的顶级属性（与compilerOptions、files、include和exclude一起）。
  • extends的值是包含继承自其它tsconfig.json路径的字符串。
  • 首先加载基本文件中的配置，然后由继承配置文件重写。
  • 如果遇到循环，我们报告错误。
  • 继承配置文件中的files、include和exclude会重写基本配置文件中相应的值。
  • 在配置文件中找到的所有相对路径将相对于它们来源的配置文件来解析。

示例

configs/base.json:

  1. {
  2.   "compilerOptions": {
  3.     "allowJs": true,
  4.     "noImplicitAny": true,
  5.     "strictNullChecks": true
  6.   }
  7. }

configs/tests.json:

  1. {
  2.   "compilerOptions": {
  3.     "preserveConstEnums": true,
  4.     "stripComments": false,
  5.     "sourceMaps": true
  6.   },
  7.   "exclude": [
  8.     "../tests/baselines",
  9.     "../tests/scenarios"
  10.   ],
  11.   "include": [
  12.     "../tests/**/*.ts"
  13.   ]
  14. }

tsconfig.json:

  1. {
  2.   "extends": "./configs/base",
  3.   "files": [
  4.     "main.ts",
  5.     "supplemental.ts"
  6.   ]
  7. }

tsconfig.nostrictnull.json:

  1. {
  2.   "extends": "./tsconfig",
  3.   "compilerOptions": {
  4.     "strictNullChecks": false
  5.   }
  6. }

新编译参数—alwaysStrict

使用—alwaysStrict调用编译器原因：1.在严格模式下解析的所有代码。2.在每一个生成文件上输出"use strict";指令;

模块会自动使用严格模式解析。对于非模块代码，建议使用该编译参数。