TypeScript 2.0

Null和undefined类型

TypeScript现在有两个特殊的类型：Null和Undefined, 它们的值分别是null和undefined。 以前这是不可能明确地命名这些类型的，但是现在null和undefined不管在什么类型检查模式下都可以作为类型名称使用。

以前类型检查器认为null和undefined赋值给一切。实际上，null和undefined是每一个类型的有效值， 并且不能明确排除它们（因此不可能检测到错误）。

—strictNullChecks

—strictNullChecks可以切换到新的严格空检查模式中。

在严格空检查模式中，null和undefined值不再属于任何类型的值，仅仅属于它们自己类型和any类型的值 （还有一个例外，undefined也能赋值给void）。因此，尽管在常规类型检查模式下T和T | undefined被认为是相同的 （因为undefined被认为是任何T的子类型），但是在严格类型检查模式下它们是不同的， 并且仅仅T | undefined允许有undefined值，T和T | null的关系同样如此。

示例

  1. // 使用--strictNullChecks参数进行编译的
  2. let x: number;
  3. let y: number | undefined;
  4. let z: number | null | undefined;
  5. x = 1;  // 正确
  6. y = 1;  // 正确
  7. z = 1;  // 正确
  8. x = undefined;  // 错误
  9. y = undefined;  // 正确
  10. z = undefined;  // 正确
  11. x = null;  // 错误
  12. y = null;  // 错误
  13. z = null;  // 正确
  14. x = y;  // 错误
  15. x = z;  // 错误
  16. y = x;  // 正确
  17. y = z;  // 错误
  18. z = x;  // 正确
  19. z = y;  // 正确

使用前赋值检查

在严格空检查模式中，编译器要求未包含undefined类型的局部变量在使用之前必须先赋值。

示例

  1. // 使用--strictNullChecks参数进行编译
  2. let x: number;
  3. let y: number | null;
  4. let z: number | undefined;
  5. x;  // 错误，使用前未赋值
  6. y;  // 错误，使用前未赋值
  7. z;  // 正确
  8. x = 1;
  9. y = null;
  10. x;  // 正确
  11. y;  // 正确

编译器通过执行基于控制流的类型分析检查变量明确被赋过值。在本篇文章后面会有进一步的细节。

可选参数和属性

可选参数和属性会自动把undefined添加到他们的类型中，即使他们的类型注解明确不包含undefined。例如，下面两个类型是完全相同的：

  1. // 使用--strictNullChecks参数进行编译
  2. type T1 = (x?: number) => string;              // x的类型是 number | undefined
  3. type T2 = (x?: number | undefined) => string;  // x的类型是 number | undefined

非null和非undefined类型保护

如果对象或者函数的类型包含null和undefined，那么访问属性或调用函数时就会产生编译错误。因此，对类型保护进行了扩展，以支持对非null和非undefined的检查。

示例

  1. // 使用--strictNullChecks参数进行编译
  2. declare function f(x: number): string;
  3. let x: number | null | undefined;
  4. if (x) {
  5.     f(x);  // 正确，这里的x类型是number
  6. }
  7. else {
  8.     f(x);  // 错误，这里的x类型是number？
  9. }
  10. let a = x != null ? f(x) : "";  // a的类型是string
  11. let b = x && f(x);  // b的类型是 string | 0 | null | undefined

非null和非undefined类型保护可以使用==、!=、===或!==操作符和null或undefined进行比较，如x != null或x === undefined。对被试变量类型的影响准确地反映了JavaScript的语义（比如，双等号运算符检查两个值无论你指定的是null还是undefined，然而三等于号运算符仅仅检查指定的那一个值）。

类型保护中的点名称

类型保护以前仅仅支持对局部变量和参数的检查。现在类型保护支持检查由变量或参数名称后跟一个或多个访问属性组成的“点名称”。

示例

  1. interface Options {
  2.     location?: {
  3.         x?: number;
  4.         y?: number;
  5.     };
  6. }
  8. function foo(options?: Options) {
  9.     if (options && options.location && options.location.x) {
  10.         const x = options.location.x;  // x的类型是number
  11.     }
  12. }

