Typescript基础入门

作者: Gukson666 | 来源:发表于2018-06-03 15:57 被阅读586次

    TypeScript 是 JavaScript 的一个超集,主要提供了类型系统对 ES6 的支持,它由 Microsoft 开发,代码开源于 GitHub 上。

    它的第一个版本发布于 2012 年 10 月,经历了多次更新后,现在已成为前端社区中不可忽视的力量,不仅在 Microsoft 内部得到广泛运用,而且 Google 的 Angular2 也使用了 TypeScript 作为开发语言。

    它除了支持最新的 JavaScript 语言特性之外,还增加了非常有用的编译时类型检查特性,而代码又最终会编译成 JavaScript 来执行,非常适合原本使用 JavaScript 来开发的大型项目。

    安装 TypeScript

    TypeScript 的命令行工具安装方法如下:

    npm install -g typescript
    
    

    以上命令会在全局环境下安装 tsc 命令,安装完成之后,我们就可以在任何地方执行 tsc 命令了。

    编译一个 TypeScript 文件很简单:

    tsc hello.ts
    
    

    我们约定使用 TypeScript 编写的文件以 .ts 为后缀。

    编辑器

    TypeScript 最大的优势之一便是增强了编辑器和 IDE 的功能,包括代码补全、接口提示、跳转到定义、重构等。主流的编辑器都支持 TypeScript,这里我推荐使用 Visual Studio Code。它是一款开源,跨终端的轻量级编辑器,内置了 TypeScript 支持。另外它本身也是用 TypeScript 编写的
    结合微软开发的开源代码编辑器 Visual Studio Code,使用 TypeScript 开发项目具有以下优点:

    • 可以使用最新的 ES2017 语言特性
    • 非常精准的代码提示
    • 编辑代码时具有即时错误检查功能,可以避免诸如输错函数名这种明显的错误
    • 非常精准的代码重构功能
    • 非常方便的断点调试功能
    • 编辑器集成调试功能

    下载安装:https://code.visualstudio.com/

    TypeScript 只会进行静态检查,如果发现有错误,编译的时候就会报错。TypeScript 编译的时候即使报错了,还是会生成编译结果,我们仍然可以使用这个编译之后的文件。如果要在报错的时候终止 js 文件的生成,可以在 tsconfig.json 中配置 noEmitOnError 即可。

    TypeScript 中,使用 : 指定变量的类型,: 的前后有没有空格都可以。

    原始数据类型

    • boolean为布尔值类型,如let isDone: boolean = false
    • number为数值类型,如let decimal: number = 6;
    • string为字符串类型,如let color: string = 'blue'
    • 数组类型,如let list: number[] = [ 1, 2, 3 ]
    • 元组类型,如let x: [ string, number ] = [ "hello", 10 ]
    • 枚举类型,如enum Color { Red, Green, Blue }; let c: Color = Color.Green
    • any为任意类型,如let notSure: any = 4; notSure = "maybe a string instead"
      可以认为,声明一个变量为任意值之后,对它的任何操作,返回的内容的类型都是任意值。
      变量如果在声明的时候,未指定其类型,那么它会被识别为任意值类型。
    • void为空类型,如let unusable: void = undefined
    • null和undefined
    let u: undefined = undefined;
    let n: null = null;
    
    • never表示没有值的类型,如function error(message: string): never { throw new Error(message); }
    • 多种类型(联合类型(Union Types))可以用|隔开,比如number | string表示可以是number或string类型
      当 TypeScript 不确定一个联合类型的变量到底是哪个类型的时候,我们只能访问此联合类型的所有类型里共有的属性或方法。

    如果定义的时候没有赋值,不管之后有没有赋值,都会被推断成 any 类型而完全不被类型检查

    接口(interface)

    接口(Interfaces)是一个很重要的概念,它是对行为的抽象,而具体如何行动需要由类(classes)去实现(implements)。

    TypeScript 中的接口是一个非常灵活的概念,除了可用于对类的一部分行为进行抽象以外,也常用于对「对象的形状(Shape)」进行描述。

    以下是接口的几种常见形式:

    // 定义具有 color 和 width 属性的对象
    interface SuperConfug {
      color: string;
      width: number;
    }
    
    // readonly 表示只读,不能对其属性进行重新赋值
    interface Point {
      readonly x: number;
      readonly y: number;
    }
    
    // ?表示属性是可选的,可选属性的含义是该属性可以不存在。仍然不允许添加未定义的属性。
    // [propName: string]: any 表示允许 obj[xxx] 这样的动态属性
    interface SquareConfig {
      color?: string;
      width?: number;
      [propName: string]: any; // 使用 [propName: string] 定义了任意属性取 string 类型的值。
    }
    
    // 函数接口
    interface SearchFunc {
      (source: string, subString: string): boolean;
    }
    

    注意,只读的约束存在于第一次给对象赋值的时候,而不是第一次给只读属性赋值的时候。

    数组

    最简单的方法是使用「类型 + 方括号」来表示数组:
    let fibonacci: number[] = [1, 1, 2, 3, 5];
    数组的项中不允许出现其他的类型:
    let fibonacci: number[] = [1, '1', 2, 3, 5];
    也可以使用数组泛型(Array Generic) Array<elemType> 来表示数组:
    let fibonacci: Array<number> = [1, 1, 2, 3, 5];

    函数

    一个函数有输入和输出,要在 TypeScript 中对其进行约束,需要把输入和输出都考虑到,其中函数声明的类型定义较简单,以下是几种函数接口的定义方式:

    // 普通函数
    function add(a: number, b: number): number {
      return a + b;
    }
    
    // 函数参数
    function readFile(file: string, callback: (err: Error | null, data: Buffer) => void) {
      fs.readFile(file, callback);
    }
    
    // 通过 type 语句定义类型
    type CallbackFunction = (err: Error | null, data: Buffer) => void;
    function readFile(file: string, callback: CallbackFunction) {
      fs.readFile(file, callback);
    }
    
    // 通过 interface 语句来定义类型
    interface CallbackFunction {
      (err: Error | null, data: Buffer): void;
    }
    function readFile(file: string, callback: CallbackFunction) {
      fs.readFile(file, callback);
    }
    

    注意,输入多余的(或者少于要求的)参数,是不被允许的。

    函数表达式

    let mySum: (x: number, y: number) => number = function (x: number, y: number): number {
        return x + y;
    };
    

    注意,不要混淆了 TypeScript 中的 => 和 ES6 中的 =>。
    在 TypeScript 的类型定义中,=> 用来表示函数的定义,左边是输入类型,需要用括号括起来,右边是输出类型。

    在 ES6 中,我们允许给函数的参数添加默认值,TypeScript 会将添加了默认值的参数识别为可选参数

    内置对象

    ECMAScript 标准提供的内置对象有:
    Boolean、Error、Date、RegExp 等。
    我们可以在 TypeScript 中将变量定义为这些类型:

    let b: Boolean = new Boolean(1);
    let e: Error = new Error('Error occurred');
    let d: Date = new Date();
    let r: RegExp = /[a-z]/;
    

    类型别名用来给一个类型起个新名字。
    简单的例子:

    type Name = string;
    type NameResolver = () => string;
    type NameOrResolver = Name | NameResolver;
    function getName(n: NameOrResolver): Name {
        if (typeof n === 'string') {
            return n;
        }
        else {
            return n();
        }
    }
    

    元组

    数组合并了相同类型的对象,而元组(Tuple)合并了不同类型的对象。
    当赋值或访问一个已知索引的元素时,会得到正确的类型:

    let xcatliu: [string, number];
    xcatliu[0] = 'Xcat Liu';
    xcatliu[1] = 25;
    

    当赋值给越界的元素时,它类型会被限制为元组中每个类型的联合类型。

    枚举

    枚举(Enum)类型用于取值被限定在一定范围内的场景,比如一周只能有七天,颜色限定为红绿蓝等。枚举项有两种类型:常数项(constant member)和计算所得项(computed member)。
    常数枚举是使用 const enum 定义的枚举类型:

    const enum Directions {
        Up,
        Down,
        Left,
        Right
    }
    
    let directions = [Directions.Up, Directions.Down, Directions.Left, Directions.Right];
    

    一个典型的计算所得项的例子:
    enum Color {Red, Green, Blue = "blue".length};
    上面的例子中,"blue".length 就是一个计算所得项。上面的例子不会报错,但是如果紧接在计算所得项后面的是未手动赋值的项,那么它就会因为无法获得初始值而报错。

    类的一些概念:

    • 类(Class):定义了一件事物的抽象特点,包含它的属性和方法
    • 对象(Object):类的实例,通过 new 生成
    • 面向对象(OOP)的三大特性:封装、继承、多态
    • 封装(Encapsulation):将对数据的操作细节隐藏起来,只暴露对外的接口。外界调用端不需要(也不可能)知道细节,就能通过对外提供的接口来访问该对象,同时也保证了外界无法任意更改对象内部的数据
    • 继承(Inheritance):子类继承父类,子类除了拥有父类的所有特性外,还有一些更具体的特性
    • 多态(Polymorphism):由继承而产生了相关的不同的类,对同一个方法可以有不同的响应。比如 Cat 和 Dog 都继承自 Animal,但是分别实现了自己的 eat 方法。此时针对某一个实例,我们无需了解它是 Cat 还是 Dog,就可以直接调用 eat 方法,程序会自动判断出来应该如何执行 eat
    • 存取器(getter & setter):用以改变属性的读取和赋值行为
    • 修饰符(Modifiers):修饰符是一些关键字,用于限定成员或类型的性质。比如 public 表示公有属性或方法
    • 抽象类(Abstract Class):抽象类是供其他类继承的基类,抽象类不允许被实例化。抽象类中的抽象方法必须在子类中被实现
    • 接口(Interfaces):不同类之间公有的属性或方法,可以抽象成一个接口。接口可以被类实现(implements)。一个类只能继承自另一个类,但是可以实现多个接口

    TypeScript 的类定义跟 JavaScript 的定义方法类型一样,但是增加了public, private, protected, readonly等访问控制修饰符:

    • public 修饰的属性或方法是公有的,可以在任何地方被访问到,默认所有的属性和方法都是 public 的
    • private 修饰的属性或方法是私有的,不能在声明它的类的外部访问
    • protected 修饰的属性或方法是受保护的,它和 private 类似,区别是它在子类中也是允许被访问的
    class Person {
      protected name: string;
      constructor(name: string) {
        this.name = name;
      }
    }
    
    class Employee extends Person {
      private department: string;
    
      constructor(name: string, department: string) {
        super(name);
        this.department = department;
      }
    
      public getElevatorPitch() {
        return `Hello, my name is ${this.name} and I work in ${this.department}.`;
      }
    }
    

    需要注意的是,这些修饰符仅在 TypeScript 程序中才有效,如果直接使用 JavaScript 是可以在类外部访问到被声明为 private 或者 protocted 的类成员,也可以修改被声明为 readonly 的成员变量。

    如果没有指定访问控制关键字,则默认为 public。

    使用 static 修饰符修饰的方法称为静态方法,它们不需要实例化,而是直接通过类来调用

    class Animal {
        static isAnimal(a) {
            return a instanceof Animal;
        }
    }
    
    let a = new Animal('Jack');
    Animal.isAnimal(a); // true
    a.isAnimal(a); // TypeError: a.isAnimal is not a function
    

    abstract 用于定义抽象类和其中的抽象方法。抽象类是不允许被实例化的,抽象类中的抽象方法必须被子类实现。
    不同类之间可以有一些共有的特性,这时候就可以把特性提取成接口(interfaces),用 implements 关键字来实现。一个类可以实现多个接口,接口与接口之间可以是继承,接口也可以继承类。

    泛型

    泛型(Generics)是指在定义函数、接口或类的时候,不预先指定具体的类型,而在使用的时候再指定类型的一种特性。
    以下是使用泛型的简单例子:

    function identity<T>(arg: T): T {
      return arg;
    }
    
    const map = new Map<string, number>();
    map.set('a', 123);
    
    function sleep(ms: number): Promise<number> {
      return new Promise<number>((resolve, reject) => {
        setTimeout(() => resolve(ms), ms);
      });
    }
    

    我们在函数名后添加了 <T>,其中 T 用来指代任意输入的类型,在后面的输入 arg: T 和输出 T 中即可使用了。
    在 TypeScript 2.3 以后,我们可以为泛型中的类型参数指定默认类型。

    function createArray<T = string>(length: number, value: T): Array<T> {
        let result: T[] = [];
        for (let i = 0; i < length; i++) {
            result[i] = value;
        }
        return result;
    }
    

    编译并执行文件

    大多数时候,为了方便我们可以直接使用 ts-node 命令执行 TypeScript 源文件而不需要预先编译。首先执行以下命令安装 ts-node:
    npm install -g ts-node
    然后使用 ts-node 命令执行即可:
    ts-node --no-cache server.ts
    说明:使用 ts-node 执行 TypeScript 程序时,为了提高编译速度,默认会缓存未修改过的 .ts 文件,但有时候会导致一些 Bug,所以建议启动时加上 --no-cache 参数。

    tsconfig.json 配置文件

    每个 TypeScript 项目都需要一个 tsconfig.json 文件来指定相关的配置,比如告诉 TypeScript 编译器要将代码转换成 ES5 还是 ES6 代码等。以下是我常用的最基本的 tsconfig.json 配置文件:

    {
      "compilerOptions": {
        "module": "commonjs",
        "moduleResolution": "node",
        "target": "es6",
        "rootDir": "src",
        "outDir": "dist",
        "sourceMap": true,
        "noImplicitAny": true,
        "noImplicitReturns": true,
        "noImplicitThis": true
      }
    }
    
    • module和moduleResolution表示这是一个 Node.js 项目,使用 CommonJS 模块机制
    • target 指定将代码编译到 ES6,如果目标执行系统可能有 Node.js v0.x 的版本,可设置编译到 ES5
    • rootDir 和 outDir 指定源码输入目录和编译后的代码输出目录
    • sourceMap 指定编译时生成对应的 SourceMap 文件,这样在调试程序时能快速知道所对应的 TypeScript 源码位置
    • noImplicit 开头的几个选项指定一些更严格的检查

    使用了这个 tsconfig.json 配置文件之后,我们的源码就需要全部放到 src 目录

    补充知识:JSX是一种嵌入式的类似XML的语法。 它可以被转换成合法的JavaScript,尽管转换的语义是依据不同的实现而定的。 JSX因React框架而流行,但也存在其它的实现。 TypeScript支持内嵌,类型检查以及将JSX直接编译为JavaScript。

    使用第三方模块

    一般情况下在 TypeScript 中是不能”直接“使用 npm 上的模块的。由于 TypeScript 项目最终会编译成 JavaScript 代码执行,当我们在 TypeScript 源码中引入这些被编译成 JavaScript 的模块时,它需要相应的声明文件(.d.ts文件)来知道该模块类型信息,这些声明文件可以通过设置tsconfig.json中的declaration: true来自动生成。而那些不是使用 TypeScript 编写的模块,也可以通过手动编写声明文件来兼容 TypeScript。

    为了让广大开发者更方便地使用 npm 上众多非 TypeScript 开发的模块,TypeScript 官方建立了一个名叫 DefinitelyTyped 的仓库,任何人都可以通过 GitHub 在上面修改或者新增 npm 模块的声明文件,经多几年多的发展,这个仓库已经包含了大部分常用模块的声明文件,而且仍然在继续不断完善。当遇到缺少模块声明文件的情况,开发者可以尝试通过 npm install @types/xxx 来安装模块声明文件。

    我们尝试执行以下命令安装 express 模块的声明文件:
    npm install @types/express --save
    成功安装。现在再通过 ts-node 来执行的时候,没有报错。

    如果我们使用的第三方模块在 DefinitelyTyped 找不到对应声明文件,也可以尝试使用require()这个终极的解决方法,它会将模块解析成 any 类型,不好的地方就是没有静态类型检查了。

    typings 声明文件

    编写 .d.ts 文件还是比较繁琐的,比如要完整地给 express 编写声明文件,首先得了解这个模块都有哪些接口,而且 JavaScript 模块普遍接口比较 灵活,同一个方法名可能接受各种各样的参数组合。所以,大多数情况下我们只会定义我们需要用到的接口,下文以 express 模块为例。

    为了验证我们编写的声明文件是否有效,首先执行以下命令将之前安装的声明文件全部删除:
    rm -rf node_modules/@types

    然后新建文件typings/express.d.ts(TypeScript 默认会自动从 typings 目录加载这些 .d.ts 文件):

    declare module 'express' {
    
      /** 定义 express() 函数 */
      function express(): express.Application;
    
      namespace express {
    
        /** 定义 Application 接口 */
        interface Application {
          /** get 方法 */
          get(path: string, handler: (req: Request, res: Response) => void): void;
          /** listen 方法 */
          listen(port: number, callback: () => void): void;
        }
    
        /** 定义 Response 接口 */
        interface Request { }
    
        /** 定义 Response 接口 */
        interface Response {
          end(data: string): void;
        }
    
      }
    
      export = express;
    }
    
    

    说明:

    • 第一行的 declare module 'express' 表示定义 express 这个模块,这样在 TypeScript 中就可以直接 import 'express' 引用
    • 最后一行export = express,并且上面分别定义了一个 function express()namespace express,这种写法是比较特殊的,我一时也没法解释清楚,反正多参照DefinitelyTyped 上其他模块的写法即可。这个问题归根结底是 express 模块通过 import * as express from 'express' 引入的时候,express本身又是一个函数,这种写法在早期的 Node.js 版本的程序和 NPM 模块中是比较流行的,但是在使用 ES6 module 语法后,就显得非常别扭

    TSLint 代码规范检查

    在编写 JavaScript 代码时,我们可以通过 ESLint 来进行代码规范检查,编写 TypeScript 代码时也可以使用 TSLint,两者在配置上也有些相似。对于初学者来说,使用 TSLint 可以知道哪些程序的写法是不被推荐的,从而养成更好的 TypeScript 代码风格。

    首先我们执行以下命令安装 TSLint:
    npm install tslint -g
    然后在项目根目录下新建 TSLint 配置文件 tslint.json:

    {
      "extends": [
        "tslint:recommended"
      ]
    }
    

    这个配置文件指定了使用推荐的 TSLint 配置(tslint:recommended)。然后执行以下命令检查:
    tslint src/**/*.ts
    可以通过修改配置文件 tslint.json 来关闭它:

    {
      "extends": [
        "tslint:recommended"
      ],
      "rules": {
        "no-console": [
          false
        ],
        "only-arrow-functions": [
          false
        ]
      }
    }
    

    以上配置允许使用 console.log 和 function,而字符串使用双引号和圆括号前的空格这两条可以使用 tslint 命令来格式化。执行以下命令检查,并允许 ESLint 尝试自动格式化:
    tslint --fix src/**/*.ts

    发布模块

    相比直接使用 JavaScript 编写的 npm 模块,使用 TypeScript 编写的模块需要增加以下几个额外的工作:

    • 发布前将 TypeScript 源码编译成 JavaScript
    • 需要修改 tsconfig.json 的配置,使得编译时生成模块对应的 .d.ts 文件
    • 在 package.json 文件增加 types 属性

    真有计划发布TypeScript 编写的模块,可以看文末链接 老雷 的文章。这里不做详述。

    单元测试

    要执行使用 TypeScript 编写的单元测试程序,可以有两种方法:

    • 先通过 tsc 编译成 JavaScript 代码后,再执行
    • 直接执行 .ts 源文件

    直接执行 .ts 源文件,下文将以 mocha 为例演示。

    首先执行以下命令安装所需要的模块:
    npm install mocha @types/mocha chai @types/chai ts-node --save-dev
    然后新建单元测试文件 src/test.ts:

    import { expect } from 'chai';
    import { add } from './math';
    
    describe('测试 math', function () {
    
      it('add()', function () {
        expect(add(1, 2)).to.equal(3);
      });
    
    });
    

    修改文件 package.json 在 scripts 中增加 test 脚本:

    {
      "scripts": {
        "test": "mocha --compilers ts:ts-node/register src/test.ts"
      }
    }
    

    说明:通过 mocha 命令的 –compilers 选项指定了 .ts 后缀的文件使用 ts-node 的钩子函数来预编译。

    然后执行以下命令测试:
    npm test
    可以看到以下结果:

      测试 math
        ✓ add()
    
      1 passing (8ms)
    

    JavaScript 项目渐进式迁移

    要将一个已有的 JavaScript 项目迁移到 TypeScript 之上,往往会遇到以下几个问题:

    • 项目代码太多,无法短时间内将源码从 JavaScript 改写为 TypeScript,两者需要共存一段时间
    • 依赖的第三方库没有 .d.ts 文件
    • 原 JavaScript 代码使用了很多的动态特性,无法简单转换代码

    针对以上第一个问题,tsconfig.json 文件中有一个 allowJs 选项,将其设置为 true 后即可支持在 TypeScript 代码中直接 import JavaScript 代码,并且具有一定的静态检查能力。以下是一个简单的例子:

    首先新建配置文件 tsconfig.json

    {
      "compilerOptions": {
        "module": "commonjs",
        "moduleResolution": "node",
        "target": "es6",
        "rootDir": "src",
        "outDir": "dist",
        "sourceMap": true,
        "allowJs": true,
        "noImplicitAny": true,
        "noImplicitReturns": true,
        "noImplicitThis": true
      }
    }
    
    

    然后新建 TypeScript 文件 src/main.ts

    import * as utils from './utils';
    
    console.log(utils.add(1, 2));
    
    

    新建 JavaScript 文件 src/utils.js

    exports.add = function (a, b) {
      return a + b;
    };
    
    

    执行 tsc 命令即可看到 dist 目录生成了对应的 dist/utils.jsdist/main.js 文件。如果去掉 allowJs 选项,则编译时会报错:

    src/main.ts(1,24): error TS6143: Module './utils' was resolved to '/tmp/src/utils.js', but '--allowJs' is not set.
    

    在实际项目中,可以先从一个 JavaScript 文件入手,将其后缀改为 .ts,然后再逐步更改项目下所有文件。

    针对缺少 .d.ts 文件的问题,可以参照上文 编写 typings 声明文件 一节,自行编写必要的 .d.ts 文件。

    而对于以上第三个问题,可以将变量类型声明为 any,这实际上是“取消”了针对该变量的静态检查,可以像 JavaScript 一样随意赋值。

    当然,从 JavaScript 迁移到 TypeScript 还有很多细节,具体可以参考这篇文章:《从 JavaScript 迁移到 TypeScript》

    在 Webpack 中使用

    Webpack 是当前最流行的前端构建工具之一,要在 Webpack 中使用 TypeScript 可以通过 ts-loader 模块来实现。

    首先全局安装 webpack 命令:
    npm install webpack -g
    然后执行以下命令安装 ts-loader 和 typescript 模块:
    npm install ts-loader typescript --save-dev
    新建 Webpack 配置文件 webpack.config.js:

    module.exports = {
      entry: './app.ts',
      output: {
        filename: 'bundle.js',
      },
      resolve: {
        extensions: [ '.ts', '.tsx', '.js' ],
      },
      module: {
        loaders: [
          {
            test: /\.tsx?$/,
            loader: 'ts-loader',
          }
        ],
      },
    };
    

    然后新建 TypeScript 配置文件 tsconfig.json:

    {
      "compilerOptions": {
        "module": "commonjs",
        "moduleResolution": "node",
        "target": "es6",
        "noImplicitAny": true,
        "noImplicitReturns": true,
        "noImplicitThis": true
      }
    }
    

    现在我们来新建 TypeScript 入口程序文件 app.ts:

    function add(a: number, b: number): number {
      return a + b;
    }
    
    const v = [ 1, 2, 3, 4, 5, 6].reduce(add);
    console.log(v);
    

    即可执行 webpack 命令编译代码,其结果如下:

    webpack
    
    ts-loader: Using typescript@2.3.4 and /tmp/tsconfig.json
    Hash: af9d997c471a89158065
    Version: webpack 3.0.0
    Time: 868ms
        Asset     Size  Chunks             Chunk Names
    bundle.js  2.57 kB       0  [emitted]  main
       [0] ./app.ts 99 bytes {0} [built]
    

    此时可见到生成了目标文件 bundle.js。

    推荐一些开源项目,进一步学习TypeScript:

    • Visual Studio Code ,微软开源的跨平台代码编辑器
    • AngularJS 2,谷歌开源的用于构建跨平台 Web 应用的开发框架
    • TSLint,一款 TypeScript 代码规范检查工具
    • Ant Design,一套企业级的 UI 设计语言和 React 实现

    参考书籍

    相关文章

      网友评论

      • confus:看起来语法有点oc的味道

      本文标题:Typescript基础入门

      本文链接:https://www.haomeiwen.com/subject/zwunpxtx.html