TypeScript - 101：基础知识

目录

• 引言
  • TypeScript
  • 安装 TypeScript
• TypeScript 基础知识
  • TypeScript 类型
  • 类型推断
  • 可选类型
• 类和接口
  • 类
    • 默认参数和可选参数
  • 接口
  • 继承
• 模块
  • 引用内部模块
  • 异步模块定义 (AMD)
• TypeScript 与外部库
  • 声明文件
• 摘要
• 附录

引言

TypeScript

如今，JavaScript 是一种通用的 Web 语言，所有浏览器都支持它，无需任何特殊安装。当今的 Web 开发离不开 JavaScript，JavaScript 的应用范围已经不仅限于客户端开发，还扩展到了服务器端开发，例如 NodeJS。但是，问任何一个正在学习 JavaScript 或来自面向对象背景的开发者，他们都会在被问及 JavaScript 编程的易用性时翻白眼。JavaScript 最强大的特性之一是其动态类型，允许我们将任何值赋给任何变量，但如果不够小心，这一特性在大型 JavaScript 应用中会成为障碍。JavaScript 也没有良好的 IntelliSense（智能感知），并且你很少能在编译时发现错误，尤其是类型错误。

正如 TypeScript 官方网站所述，“TypeScript 是一种类型的 JavaScript 超集，可编译为纯 JavaScript”。TypeScript 并非 JavaScript 的替代品，它不为 JavaScript 添加任何新功能。TypeScript 为开发者提供了类型安全、编译时类型检查、在 JavaScript 之上的面向对象构造等功能，基本上让开发者在编写 JavaScript 时可以进行面向对象的思考。TypeScript 最神奇的一点是，它会编译成 JavaScript，因此我们无需支持任何新的虚拟机来运行 TypeScript，然后可以将其引用到网页中，或在 NodeJS 等服务器端使用。

TypeScript 是微软开发的开源项目，但它与微软平台没有任何关联，可以在任何需要编写 JavaScript 的环境中使用。尽管微软在 Visual Studio 中为 TypeScript 提供了出色的支持，并且我们将使用 Visual Studio 来演示，但我们也可以从命令行使用 TypeScript 编译器将 TypeScript 编译为 JavaScript（我们也会简要示例）。

安装 TypeScript

TypeScript 已默认包含在 Visual Studio 2013 Update 2 中，并且可以从 TypeScript 网站提供的安装程序安装到 Visual Studio 2012 中。本文撰写时，当前版本为 1.0。TypeScript 还支持 sublime、Emacs 和 Vim 等其他编辑器。TypeScript 还有一个可用于 Node.js 的包。所有这些安装都可以在 TypeScript 网站找到。

在为 Visual Studio 安装 TypeScript 后，它会添加新的项目和项模板。这使我们能够创建 TypeScript 新项目，以及将 TypeScript 文件添加到现有应用程序中。

TypeScript 文件模板的创建方式与其他文件类似，只需选择“添加新项”，然后选择一个 TypeScript 文件。

所有 TypeScript 文件都以 *.ts 扩展名结尾。TypeScript 的 Visual Studio 插件会在我们修改并保存 TypeScript 文件时，自动创建并更新一个同名的 JavaScript 文件。然后，生成的 JavaScript 文件可以作为普通文件使用并包含在任何网页中。

当我们创建一个 TypeScript 项目时，项目中会创建一个默认的“app.ts”文件，其中包含默认的代码实现。Visual Studio 还提供 TypeScript 文件与其对应的 JavaScript 文件的并排视图，每次保存 TypeScript 文件时，我们都可以看到 JavaScript 文件中的变化。TypeScript 文件通过创建相应的“*.js.map”文件来实现此功能。Visual Studio 使用此映射文件将 TypeScript 代码与生成的 JavaScript 代码进行映射。此外，Chrome 等浏览器也会使用这些映射文件来帮助我们直接调试 TypeScript 文件，而不是调试 JavaScript 文件。

如果发现 TypeScript 未自动编译或更新 JavaScript，请检查“工具”菜单下的选项，如下图所示。此问题以前在 TypeScript 1.0 之前的版本中很常见。

我们还可以使用“tsc.exe”命令并通过传递 <<文件名>>.ts 文件来从命令行生成 JavaScript 文件。“tsc.exe”位于“Microsoft SDK/TypeScript”目录下。

TypeScript 基础知识