点名称的类型保护和用户定义的类型保护函数，还有typeof和instanceof操作符一起工作，并且不依赖—strictNullChecks编译参数。

对点名称进行类型保护后给点名称任一部分赋值都会导致类型保护无效。例如，对x.y.z进行了类型保护后给x、x.y或x.y.z赋值，都会导致x.y.z类型保护无效。

表达式操作符

表达式操作符允许运算对象的类型包含null和/或undefined，但是总是产生非null和非undefined类型的结果值。

  1. // 使用--strictNullChecks参数进行编译
  2. function sum(a: number | null, b: number | null) {
  3.     return a + b;  // 计算的结果值类型是number
  4. }

&&操作符添加null和/或undefined到右边操作对象的类型中取决于当前左边操作对象的类型，||操作符从左边联合类型的操作对象的类型中将null和undefined同时删除。

  1. // 使用--strictNullChecks参数进行编译
  2. interface Entity {
  3.     name: string;
  4. }
  5. let x: Entity | null;
  6. let s = x && x.name;  // s的类型是string | null
  7. let y = x || { name: "test" };  // y的类型是Entity

类型扩展

在严格空检查模式中，null和undefined类型是不会扩展到any类型中的。

  1. let z = null;  // z的类型是null

在常规类型检查模式中，由于扩展，会推断z的类型是any，但是在严格空检查模式中，推断z是null类型（因此，如果没有类型注释，null是z的唯一值）。

非空断言操作符

在上下文中当类型检查器无法断定类型时，一个新的后缀表达式操作符!可以用于断言操作对象是非null和非undefined类型的。具体而言，运算x!产生一个不包含null和undefined的x的值。断言的形式类似于<T>x和x as T，!非空断言操作符会从编译成的JavaScript代码中移除。

  1. // 使用--strictNullChecks参数进行编译
  2. function validateEntity(e?: Entity) {
  3.     // 如果e是null或者无效的实体，就会抛出异常
  4. }
  6. function processEntity(e?: Entity) {
  7.     validateEntity(e);
  8.     let s = e!.name;  // 断言e是非空并访问name属性
  9. }

兼容性

这些新特性是经过设计的，使得它们能够在严格空检查模式和常规类型检查模式下都能够使用。尤其是在常规类型检查模式中，null和undefined类型会自动从联合类型中删除（因为它们是其它所有类型的子类型），!非空断言表达式操作符也被允许使用但是没有任何作用。因此，声明文件使用null和undefined敏感类型更新后，在常规类型模式中仍然是可以向后兼容使用的。

在实际应用中，严格空检查模式要求编译的所有文件都是null和undefined敏感类型。

基于控制流的类型分析

TypeScript 2.0实现了对局部变量和参数的控制流类型分析。以前，对类型保护进行类型分析仅限于if语句和?:条件表达式，并且不包括赋值和控制流结构的影响，例如return和break语句。使用TypeScript2.0，类型检查器会分析语句和表达式所有可能的控制流，在任何指定的位置对声明为联合类型的局部变量或参数产生最可能的具体类型（缩小范围的类型）。

示例

  1. function foo(x: string | number | boolean) {
  2.     if (typeof x === "string") {
  3.         x; // 这里x的类型是string
  4.         x = 1;
  5.         x; // 这里x的类型是number
  6.     }
  7.     x; // 这里x的类型是number | boolean
  8. }
  10. function bar(x: string | number) {
  11.     if (typeof x === "number") {
  12.         return;
  13.     }
  14.     x; // 这里x的类型是string
  15. }

基于控制流的类型分析在—strictNullChecks模式中尤为重要，因为可空类型使用联合类型来表示：

  1. function test(x: string | null) {
  2.     if (x === null) {
  3.         return;
  4.     }
  5.     x; // 在函数的剩余部分中，x类型是string
  6. }

而且，在—strictNullChecks模式中，基于控制流的分析包括，对类型不允许为undefined的局部变量有明确赋值的分析。

  1. function mumble(check: boolean) {
  2.     let x: number; // 类型不允许为undefined
  3.     x; // 错误，x是undefined
  4.     if (check) {
  5.         x = 1;
  6.         x; // 正确
  7.     }
  8.     x; // 错误，x可能是undefi
  9.     x = 2;
  10.     x; // 正确
  11. }