TypeScript 在 JavaScript 的基础上为开发者提供了面向对象的概念和编译时类型检查，这有助于编写更结构化、可维护和健壮的代码。TypeScript 引入了类、接口、模块和变量等标准面向对象术语，这些最终会被转换为各种形式的 JavaScript。典型的 TypeScript 文件代码结构如下所示。

模块

模块在 .NET 世界中类似于命名空间，可以包含类和接口。模块本身没有自己的特性，它们只提供一个容器，用于以逻辑形式组织代码。将模块视为业务/逻辑实体的容器。

接口

接口在 .NET 中与接口完全相同，它们为类提供了要实现的契约。TypeScript 有助于为实现这些接口的类提供编译时错误检查。如果所有方法（包括方法签名）都未正确实现，TypeScript 会在设计时和编译时标记它们。关于接口的有趣之处在于，它们在 JavaScript 中不存在，因此在我们将 TypeScript 文件编译为 JavaScript 时，接口会被忽略。

类

类的概念与 .NET/Java 世界非常相似。类包含变量、属性和方法，这些共同构成了一个逻辑实体。TypeScript 还允许使用“private”和“public”关键字来设置变量和函数的范围，尽管这些范围不会对生成的 JavaScript 产生任何影响。

函数

函数是实现逻辑的方法。TypeScript 提供编译时支持，以确保调用函数的任何人都能正确匹配输入参数和返回值的类型。

变量

变量是定义在类或函数内的字段。TypeScript 允许我们使用“var”关键字定义变量并为其指定数据类型。一旦指定了数据类型，变量的任何后续使用都必须与相同的数据类型相符，否则 TypeScript 将在设计时和编译时生成错误。TypeScript 也很智能，能够推断变量的类型，并在声明和初始化变量时将其视为该类型。在 TypeScript 无法推断类型的情况下，它会为该变量分配“any”类型。

TypeScript 类型

TypeScript 提供了一些原始类型（如下所示）以及一个动态类型“any”。“Any”类似于 C# 中的“dynamic”关键字，我们可以将任何类型的值赋给变量。TypeScript 不会为“any”类型的变量标记任何类型错误。

在 TypeScript 中，我们通过在变量名后附加冒号，然后跟类型名称来定义变量的类型，如下例所示。

var num: number = 30; //variable num is of type number

下面是 TypeScript 中可用的原始类型列表

• Number： “number”是 TypeScript 中的原始数字类型。TypeScript 中没有区分 float 或 double 的不同类型。
• Boolean：“boolean”类型表示 true 或 false 条件。
• String：“string”表示字符序列，类似于 C#。
• Null：“null”是一种特殊类型，用于将 null 值赋给变量。
• Undefined：“undefined”也是一种特殊类型，可以赋给任何变量。

数组类型：TypeScript 还允许开发者通过添加方括号来创建数组对象，类似于 .NET 中的方式，如下例所示。

 var array: string[] = ['test', 'dummy'];
 var first: string = array[0];

 var array = ['test', 'dummy'];
 var first = array[0];

这允许我们在 TypeScript 中使用原始类型创建复杂对象。在 TypeScript 中，数组使用零基索引访问。

TypeScript 还允许我们创建复杂变量，如下例所示。

 var name = { firstName: 'Homer', lastName: 'Simpson' };
 name.firstName = 2; //This gives compile time error

 var name = { firstName: 'Homer', lastName: 'Simpson' };
 name.firstName = 2; //No Error in JavaScript

此外，在上面的例子中，请注意我们没有定义 name 变量的类型，但 TypeScript 足够智能，能够推断出 name 是一个复杂对象，其中包含“firstName”和“lastName” string 变量。如果我们尝试将任何非 string 类型的值赋给其中任何一个变量，TypeScript 都会在设计时显示一个错误，并在 name 变量下方显示一条红线。

类型推断

如上所述，TypeScript 提供类型推断，即使我们没有为变量定义类型，TypeScript 也会根据初始化变量的值来推断其类型。如果我们既没有初始化变量，也没有在声明变量时定义类型，TypeScript 会为该变量分配“any”类型。但是，由于 JavaScript 不区分任何这些类型，所有变量对于 JavaScript 来说都是相同的。

 var dummy; //any type
 var num = 10; //number
 var str = 'Hello TypeScript'; //string
 var bln = true; //boolean
 var stringArray = ['Homer', 'Simpson']; //string[]

 var dummy;
 var num = 10;
 var str = 'Hello TypeScript';
 var bln = true;
 var stringArray = ['Homer', 'Simpson'];

类型仅对 TypeScript 有效，对生成的 JavaScript 没有影响。类型仅由 TypeScript 用于编译时检查，并使开发者能够确保将正确的值传递给变量。