标记联合类型

TypeScript 2.0实现了标记（或区分）联合类型。具体而言，TS编译器现在支持类型保护，基于判别属性的检查来缩小联合类型的范围，并且switch语句也支持此特性。

示例

  1. interface Square {
  2.     kind: "square";
  3.     size: number;
  4. }
  6. interface Rectangle {
  7.     kind: "rectangle";
  8.     width: number;
  9.     height: number;
  10. }
  12. interface Circle {
  13.     kind: "circle";
  14.     radius: number;
  15. }
  17. type Shape = Square | Rectangle | Circle;
  19. function area(s: Shape) {
  20.     // 在下面的switch语句中，s的类型在每一个case中都被缩小
  21.     // 根据判别属性的值，变量的其它属性不使用类型断言就可以被访问
  22.     switch (s.kind) {
  23.         case "square": return s.size * s.size;
  24.         case "rectangle": return s.width * s.height;
  25.         case "circle": return Math.PI * s.radius * s.radius;
  26.     }
  27. }
  29. function test1(s: Shape) {
  30.     if (s.kind === "square") {
  31.         s;  // Square
  32.     }
  33.     else {
  34.         s;  // Rectangle | Circle
  35.     }
  36. }
  38. function test2(s: Shape) {
  39.     if (s.kind === "square" || s.kind === "rectangle") {
  40.         return;
  41.     }
  42.     s;  // Circle
  43. }

判别属性类型保护是x.p == v、x.p === v、x.p != v或者x.p !== v其中的一种表达式，p和v是一个属性和字符串字面量类型或字符串字面量联合类型的表达式。判别属性类型保护缩小x的类型到由判别属性p和v的可能值之一组成的类型。

请注意，我们目前只支持字符串字面值类型的判别属性。我们打算以后添加对布尔值和数字字面量类型的支持。

never类型

TypeScript 2.0引入了一个新原始类型never。never类型表示值的类型从不出现。具体而言，never是永不返回函数的返回类型，也是变量在类型保护中永不为true的类型。

never类型具有以下特征：

  • never是所有类型的子类型并且可以赋值给所有类型。
  • 没有类型是never的子类型或能赋值给never（never类型本身除外）。
  • 在函数表达式或箭头函数没有返回类型注解时，如果函数没有return语句，或者只有never类型表达式的return语句，并且如果函数是不可执行到终点的（例如通过控制流分析决定的），则推断函数的返回类型是never。
  • 在有明确never返回类型注解的函数中，所有return语句（如果有的话）必须有never类型的表达式并且函数的终点必须是不可执行的。
    因为never是每一个类型的子类型，所以它总是在联合类型中被省略，并且在函数中只要其它类型被返回，类型推断就会忽略never类型。

一些返回never函数的示例：

  1. // 函数返回never必须无法执行到终点
  2. function error(message: string): never {
  3.     throw new Error(message);
  4. }
  6. // 推断返回类型是never
  7. function fail() {
  8.     return error("Something failed");
  9. }
  11. // 函数返回never必须无法执行到终点
  12. function infiniteLoop(): never {
  13.     while (true) {
  14.     }
  15. }

一些函数返回never的使用示例：

  1. // 推断返回类型是number
  2. function move1(direction: "up" | "down") {
  3.     switch (direction) {
  4.         case "up":
  5.             return 1;
  6.         case "down":
  7.             return -1;
  8.     }
  9.     return error("Should never get here");
  10. }
  12. // 推断返回类型是number
  13. function move2(direction: "up" | "down") {
  14.     return direction === "up" ? 1 :
  15.         direction === "down" ? -1 :
  16.         error("Should never get here");
  17. }
  19. // 推断返回类型是T
  20. function check<T>(x: T | undefined) {
  21.     return x || error("Undefined value");
  22. }