函数也支持类型检查。我们可以在定义输入参数时定义类型，但如果未指定类型，TypeScript 会将其视为“any”。对于返回类型，如果我们不定义类型，TypeScript 将根据这些变量的使用情况来推断类型。

 var addFunction = function (n1: number, n2: number, n3: number) {
 var sum = n1 + n2 + n3;
 return sum;
 };
 var str1: string = addFunction(10, 20, 30); //Gives compile time error as 
      //return type of a function is number and is being assigned to a string

 var sum: number = addFunction(10, 20, 30); // This works
 var result = addFunction(10, 20, 30); // This also works

 var addFunction = function (n1, n2, n3) {
var sum = n1 + n2 + n3;
return sum;
};
var str1 = addFunction(10, 20, 30);
var sum = addFunction(10, 20, 30);
var result = addFunction(10, 20, 30);

在上表中，我们看到 TypeScript 使用类型推断来确定“addFunction”根据输入参数类型具有“number”返回类型。当我们尝试将函数的结果赋给一个 string 变量时，TypeScript 会显示设计时和编译时错误。这在 JavaScript 中不会发生，JavaScript 会正常编译。同样，如果我们没有为变量“n1”、“n2”、“n3”定义类型，TypeScript 会将它们分配为“any”类型，然后将返回类型分配为“any”。我们还可以通过在参数后加上冒号并分配类型来显式定义返回类型，例如：

 var addFunction = function (n1: number, n2: number, n3: number) : number {
 var sum = n1 + n2 + n3;
 return sum;
 };

可选类型

TypeScript 还允许我们在函数中将一个变量声明为可选，这样调用该函数的任何人都可以选择是否传递该变量的值。要使函数参数成为可选，我们需要在变量名后加上“?”。同样，可选参数在 JavaScript 中不存在，因此在那里不会被处理。

 var addFunction = function (n1: number, n2: number, n3?: number) : number {
 var sum = n1 + n2 + n3;
 return sum;
 };
 var sum: number = addFunction(10, 20);

 var addFunction = function (n1, n2, n3) {
 var sum = n1 + n2 + n3;
 return sum;
 };
 var sum = addFunction(10, 20);

可选参数必须是参数列表中的最后一个参数，并且不能在可选参数之后有必需的参数，这与 C# 约定类似。我们也可以在类中定义的变量/字段中使用可选概念，这将在下一章中展示。

类和接口

类

TypeScript 类是抽象的基本单元，与 C#/Java 类非常相似。在 TypeScript 中，可以使用“class”关键字后跟类名来定义类。TypeScript 类可以包含构造函数、字段、属性和函数。TypeScript 允许开发者将类中变量的作用域定义为“public”或“private”。重要的是要注意，“public/private”关键字仅在 TypeScript 中可用，一旦转换为 JavaScript，就无法区分两者，都可以被调用。TypeScript 使用“constructor”关键字定义构造函数。

 class Student {
    private firstName: string;
    private lastName: string;
    yearOfBirth: number;    //Public scope by default
    schoolName: string;
    city: string;
    //Constructor            
    constructor(firstName: string, lastName: string, schoolName: string, 
                city: string, yearOfBirth: number) {

        this.firstName = firstName;
        this.lastName = lastName;
        this.yearOfBirth = yearOfBirth;
        this.city = city;
        this.schoolName = schoolName;

    }
    //Function
    age() {
        return 2014 - this.yearOfBirth;
    }         
    //Function
    printStudentFullName(): void {
        alert(this.lastName + ',' + this.firstName);
    }
}

 var Student = (function () {
    //Constructor
    function Student(firstName, lastName, schoolName, city, yearOfBirth) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.yearOfBirth = yearOfBirth;
        this.city = city;
        this.schoolName = schoolName;
    }
    //Function
    Student.prototype.age = function () {
        return 2014 - this.yearOfBirth;
    };

    //Function
    Student.prototype.printStudentFullName = function () {
        alert(this.lastName + ',' + this.firstName);
    };
    return Student;
})();

在上面 TypeScript 中定义的构造函数中，我们有几个输入变量，然后这些变量被映射到类中的局部变量。我们可以修改此构造函数，通过在构造函数定义中指定作用域以及变量名来实现隐式变量声明和映射，如下所示。

constructor(private firstName: string, private lastName: string, public schoolName: string, 
            public yearOfBirth: number) {}