因为never可以赋值给每一个类型，当需要回调函数返回一个更加具体的类型时，函数返回never类型可以用于检测返回类型是否正确：

  1. function test(cb: () => string) {
  2.     let s = cb();
  3.     return s;
  4. }
  6. test(() => "hello");
  7. test(() => fail());
  8. test(() => { throw new Error(); })

只读属性和索引签名

属性或索引签名现在可以使用readonly修饰符声明为只读的。

只读属性可以初始化和在同一个类的构造函数中被赋值，但是在其它情况下对只读属性的赋值是不允许的。

此外，有几种情况下实体隐式只读的：

  • 属性声明只使用get访问器而没有使用set访问器被视为只读的。
  • 在枚举类型中，枚举成员被视为只读属性。
  • 在模块类型中，导出的const变量被视为只读属性。
  • 在import语句中声明的实体被视为只读的。
  • 通过ES2015命名空间导入访问的实体被视为只读的（例如，当foo当作import * as foo from "foo"声明时，foo.x是只读的）。

    示例

  1. interface Point {
  2.     readonly x: number;
  3.     readonly y: number;
  4. }
  6. var p1: Point = { x: 10, y: 20 };
  7. p1.x = 5;  // 错误，p1.x是只读的
  9. var p2 = { x: 1, y: 1 };
  10. var p3: Point = p2;  // 正确，p2的只读别名
  11. p3.x = 5;  // 错误，p3.x是只读的
  12. p2.x = 5;  // 正确，但是因为别名使用，同时也改变了p3.x
  1. class Foo {
  2.     readonly a = 1;
  3.     readonly b: string;
  4.     constructor() {
  5.         this.b = "hello";  // 在构造函数中允许赋值
  6.     }
  7. }
  1. let a: Array<number> = [0, 1, 2, 3, 4];
  2. let b: ReadonlyArray<number> = a;
  3. b[5] = 5;      // 错误，元素是只读的
  4. b.push(5);     // 错误，没有push方法（因为这会修改数组）
  5. b.length = 3;  // 错误，length是只读的
  6. a = b;         // 错误，缺少修改数组的方法

指定函数中this类型

紧跟着类和接口，现在函数和方法也可以声明this的类型了。

函数中this的默认类型是any。从TypeScript 2.0开始，你可以提供一个明确的this参数。this参数是伪参数，它位于函数参数列表的第一位：

  1. function f(this: void) {
  2.     // 确保`this`在这个独立的函数中无法使用
  3. }

回调函数中的this参数

库也可以使用this参数声明回调函数如何被调用。

示例

  1. interface UIElement {
  2.     addClickListener(onclick: (this: void, e: Event) => void): void;
  3. }

this:void意味着addClickListener预计onclick是一个this参数不需要类型的函数。

现在如果你在调用代码中对this进行了类型注释：

  1. class Handler {
  2.     info: string;
  3.     onClickBad(this: Handler, e: Event) {
  4.         // 哎哟，在这里使用this.在运行中使用这个回调函数将会崩溃。
  5.         this.info = e.message;
  6.     };
  7. }
  8. let h = new Handler();
  9. uiElement.addClickListener(h.onClickBad); // 错误！

—noImplicitThis

TypeScript 2.0还增加了一个新的编译选项用来标记函数中所有没有明确类型注释的this的使用。

tsconfig.json支持文件通配符

文件通配符来啦！！支持文件通配符一直是最需要的特性之一。

类似文件通配符的文件模式支持两个属性"include"和"exclude"。

示例

  1. {
  2.     "compilerOptions": {
  3.         "module": "commonjs",
  4.         "noImplicitAny": true,
  5.         "removeComments": true,
  6.         "preserveConstEnums": true,
  7.         "outFile": "../../built/local/tsc.js",
  8.         "sourceMap": true
  9.     },
  10.     "include": [
  11.         "src/**/*"
  12.     ],
  13.     "exclude": [
  14.         "node_modules",
  15.         "**/*.spec.ts"
  16.     ]
  17. }

支持文件通配符的符号有：

  • *匹配零个或多个字符（不包括目录）
  • ?匹配任意一个字符（不包括目录）
  • */递归匹配所有子目录
    如果文件通配符模式语句中只包含    或.*，那么只匹配带有扩展名的文件（例如默认是.ts、.tsx和.d.ts，如果allowJs设置为true，.js和.jsx也属于默认）。