在以上情况中，变量现在仅在构造函数参数中定义和声明。与参数一起指定的作用域成为该类变量的作用域。

要使用类，其行为与 C# 类似，我们使用“new”关键字来初始化类对象，如果构造函数需要参数，则传递参数，然后调用类的方法或访问其 public 变量。

var student = new Student('Tom', 'Hanks', 'World Acting School',1950);
 var age = student.age();
 var fullName = student.printStudentFullName();
 var schoolName = student.schoolName;

默认参数和可选参数

在 TypeScript 中，我们还可以为任何参数设置默认值，然后在调用该函数时，不需要传递这些参数的值。如果我们不传递值，则函数将采用分配的默认值，否则将采用传递的值，如下例所示。

constructor(private firstName: string, private lastName: string, public schoolName: string, 
            public yearOfBirth: number = 1990){}

在上面的例子中，我们为“yearOfBirth”字段分配了一个可选值，如果调用函数时未为此字段传递任何值，则构造函数将将其初始化为 1990。

可选参数的情况也类似，我们可以通过在参数名后添加“?”来定义一个参数。在这种情况下，调用函数时，我们不需要为该参数传递值。

Subject(subjectList?: string[]) {
   if (subjectList == null) {
      alert('Oh, You have not subscribed to any course');
    }
  }

在这里，如果我们不传递任何参数值就调用 subject 方法，TypeScript 不会显示任何错误。

接口

TypeScript 支持使用接口作为类的契约，类似于 C#。要声明一个接口，我们使用“interface”关键字后跟接口名称。关于接口的重要一点是，当编译成 JavaScript 时，接口代码会被忽略，也不会生成相应的 JavaScript。

interface IStudent {
     yearOfBirth: number;
     age : () => number;
   }

类使用“implement”关键字后跟接口名称来实现接口。与 C# 一样，类可以实现多个接口，TypeScript 会进行设计时检查，以确保类实现了该接口的所有方法。

class Student implements IStudent

现在，Student 类将不得不实现“age”方法并定义“yearOfBirth”属性，否则 TypeScript 将显示设计时错误，并指出哪个属性/方法未在类中实现。

继承

有了类和接口，TypeScript 也支持继承，这是一个非常强大的特性，它使编写客户端代码的方式与我们编写 C# 代码的方式保持一致。通过继承，我们可以扩展类，实现和扩展接口，并编写与 OOP 非常接近的代码。在 TypeScript 中，当我们在子类中扩展基类时，我们使用“super”关键字来调用基类的构造函数，甚至调用基类的 public 方法。

要在 TypeScript 中扩展类，我们在类名后使用“extend”关键字，然后跟需要扩展的类名。我们还可以继承接口。

//Interface
interface IStudent {
    yearOfBirth: number;
    age : () => number;
}
//Base Class
class College {
    constructor(public name: string, public city: string) {
    }
    public Address(streetName: string) {             
        return ('College Name:' + this.name + ' City: ' + this.city + ' Street Name: ' + streetName);
    }
}
//Child Class implements IStudent and inherits from College
class Student extends College implements IStudent {
    firstName: string;
    lastName: string;
    yearOfBirth: number;
    //private _college: College;
    //Constructor            
    constructor(firstName: string, lastName: string, name: string, city: string, yearOfBirth: number) {
        super(name, city);
        this.firstName = firstName;
        this.lastName = lastName;
        this.yearOfBirth = yearOfBirth;
    }
    age () { 
        return 2014 - this.yearOfBirth;
    }
    CollegeDetails() {
        var y = super.Address('Maple Street');
        alert(y);
    }
    printDetails(): void {
        alert(this.firstName + ' ' + this.lastName + ' College is: ' + this.name);
    }
}

模块

TypeScript 中的模块与 C# 中的命名空间用途类似，它允许我们将逻辑代码分组。模块有助于我们在客户端代码中遵循“关注点分离”的概念，其中每个模块都可以扮演特定的角色。模块通过允许我们导入其他模块、导出模块外的特性来提供灵活性。

模块内的所有内容都作用于该模块的作用域，因此，放置在模块内的类和接口无法在外部访问，除非我们使用“export”关键字显式地为它们提供作用域。

模块使用“module”关键字声明。我们可以将一个模块嵌套在另一个模块中，这有助于提供更好的代码可维护性。

module Movie {
    class Comedy {
        constructor(public actorName: string) { }

        getAllMovies() {
            return (["Alien", "Paul Bart", "Home Alone"]);
        }

        getMoviesbyActor() {
            if (this.actorName === 'Seth Rogen') {
                return (["Observe and Report"]);
            }
            else {
                return (["Home Alone"]);
            }
        }
    }   
}

在这里，我们声明了一个包含类定义的模块。值得注意的是，“Comedy”类在“Movie”模块之外是不可见的，但在“Movie”模块内部可以访问，因为它在该作用域内。这有助于代码分离，并根据业务需求提供相关作用域。

要能够访问模块外部的类、接口或变量，我们需要使用“export”关键字标记它们。一旦模块内的类被标记为“export”关键字，所有 public 变量和函数也可以在模块外部访问。

因此，模块有助于我们最小化类的作用域，并为我们提供一个更健壮的平台来管理客户端代码。在任何应用程序中，无论其规模如何，我们都希望访问其他模块内的模块，获取引用，调用类中的方法等等。要实现这一点，我们需要在模块之间创建依赖关系，并确保脚本按照依赖关系加载到页面中，未依赖于任何其他模块的模块应该先加载，依此类推。

在 TypeScript 中，我们有两种方式在模块之间添加依赖关系，如下一节所述。

引用内部模块

TypeScript 提供了一个系统（此机制也适用于 Visual Studio 中的 JavaScript），通过该系统，我们可以使模块在其他模块内部甚至在整个程序中可用。这可以通过在要引用其他模块的模块顶部添加引用注释来实现。任何模块的依赖关系都定义在该模块的顶部，形式为注释。

/// <reference path="Sample.ts" />
  var college = new Sample.College('My College', 'My City');

上面，我们看到在添加了对 Sample 模块（位于 Sample.ts 中）的引用后，我们可以访问 College 类，前提是 College 类已标记为“export”关键字。通过拖放文件即可添加引用注释，Visual Studio 默认会在文件顶部添加这些注释。

引用注释告知编译器 Sample 模块将在本模块加载之前可用，因此编译器允许在此处访问 Sample 模块中的类。通过添加“reference”注释，我们还可以获得类的自动完成和设计时编译检查。我们可以根据需要添加任意多的“reference”注释来为模块添加依赖项。

使用这种方法，我们应该了解每个模块的依赖关系图，因此它适用于小型或中型应用程序。我们必须确保所有依赖项都在指定模块加载之前加载才能使其正常工作，这对于拥有大量模块及其相应文件的特大型应用程序来说可能是一件头疼的事。

异步模块定义 (AMD)

AMD 允许模块按需异步加载。RequireJS 就是提供按需加载模块机制的库之一。我们只需要使用“import”关键字引用依赖模块，RequireJS 会在运行时负责加载它们。AMD 管理每个模块的依赖关系，并消除了在特定模块加载之前确保所有依赖模块都已加载到页面的复杂性。RequireJS 使用识别谁依赖于谁，然后按顺序加载它们的概念。

这是大型 Web 应用程序非常有用的技术，这些应用程序拥有大量的 TypeScript/JavaScript 文件，并且维护依赖关系图非常麻烦。

RequireJS 使用配置式编程来处理模块加载。我们不是按特定顺序加载所有脚本，而是通过 RequireJS 在 HTML 页面中定义一个启动/引导文件。RequireJS 会读取该文件并导航到启动文件，然后根据需要调用其他模块。当我们调用其他模块时，RequireJS 会按需加载依赖项。

<!-- Below line initalizes requirejs and mentions the startup file. In this case main-->
   <script data-main="main" src="Scripts/require.js" type="text/javascript"></script>

然后在 main.ts/main.js 中，我们定义 start 方法，在这种情况下是 run()，它将负责加载起始页，在这种情况下是 dataService。

main.ts

require.config({
    baseUrl : "."
}); 

require(["bootstrapper"], (bootstrap) => {
    bootstrap.run();
});

Bootstrapper.ts

import ds = require("DataService");

export function run() {
    var service = new ds.DataService();
}    alert(service.getMessage());

DataService.ts

export interface IDataService {
     msg: string;
     getMessage(): string;
    };

export class DataService implements IDataService {
     msg = 'Data from API Call';
     getMessage() { return this.msg; }
}

总而言之，管理许多 TypeScript/JavaScript 文件是一项重要的任务，需要提前计划。对于小型应用程序，管理依赖关系不是主要问题，因为我们可以简单地使用“reference”风格的注释并确保按定义的顺序加载脚本。但是，如果我们知道应用程序将增长到大量文件，那么我们应该计划妥善管理依赖关系。

TypeScript 与外部库