如果"files"和"include"都没有指定，编译器默认包含所有目录中的TypeScript文件（.ts、.d.ts和.tsx），除了那些使用exclude属性排除的文件外。如果allowJs设置为true，JS文件（.js和.jsx）也会被包含进去。

如果"files"和"include"都指定了，编译器将包含这两个属性指定文件的并集。使用ourDir编译选项指定的目录文件总是被排除，即使"exclude"属性指定的文件也会被删除，但是files属性指定的文件不会排除。

"exclude"属性指定的文件会对"include"属性指定的文件过滤。但是对"files"指定的文件没有任何作用。当没有明确指定时，"exclude"属性默认会排除node_modules、bower_components和jspm_packages目录。

模块解析增加：BaseUrl、路径映射、rootDirs和追踪

TypeScript 2.0提供了一系列额外的模块解析属性告诉编译器去哪里可以找到给定模块的声明。

更多详情，请参阅模块解析文档。

Base URL

使用了AMD模块加载器并且模块在运行时”部署“到单文件夹的应用程序中使用baseUrl是一种常用的做法。所有非相对名称的模块导入被认为是相对于baseUrl的。

示例

  1. {
  2.   "compilerOptions": {
  3.     "baseUrl": "./modules"
  4.   }
  5. }

现在导入moduleA将会在./modules/moduleA中查找。

  1. import A from "moduleA";

路径映射

有时模块没有直接位于baseUrl中。加载器使用映射配置在运行时去映射模块名称和文件，请参阅RequireJs文档和SystemJS文档。

TypeScript编译器支持tsconfig文件中使用"paths"属性映射的声明。

示例

例如，导入"jquery"模块在运行时会被转换为"node_modules/jquery/dist/jquery.slim.min.js"。

  1. {
  2.     "compilerOptions": {
  3.         "baseUrl": "./node_modules",
  4.         "paths": {
  5.         "jquery": ["jquery/dist/jquery.slim.min"]
  6.         }
  7.     }
  8. }

使用"paths"也允许更复杂的映射，包括多次后退的位置。考虑一个只有一个地方的模块是可用的，其它的模块都在另一个地方的项目配置。

rootDirs和虚拟目录

使用rootDirs，你可以告知编译器的根目录组合这些“虚拟”目录。因此编译器在这些“虚拟”目录中解析相对导入模块，仿佛是合并到一个目录中一样。

示例

给定的项目结构

  1.  src
  2.  └── views
  3.      └── view1.ts (imports './template1')
  4.      └── view2.ts
  6.  generated
  7.  └── templates
  8.          └── views
  9.              └── template1.ts (imports './view2')

构建步骤将复制/src/views和/generated/templates/views目录下的文件输出到同一个目录中。在运行时，视图期望它的模板和它存在同一目录中，因此应该使用相对名称"./template"导入。

"rootDir"指定的一组根目录的内容将会在运行时合并。因此在我们的例子，tsconfig.json文件应该类似于：

  1. {
  2.   "compilerOptions": {
  3.     "rootDirs": [
  4.       "src/views",
  5.       "generated/templates/views"
  6.     ]
  7.   }
  8. }

追踪模块解析

—traceResolution提供了一种方便的方法，以了解模块如何被编译器解析的。

  1. tsc --traceResolution

快捷外部模块声明

当你使用一个新模块时，如果不想要花费时间书写一个声明时，现在你可以使用快捷声明以便以快速开始。

declarations.d.ts

  1. declare module "hot-new-module";

所有从快捷模块的导入都具有任意类型。

  1. import x, {y} from "hot-new-module";
  2. x(y);

模块名称中的通配符

以前使用模块加载器（例如AMD和SystemJS）导入没有代码的资源是不容易的。之前，必须为每个资源定义一个外部模块声明。

TypeScript 2.0支持使用通配符符号（*）定义一类模块名称。这种方式，一个声明只需要一次扩展名，而不再是每一个资源。

示例

  1. declare module "*!text" {
  2.     const content: string;
  3.     export default content;
  4. }
  5. // Some do it the other way around.
  6. declare module "json!*" {
  7.     const value: any;
  8.     export default value;
  9. }

现在你可以导入匹配"!text"或"json!"的东西了。

  1. import fileContent from "./xyz.txt!text";
  2. import data from "json!http://example.com/data.json";
  3. console.log(data, fileContent);

当从一个基于非类型化的代码迁移时，通配符模块的名称可能更加有用。结合快捷外部模块声明，一组模块可以很容易地声明为any。

示例

  1. declare module "myLibrary/*";

所有位于myLibrary目录之下的模块的导入都被编译器认为是any类型，因此这些模块的任何类型检查都会被关闭。

  1. import { readFile } from "myLibrary/fileSystem/readFile`;
  3. readFile(); // readFile是'any'类型

支持UMD模块定义

一些库被设计为可以使用多种模块加载器或者不是使用模块加载器（全局变量）来使用，这被称为UMD或同构模块。这些库可以通过导入或全局变量访问。

举例：

math-lib.d.ts
  1. export const isPrime(x: number): boolean;
  2. export as namespace mathLib;

然后，该库可作为模块导入使用：

  1. import { isPrime } from "math-lib";
  2. isPrime(2);
  3. mathLib.isPrime(2); // 错误：无法在模块内部使用全局定义

它也可以被用来作为一个全局变量，只限于没有import和export脚本文件中。

  1. mathLib.isPrime(2);

可选类属性

现在可以在类中声明可选属性和方法，与接口类似。

示例

  1. class Bar {
  2.     a: number;
  3.     b?: number;
  4.     f() {
  5.         return 1;
  6.     }
  7.     g?(): number;  // 可选方法的方法体可以省略
  8.     h?() {
  9.         return 2;
  10.     }
  11. }

在—strictNullChecks模式下编译时，可选属性和方法会自动添加undefined到它们的类型中。因此，上面的b属性类型是number | undefined，上面g方法的类型是(()=> number) | undefined。使用类型保护可以去除undefined。

私有的和受保护的构造函数

类的构造函数可以被标记为private或protected。私有构造函数的类不能在类的外部实例化，并且也不能被继承。受保护构造函数的类不能再类的外部实例化，但是可以被继承。

示例

  1. class Singleton {
  2.     private static instance: Singleton;
  4.     private constructor() { }
  6.     static getInstance() {
  7.         if (!Singleton.instance) {
  8.             Singleton.instance = new Singleton();
  9.         }
  10.         return Singleton.instance;
  11.     }
  12. }
  14. let e = new Singleton(); // 错误：Singleton的构造函数是私有的。
  15. let v = Singleton.getInstance();

抽象属性和访问器

抽象类可以声明抽象属性和、或访问器。所有子类将需要声明抽象属性或者被标记为抽象的。抽象属性不能初始化。抽象访问器不能有具体代码块。

示例

  1. abstract class Base {
  2.     abstract name: string;
  3.     abstract get value();
  4.     abstract set value(v: number);
  5. }
  7. class Derived extends Base {
  8.     name = "derived";
  10.     value = 1;
  11. }

隐式索引签名

如果对象字面量中所有已知的属性是赋值给索引签名，那么现在对象字面量类型可以赋值给索引签名类型。这使得一个使用对象字面量初始化的变量作为参数传递给期望参数是map或dictionary的函数成为可能：

  1. function httpService(path: string, headers: { [x: string]: string }) { }
  3. const headers = {
  4.     "Content-Type": "application/x-www-form-urlencoded"
  5. };
  7. httpService("", { "Content-Type": "application/x-www-form-urlencoded" });  // 可以
  8. httpService("", headers);  // 现在可以，以前不可以。

使用—lib编译参数包含内置类型声明

获取ES6/ES2015内置API声明仅限于target: ES6。输入—lib，你可以使用—lib指定一组项目所需要的内置API。比如说，如果你希望项目运行时支持Map、Set和Promise（例如现在静默更新浏览器），直接写—lib es2015.collection,es2015.promise就好了。同样，你也可以排除项目中不需要的声明，例如在node项目中使用—lib es5,es6排除DOM。