在前面的章节中，我们看到了 TypeScript 如何将 JavaScript 的复杂性封装在面向对象的优点中，现在是时候扩展这种优点并添加一点甜头了。

当今时代，在客户端开发中频繁使用外部库是很常见的，例如著名的 Jquery、Knockout、Toastr，以及最著名的 Angular。TypeScript 在这些库中也扮演着角色，它允许我们使用“声明文件”将这些库作为引用包含在 TypeScript 代码中。

声明文件

声明文件是一种方式，TypeScript 通过它提供了所有特性，如自动完成、类型检查、设计时和编译时类型安全，用于外部库。TypeScript 预装了 DOM（文档对象模型）和 JavaScript API 的定义，例如：

window.onload = function () {
     var t: HTMLElement =    document.getElementById('id'); }

在这里，我们看到在 TypeScript 中，如果我们输入“document”，就会获得关于“document”所有可用方法的智能提示。这有助于我们使用 TypeScript 编写原生 JavaScript，并确保我们遵循每个方法调用的正确结构。

TypeScript 还通过其各自的定义文件支持其他流行库。这些文件扩展名为“*.d.ts”，TypeScript 使用它们来添加设计时支持和编译时检查。这些文件仅包含库支持的所有函数的定义，而不包含任何实现。所有库都可以在 TypeScript Definitions 找到。要访问这些库，我们只需使用“reference comments”包含其对应的“*.d.ts”文件。一旦我们包含此文件，我们将能够访问库的类和函数。例如，如果我们包含 Jquery.d.ts 文件，我们将能够访问“$”函数，并且 TypeScript 还会为所有 Jquery 函数提供智能提示。

/// <reference path="typings/jquery.d.ts" />
    document.title = 'Hello TypeScript';
    $(document).ready(function() {
    var v;
    });

类似地，我们可以使用 Angular 的定义文件在 TypeScript 中编写客户端代码，示例如下：

/// <reference path="../scripts/typings/angularjs/angular.d.ts">
/// <reference path="../scripts/typings/angularjs/angular-route.d.ts">

export class DataService {
        private videos: string[]
        private moviesApiPath: string;
        private categoriesApiPath: string;
        private httpService: ng.IHttpService;  //Note the type ng.IHttpService
        private qService: ng.IQService;        //Note the angular promises

        getAllMovies(fetchFromService?: boolean): ng.IPromise<any> {
            var self = this;

            if (fetchFromService) {
                return getMoviesFromService();
            } else {
                if (self.movies !== undefined) {
                    return self.qService.when(self.videos);
                } else {
                    return getVideosFromService();
                }
            }

摘要

对于 TypeScript 中的每个特性，我们都将其与 OOP 语言（如 C# 和 Java）中的相应特性进行关联，但我们需要牢记 TypeScript 并非 OOP 语言。事实上，TypeScript 只是 JavaScript 之上的一个工具，它为我们提供了更健壮的代码结构和类型安全。TypeScript 提高了编写 JavaScript 代码的开发者的生产力，它本身不提供像 Jquery 这样的库的任何特定功能。

我们在 TypeScript 中使用的许多特性在编译后的 JavaScript 文件中都会被移除，最终我们得到的是纯 JavaScript 代码。TypeScript 是开源的，与微软或 .NET 技术没有任何关系。编写 JavaScript 代码的开发者可以除了 Visual Studio 之外，在 Sublime Text、VIM 等各种 IDE 中使用 TypeScript。TypeScript 存在各种论坛/博客，开发社区也已开始在其各自的库中使用 TypeScript。Resharper 在其 8.0 版本中也提供了对 TypeScript 的支持，这使得开发者能够更轻松地进行重构、创建函数以及使用 Visual Studio 用户所习惯的其他功能。

附录

TypeScript 参考网站

• https://typescript.net.cn/
• http://typescript.codeplex.com/
• http://blogs.msdn.com/b/typescript/archive/2014/04/02/announcing-typescript-1-0.aspx
• http://www.barbarianmeetscoding.com/blog/2013/08/20/learn-typescript-to-improve-your-javascript/
• http://gilamran.blogspot.in/2014/04/typescript-for-javascripters.html

RequireJS 参考网站

• https://requirejs.node.org.cn/

TypeScript 与 Angular 参考网站

• http://www.dotnetcurry.com/showarticle.aspx?ID=1016

Resharper 参考网站

• http://blog.jetbrains.com/dotnet/2014/03/17/more-typescript-support-in-resharper-8-2/

联系我：您可以通过 Twitter @ohri_sachin 联系我