下面是列出了可用的API：

  • dom
  • webworker
  • es5
  • es6 / es2015
  • es2015.core
  • es2015.collection
  • es2015.iterable
  • es2015.promise
  • es2015.proxy
  • es2015.reflect
  • es2015.generator
  • es2015.symbol
  • es2015.symbol.wellknown
  • es2016
  • es2016.array.include
  • es2017
  • es2017.object
  • es2017.sharedmemory
  • scripthost

    示例

  1. tsc --target es5 --lib es5,es2015.promise
  1. "compilerOptions": {
  2.     "lib": ["es5", "es2015.promise"]
  3. }

使用—noUnusedParameters和—noUnusedLocals标记未使用的声明

TypeScript 2.0有两个新的编译参数来帮助你保持一个干净的代码库。-noUnusedParameters编译参数标记所有未使用的函数或方法的参数错误。—noUnusedLocals标记所有未使用的局部（未导出）声明像变量、函数、类和导入等等，另外未使用的私有类成员在—noUnusedLocals作用下也会标记为错误。

示例

  1. import B, { readFile } from "./b";
  2. //     ^ 错误：`B`声明了，但是没有使用。
  3. readFile();
  6. export function write(message: string, args: string[]) {
  7.     //                                 ^^^^  错误：'arg'声明了，但是没有使用。
  8.     console.log(message);
  9. }

使用以_开头命名的参数声明不会被未使用参数检查。例如：

  1. function returnNull(_a) { // 正确
  2.     return null;
  3. }

模块名称允许.js扩展名

TypeScript 2.0之前，模块名称总是被认为是没有扩展名的。例如，导入一个模块import d from "./moduleA.js"，则编译器在./moduleA.js.ts或./moduleA.js.d.ts中查找"moduleA.js"的定义。这使得像SystemJS这种期望模块名称是URI的打包或加载工具很难使用。

使用TypeScript 2.0，编译器将在./moduleA.ts或./moduleA.d.ts中查找"moduleA.js"的定义。

支持编译参数target : es5和module: es6同时使用

之前编译参数target : es5和module: es6同时使用被认为是无效的，但是现在是有效的。这将有助于使用基于ES2015的tree-shaking（将无用代码移除）比如rollup。

函数形参和实参列表末尾支持逗号

现在函数形参和实参列表末尾允许有逗号。这是对第三阶段的ECMAScript提案的实现, 并且会编译为可用的ES3/ES5/ES6。

示例

  1. function foo(
  2.   bar: Bar,
  3.   baz: Baz, // 形参列表末尾添加逗号是没有问题的。
  4. ) {
  5.   // 具体实现……
  6. }
  8. foo(
  9.   bar,
  10.   baz, // 实参列表末尾添加逗号同样没有问题
  11. );

新编译参数—skipLibCheck

TypeScript 2.0添加了一个新的编译参数—skipLibCheck，该参数可以跳过声明文件（以.d.ts为扩展名的文件）的类型检查。当一个程序包含有大量的声明文件时，编译器需要花费大量时间对已知不包含错误的声明进行类型检查，通过跳过声明文件的类型检查，编译时间可能会大大缩短。

由于一个文件中的声明可以影响其他文件中的类型检查，当指定—skipLibCheck时，一些错误可能检测不到。比如说, 如果一个非声明文件中的类型被声明文件用到, 可能仅在声明文件被检查时能发现错误. 不过这种情况在实际使用中并不常见。

允许在声明中重复标识符

这是重复定义错误的一个常见来源。多个声明文件定义相同的接口成员。

TypeScript 2.0放宽了这一约束，并允许可以不同代码块中出现重复的标识符, 只要它们有完全相同的类型。

在同一代码块重复定义仍不允许。

示例

  1. interface Error {
  2.     stack?: string;
  3. }
  6. interface Error {
  7.     code?: string;
  8.     path?: string;
  9.     stack?: string;  // OK
  10. }

新编译参数—declarationDir

—declarationDir可以使生成的声明文件和JavaScript文件不在同一个位置中。

原文: https://www.tslang.cn/docs/release-notes/typescript-2.0.html