[NestJS] 大前端Node层应用框架 之 NestJS英文官方文档解读笔记 （持续跟新ing

前言

公司的项目使用了大前端技术，大前端做为中间层，整合了服务端的接口，也缩短了前端的开发等待接口的空窗期。全部的mock数据在node层生成供调试，使前端开发造成了闭环。而node层所运用的框架中，nest是一个很是高效、好用的框架。

• 本文做为学习nest框架的一篇笔记，对英文官方文档进行了直译、意译和理解。
• 若有错误欢迎及时指正并修改。

介绍

• NestJS是一个为了构建高效、可扩展的服务端应用框架。它运用了渐进式javascript，使用而且彻底支持Typescript，结合了面向对象编程OOP、函数式编程FP、函数式响应编程FRP。
• 在Nest底层也运用了强大的HTTP服务框架例如Express(默认)，和Fastify(可配置)。
• Nest在这些经常使用的HTTP框架之上提供了一个抽象层，但也直接暴露了他们本身的API给开发者。这也容许开发者自由地使用无数原先平台就可使用的第三方模块(中间件)。

安装

• 开始一个nest，可使用脚手架Nest CLI，也能够clone一个初始项目

$ npm i -g @nestjs/cli
$ nest new project-name
复制代码

or

$ git clone https://github.com/nestjs/typescript-starter.git project
$ cd project
$ npm install
$ npm run start
复制代码

• 手动建立

$ npm i --save @nestjs/core @nestjs/common rxjs reflect-metadata
复制代码

控制器

控制器

• 控制器负责处理收到的请求而且返回响应给客户端
• 控制器的目的是接受应用的具体请求。路由决定了哪个控制器接受哪些请求。一般控制器都会至少两个路由，不一样的路由能够执行不一样的动做。
• 建立一个控制器须要使用类class和装饰器decorator

路由

• 建立一个基本的控制器须要使用装饰器@Controller，下例规定了路由前缀cat传入控制器。如此一来咱们能够轻松地将一系列路由归为一组，减小了重复代码。后面全部路由都会在/cats之下。

import { Controller, Get } from '@nestjs/common';

@Controller('cats')
export class CatsController {
  @Get()
  findAll(): string {
    return 'This action returns all cats';
  }
}
复制代码

• 建立控制器可使用脚手架指令$ nest g controller cats
• @Get()告诉Nest须要为HTTP的get请求建立一个处理函数。
• 此例中，Nest路由了一个get请求到findAll方法，而此方法名彻底是随意的（显然咱们必需为路由绑定一个处理函数，然而Nest历来不关心这个函数的名字到底叫什么）。而且这个方法将会返回一个200的状态码和对应的响应数据（此例为字符串）。

  Nest使用了两个不一样的配置来操做处理函数的响应

standard（标准的）	此配置使用内置的方法，当函数返回了一个对象或数组会自动转为JSON格式，而返回字符时不会转换。这使得返回值处理十分简单，而Nest只关注剩余的部分。
Library-specific（规定库的）	使用此配置能够经过在函数签名中注入@Res()装饰器来获取库的(Express)request对象(findAll(@Res() response))，这样也就可使用原生的request对象暴露的API进行处理。例如response.status(200).send()

不能够同时使用上述两种方法，当Nest监测到你使用了@Res()或者@Next()时，那么代表你选择了Library-specific项。二者同时使用时Nest会自动禁用standard项，而形成不可预期的后果。

request对象

• 处理函数一般须要获取客户端请求的详细信息，Nest提供了底层库的request对象(默认Express)。
• 方法是在处理函数签名中注入@Req()装饰器

import { Controller, Get, Req } from '@nestjs/common';
import { Request } from 'express';

@Controller('cats')
export class CatsController {
  @Get()
  findAll(@Req() request: Request): string {
    return 'This action returns all cats';
  }
}
复制代码

ps: 为了使用Express的类型能够安装`@types/express`包
复制代码

• request对象表明了Http请求，包含许多属性：query string、parameters、HTTP headers。大可能是状况下这些属性不用咱们手动去调用，可使用专门的装饰器。例如@Body()或@Query()。

@Request()	req
@Response()	res*
@Next()	next
@Session()	req.session
@Param(key?: string)	req.params / req.params[key]
@Body(key?: string)	req.body / req.body[key]
@Query(key?: string)	req.query / req.query[key]
@Headers(name?: string)	req.headers / req.headers[name]

* 因为Library-specific的存在，会有两种风格的Resquest对象。standard模式使用@Request()装饰器，而底层库的request对象使用@Req()装饰器获取，并确保理解他们的不一样。

资源

• 前面咱们经过Get请求来获取了cat的资源，如今咱们也但愿去建立一个新的cat记录。使用post。

import { Controller, Get, Post } from '@nestjs/common';

@Controller('cats')
export class CatsController {
  @Post()
  create(): string {
    return 'This action adds a new cat';
  }

  @Get()
  findAll(): string {
    return 'This action returns all cats';
  }
}
复制代码

• Nest提供了一样风格的其余HTTP请求方式，@Put()、@Delete()、@Patch()、@Options()、@Head()、 @All()

路由通配符

• *号通配符能够在路由中使用，能够匹配任意字符的结合

@Get('ab*cd')
findAll() {
  return 'This route uses a wildcard';
}
复制代码

• 上例能够匹配abcd, ab_cd, abecd等等
• 正则表达式，以及其余符号?、+、*、()都可使用

• The hyphen ( -) and the dot (.) are interpreted literally by string-based paths.

状态码

• 处理函数响应的状态码老是默认为200，post例外为201
• 可使用装饰器@HttpCode(...)指定状态码

@Post()
@HttpCode(204)
create() {
  return 'This action adds a new cat';
}
复制代码

• 一般状态码不是静态，而是由多种因素来决定的。在这种状况下你可使用Library-specific模式的response对象

请求头

• 想要规定一个自定义的响应头，可使用装饰器@Header()或者Library-specific模式的res对象

@Post()
@Header('Cache-Control', 'none')
create() {
  return 'This action adds a new cat';
}
复制代码

路由参数

• 若是须要接受动态的数据做为请求地址的一部分，静态地址的路由将不会工做。（动态路由参数）
• 例如Get /cats/1 来获取id=1的Cat资源
• 使用装饰器@Param()来获取动态路由参数

@Get(':id')
findOne(@Param() params): string {
  console.log(params.id);
  return `This action returns a #${params.id} cat`;
}
复制代码

• 也能够传入特定的参数给装饰器，来直接经过名称获取路由参数。

@Get(':id')
findOne(@Param('id') id): string {
  return `This action returns a #${id} cat`;
}
复制代码

路由顺序

• 请注意路由顺序，当以前使用了动态路由参数进行截获，则以后就不会命中不使用动态参数的静态同级路由。

@Controller('cats')
export class CatsController {
  @Get(':id')
  findOne(@Param('id') id: string) {
    return `This action returns a #${id} cat`;
  }

  @Get()
  findAll() {
    // 此节点将不会命中，由于/cats请求将被/cats:id请求所截获
  }
}
复制代码

做用域

• 因为读者来自不一样的编程语言背景，学习此块内容是不被指望的，几乎全部的东西都经过收到的request请求共享了。咱们有一个链接池，链接到了数据库、具备全局状态的单例服务等。记住Node并无遵循多线程无状态的请求/响应模式，全部的请求都为单线程处理。所以使用单例对象对于应用来更加安全。

异步性

• 数据获取几乎都是异步的，而Nest支持异步async函数。
• 每一个异步async函数都返回一个Promise对象，也就是你能够返回一个延迟的值，Nest将会本身处理。

@Get()
async findAll(): Promise<any[]> {
  return [];
}
复制代码

• 也可使用RxJS

请求的负载

• 若是使用了Typescript，那么须要定义一个DTO文件(Data Transfer Object)。DTO文件定义了数据在网络中的传输形式。可使用Typescript的interface或者简单的一个类来定义DTO文件。建议使用类来定义，由于类是ES6的一部分，他们在js编译的过程当中是受保护的实体信息，而interface在转译为js的过程当中会被移除，Nest在运行过程当中获取不到它们。这很重要，由于一些特性，例如管道，在运行时可能会使变量的类型改变。

export class CreateCatDto {
  readonly name: string;
  readonly age: number;
  readonly breed: string;
}
复制代码

@Post()
async create(@Body() createCatDto: CreateCatDto) {
  return 'This action adds a new cat';
}
复制代码

完整的例子

import { Controller, Get, Query, Post, Body, Put, Param, Delete } from '@nestjs/common';
import { CreateCatDto, UpdateCatDto, ListAllEntities } from './dto';

@Controller('cats')
export class CatsController {
  @Post()
  create(@Body() createCatDto: CreateCatDto) {
    return 'This action adds a new cat';
  }

  @Get()
  findAll(@Query() query: ListAllEntities) {
    return `This action returns all cats (limit: ${query.limit} items)`;
  }

  @Get(':id')
  findOne(@Param('id') id: string) {
    return `This action returns a #${id} cat`;
  }

  @Put(':id')
  update(@Param('id') id: string, @Body() updateCatDto: UpdateCatDto) {
    return `This action updates a #${id} cat`;
  }

  @Delete(':id')
  remove(@Param('id') id: string) {
    return `This action removes a #${id} cat`;
  }
}
复制代码

• 控制器一般都属于一个模块，咱们要在装饰器@Module()中包含controllers数组
• 启动时，须要在模块上挂载定义的控制器，不然Nest根本不知道他们的存在。。。

import { Module } from '@nestjs/common';
import { CatsController } from './cats/cats.controller';

@Module({
  controllers: [CatsController],  // 数组
})
export class AppModule {}
复制代码

---

供应者

供应者Provider（依赖）

• 供应者在Nest中一是一个基本的概念。许多基础的Nest类均可以看做供应者——服务、库、工厂、工具等等。供应者主要的目的是注入依赖。这意味着对象之间能够建立多种依赖关系，对象上实例方法的预编译能够委托给Nest的运行系统。供应者Provider是一个简单的使用了装饰器@Injectable()的类。

• 在前面的章节，咱们建立了一个简单的控制器CatController。控制器应只处理HTTP请求，而将其余复杂的业务交给供应者来处理。
  
  ps：尽管Nest支持用一种更加面向对象的方式来设计组织依赖，但咱们强烈建议遵循SOLID原则。（面向对象设计的五大原则）

服务

• 建立一个简单的服务，来负责数据的存储和检索，最后由控制器来调用。

import { Injectable } from '@nestjs/common';
import { Cat } from './interfaces/cat.interface';

@Injectable()
export class CatsService {
  private readonly cats: Cat[] = [];

  create(cat: Cat) {
    this.cats.push(cat);
  }

  findAll(): Cat[] {
    return this.cats;
  }
}
复制代码

ps: 可使用脚手架命令nest g service cat来建立服务。

• 咱们的CatService是拥有一个属性两个方法的基本的类，新的特征就是使用了装饰器@Injectable()。附带了元数据来告诉Nest这个类是一个Nest的提供者。顺带一提，此例也使用了一个Cat接口，也许长这样。

export interface Cat {
  name: string;
  age: number;
  breed: string;
}
复制代码

• 如今咱们拥有了一个服务的类来检索Cats，将它应用到控制器上

import { Controller, Get, Post, Body } from '@nestjs/common';
import { CreateCatDto } from './dto/create-cat.dto';
import { CatsService } from './cats.service';
import { Cat } from './interfaces/cat.interface';

@Controller('cats')
export class CatsController {
  constructor(private readonly catsService: CatsService) {}

  @Post()
  async create(@Body() createCatDto: CreateCatDto) {
    this.catsService.create(createCatDto);
  }

  @Get()
  async findAll(): Promise<Cat[]> {
    return this.catsService.findAll();
  }
}
复制代码

• CatService服务经过类的构造器来注入，注意private readonly语法，这种表达式能够在马上这个位置同时声明并初始化成员(TS语法糖)。

依赖注入

• Nest是围绕你们所熟知的依赖注入而构建的，关于其概念咱们建议阅读Auglar的官方文档。
• 在Nest中，因为Typescript的存在，管理依赖是很是简单的，由于他们经过类型来解析。在下面的例子中，Nest将经过建立并返回一个CatService实例来解析CatService（正常状况下是一个单例对象，若是在别的地方中被请求过，则返回已经存在实例）。依赖解析成功并传入控制器的构造函数（或者传给已经声明的属性）。

constructor(private readonly catsService: CatsService) {}
复制代码

做用域（生命周期）

• 一个提供者Provider的生命周期（做用域）与应用的声明周期同步。当应用建立时，全部的依赖必须被解析，所以每一个提供者也必须被实例化。同理，当应用关闭时，每一个提供者将会销毁。固然你也可使你提供者的生命周期在你的所需范围内。点击这里来阅读此技巧

自定义化提供者

• Nest有一个内置的控制反转（面向对象设计原则，下降耦合性）的容器来处理两个提供者间的关系。该特性是构成上述的依赖注入的基础，但实际上它比咱们所描述的还要强大得多。装饰器@Injectable()只是冰山一角，而且也不是定义供应者的惟一方式。实际上你可使用简单的值、类、甚至是同步或异步的工厂。点击这里阅读更多案例

可选的提供者

• 有时候你可能有一些依赖并不须要去解析他。举个🌰，你的类也许依赖于一个配置对象，可是若是没有任何入参，应使用默认值。这种状况下提供者变为可选的，并且缺乏配置的提供者也不会报错。

import { Injectable, Optional, Inject } from '@nestjs/common';

@Injectable()
export class HttpService<T> {
  constructor(
    @Optional() @Inject('HTTP_OPTIONS') private readonly httpClient: T
  ) {}
}
复制代码

• 注意上面的例子使用的是自定义提供者，由于使用了HTTP_OPTIONS标识。前面的例子显示了基于构造器的注入，它经过构造函数中的类指示依赖关系。点击这里阅读更多关于自定义提供者而相关标识

以属性为基础的注入

• 目前为止咱们使用的都是以构造器为基础的注入，提供者经过构造函数被注入。在一些特定状况下，以属性为基础的注入会更加有用。例如，一个顶层的类依赖于一个或多个提供者，而子类始终经过super来继承父类引用的Provider是很是"单调乏味"的。为了不这种状况，你能够在属性层使用装饰器@Inject()。

import { Injectable, Inject } from '@nestjs/common';

@Injectable()
export class HttpService<T> {
  @Inject('HTTP_OPTIONS')
  private readonly httpClient: T;
}
复制代码

若是你的类中没有使用另外的提供者，你应该始终使用以构造器为基础的注入

注册提供者

• 如今咱们有了一个提供者CatService，咱们须要将它注册到控制器上才能实现注入。在@Module()模块中加入你的服务CatService到提供者Providers数组。

import { Module } from '@nestjs/common';
import { CatsController } from './cats/cats.controller';
import { CatsService } from './cats/cats.service';

@Module({
  controllers: [CatsController],
  providers: [CatsService],
})
export class AppModule {}
复制代码

• 这样一来，Nest就能够处理控制器的提供者们之间的依赖关系了。

---

模块

模块

• 模块是一个使用装饰器@Module()的类，装饰器提供元数据给Nest来组织应用结构。

• 每一个应用至少有一个根模块。根模块是Nest绘制应用结构的起点，Nest利用内部的数据结构来解析模块、依赖、以及提供者间的关系。理论上来讲，很是小的应用也许只由一个根模块，但这不是典型例子。咱们想要强调，模块是强烈推荐的一个高效的方式去组织你的组件。因此绝大多数应用将使用多个模块，每一个模块涵盖了一系列相关的功能。
• 使用@Module()装饰一个对象，属性用来描述这个模块。

供应者Provider	供应者将会被Nest实例化，而且这些供应者至少在当前模块中是共享的
控制器Controller	这个属性定义了在当前模块中哪些控制器将会被实例化
输入imports	引入模块的列表，引入了其余模块导出的在此模块中须要使用的提供者
输出exports	此模块所使用的提供者的子集，导出的提供者在导入此模块的其余模块中可用

• 模块默认包含了提供者Provider，这意味着你若是想注入一个既不是当前模块一部分的提供者，也不是导入的模块所导出的提供者，是不可能的。这样一来，你就要考虑从一个模块中导入一些提供者，做为模块的公共接口或者API。（一个公共模块）

特征模块

• 控制器CatsController和服务CatsService是应用的同一块区域，他们应该放入特征模块中。

import { Module } from '@nestjs/common';
import { CatsController } from './cats.controller';
import { CatsService } from './cats.service';

@Module({
  controllers: [CatsController],
  providers: [CatsService],
})
export class CatsModule {}
复制代码

ps: 可使用脚手架指令nest g module cats来建立模块。

• 上面，咱们定义了CatsModule在cats.module.ts文件中。而后将全部相关的文件放统一目录下。最后将它导出到根模块就能够了。

import { Module } from '@nestjs/common';
import { CatsModule } from './cats/cats.module';

@Module({
  imports: [CatsModule],
})
export class AppModule {}
复制代码

• 而后结构目录看起来像这样

共享模块

• 在Nest中，模块默认是一个单例对象，而且你能够轻松的在任何提供者之间共享同一个实例。

• 每一个模块自动的成为共享模块，只要建立就能够被任意其余模块重用。想像一下若是须要在其余几个模块中共享一个CatService服务的实例，咱们须要经过在模块中增长exports属性来导出提供者CatService。

import { Module } from '@nestjs/common';
import { CatsController } from './cats.controller';
import { CatsService } from './cats.service';

@Module({
  controllers: [CatsController],
  providers: [CatsService],
  exports: [CatsService]
})
export class CatsModule {}
复制代码

• 如今任何其余模块只要引入CatModule模块，就能共享同一个服务实例。

模块重导出

• 如上所述，模块能够导出他们内部的提供者，此外他们还能够将引入的模块从新导出。那么其余模块引入了该模块时，同时可使用该模块重导出的模块共享的提供者。

@Module({
  imports: [CommonModule],
  exports: [CommonModule],
})
export class CoreModule {}
复制代码

依赖注入

• 模块的类也能够引入提供者

import { Module } from '@nestjs/common';
import { CatsController } from './cats.controller';
import { CatsService } from './cats.service';

@Module({
  controllers: [CatsController],
  providers: [CatsService],
})
export class CatsModule {
  constructor(private readonly catsService: CatsService) {}
}
复制代码

• 然而模块的类自身不能做为提供者被本身引入造成循环依赖（本身依赖本身）

全局模块

• 若是你处处引入同一个模块是“单调乏味的”。不像在Nest中，Augular的提供者注册在全局做用域下，只要定义，哪里均可以用。然而Nest将提供者包含在模块的做用域下，别的地方没法使用没有导出的提供者。
• 若是你想在哪里均可以使用一些提供者，使用装饰器@Global()

import { Module, Global } from '@nestjs/common';
import { CatsController } from './cats.controller';
import { CatsService } from './cats.service';

@Global()
@Module({
  controllers: [CatsController],
  providers: [CatsService],
  exports: [CatsService],
})
export class CatsModule {}
复制代码

• 装饰器@Global()使该模块在全局做用域下。全局模块应只被注册一次在核心模块或者根模块当中。在上例中，其余模块使用服务CatService时，不用再引入该模块。

ps: 不要处处使用全局模块，他只是为了减小大量的必需引入。大多数状况下更好的方式是使用imports。

动态模块

• Nest的模块系统中包含了一个特性叫作动态模块，它能轻易地使你建立一个自定义模块。下面是一个动态模块的例子，DatabaseModule

import { Module, DynamicModule } from '@nestjs/common';
import { createDatabaseProviders } from './database.providers';
import { Connection } from './connection.provider';

@Module({
  providers: [Connection],
})
export class DatabaseModule {
  static forRoot(entities = [], options?): DynamicModule {
    const providers = createDatabaseProviders(options, entities);
    return {
      module: DatabaseModule,
      providers: providers,
      exports: providers,
    };
  }
}
复制代码

ps：forRoot()方法可能会同步或异步地返回一个动态模块。（经过Promise

• 这个模块定义了一个默认的Provider叫作Connection，依赖于传入的entities和options对象，暴露了一个提供者provider的集合，好比库。记住动态模块扩展（而非重载）了基础模块的元数据。这就是从模块导出静态声明的提供者Connection和动态配置库的提供者的方式。
• 当你须要动态地注册并配置你的提供者Providers时，这个重要的特性是很是有用的。只要用这种方式定义，DatabaseModule模块就能以以下的方式导出并配置。

import { Module } from '@nestjs/common';
import { DatabaseModule } from './database/database.module';
import { User } from './users/entities/user.entity';

@Module({
  imports: [DatabaseModule.forRoot([User])],
})
export class AppModule {}
复制代码

• 若是你想反过来重导出一个动态模块，你能够在导出数组中，删除forRoot()函数的调用

import { Module } from '@nestjs/common';
import { DatabaseModule } from './database/database.module';
import { User } from './users/entities/user.entity';

@Module({
  imports: [DatabaseModule.forRoot([User])],
  exports: [DatabaseModule],
})
export class AppModule {}
复制代码

中间件

中间件

• 中间件是一个函数，在路由处理函数以前被调用。中间件函数接收了request和response对象还有管道函数next()。

• 中间件函数能够完成如下任务

  1. 运行任何代码
  2. 修改request、response对象
  3. 结束request-response循环
  4. 栈中调用next函数
  5. 若是当前中间件没有结束request-response循环，即必须调用next函数将控制权交给下个中间件函数。不然请求会一直处于挂起状态

• 你能够用任何一个函数或者使用了装饰器@Injectable的类实现中间件。若是是类应当实现NestMiddleware接口，而函数不须要任何特殊的需求。让咱们使用类来实现一个简单的中间件。

import { Injectable, NestMiddleware } from '@nestjs/common';
import { Request, Response } from 'express';

@Injectable()
export class LoggerMiddleware implements NestMiddleware {
  use(req: Request, res: Response, next: Function) {
    console.log('Request...');
    next();
  }
}
复制代码

依赖注入

• Nest中间件彻底支持依赖注入，就像提供者或控制器，他们能够注入在同一个模块中可用的依赖。一般是经过constructor来实现。

应用中间件

• 在装饰器@Modules()中没有中间件的位置，取而代之咱们使用模块类中的configure()函数来设置他们。包含中间件的模块必须实现NestModule的接口。让咱们在根模块上设置一个LoggerMiddleware的中间件。

import { Module, NestModule, MiddlewareConsumer } from '@nestjs/common';
import { LoggerMiddleware } from './common/middleware/logger.middleware';
import { CatsModule } from './cats/cats.module';

@Module({
  imports: [CatsModule],
})
export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer
      .apply(LoggerMiddleware)
      .forRoutes('cats');
  }
}
复制代码

• 在上面的例子中咱们为在CatsController中定义的路由/cats的处理函数以前设置了中间件LoggerMiddleware。 当咱们在配置中间件时，经过传入一个包含路由path和request方法的对象给forRoutes()来将中间件函数限制为一个特定的路由。在下面的例子中，注意咱们引入了枚举类型RequestMethod，断言请求方法的类型。

import { Module, NestModule, RequestMethod, MiddlewareConsumer } from '@nestjs/common';
import { LoggerMiddleware } from './common/middleware/logger.middleware';
import { CatsModule } from './cats/cats.module';

@Module({
  imports: [CatsModule],
})
export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer
      .apply(LoggerMiddleware)
      .forRoutes({ path: 'cats', method: RequestMethod.GET });
  }
}

复制代码

路由通配符

• 支持基于模式的路由。举个例子，*做为通配符能够匹配任意字符结合。

forRoutes({ path: 'ab*cd', method: RequestMethod.ALL });
复制代码

中间件Consumer

• MiddlewareConsumer是一个辅助类，它提供了一些内置的方法来管理中间件。他们均可以简单地使用用链式风格连接起来。forRoutes()方法可使用单个字符串，多字符串，一个RouteInfo对象，一个控制器Controller的类，或者甚至是多个控制器的类。大多数状况下你可能会传入一个用逗号分割的控制器的列表。下面的例子是单个控制器。

import { Module, NestModule, MiddlewareConsumer } from '@nestjs/common';
import { LoggerMiddleware } from './common/middleware/logger.middleware';
import { CatsModule } from './cats/cats.module';

@Module({
  imports: [CatsModule],
})
export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer
      .apply(LoggerMiddleware)
      .forRoutes(CatsController);
  }
}
复制代码

ps：apply()方法接受一个中间件，或者多个中间件参数。

• 咱们常常想要在中间件应用中排除某个特定的路由。当用类来定义中间件时（正如咱们到目前为止所作的，而不是使用可替代的函数中间件），咱们可使用exclude()方法来排除某个特定的路由。这个方法接受一个一个或多个对象来匹配须要排除路由path和方法。

consumer
  .apply(LoggerMiddleware)
  .exclude(
    { path: 'cats', method: RequestMethod.GET },
    { path: 'cats', method: RequestMethod.POST }
  )
  .forRoutes(CatsController);
复制代码

• 经过上面的例子，中间件LoggerMiddleware会绑定在CatsController中全部的路由，除了传入exclude()方法的两个对象。请记住exclude()方法在函数中间件中没有做用。此外，exclude方法不会排除那些来自更通用的路由。（好比说通配符）。若是你须要那种级别上的控制，你应当把你路由限制的逻辑直接放在中间件中。例如：接受路由请求而且有条件地应用中间件的逻辑。

函数中间件

• 咱们用的LoggerMiddleware类仍是很是简单。他没有成员，没有额外的方法，没有依赖。为何咱们不定义一个简单的函数而不是一个类呢。让咱们将它从类中间件转换为函数中间件。

export function logger(req, res, next) {
  console.log(`Request...`);
  next();
};
复制代码

• 而后在根路由中去使用它。

consumer
  .apply(logger)
  .forRoutes(CatsController);
复制代码

ps: 考虑只在不须要任何依赖的状况下使用函数中间件。

多个中间件

• 上面提到的，为了绑定多个中间件并依次执行，只须要提供一个逗号分割的apply()方法的调用。

consumer.apply(cors(), helmet(), logger).forRoutes(CatsController);
复制代码

全局中间件

• 若是咱们想当即在每一个注册的路由上绑定中间件，咱们可使用由INestApplication接口提供的use()方法。

const app = await NestFactory.create(AppModule);
app.use(logger);  // 就像Express
await app.listen(3000);
复制代码

---

异常过滤器

异常过滤器

• Nest有一个异常层，负责处理整个应用中全部未处理过的异常。当你一个异常没有被你的应用的代码处理，他就会被这一层捕获。而后自动发送合适的用户友好型响应。

• 这个动做由一个内置的全局异常过滤器完成，处理了HttpException类型的异常(及其子类)。当一个异常未被识别(既不是HttpException也不是继承自HttpException的类)，客户端会接受到以下的JSON的响应。

{
  "statusCode": 500,
  "message": "Internal server error"
}

复制代码

底层异常

• 内置的Http异常的类经过@nestjs/common包暴露。
• 在CatsController中，咱们有一个findAll()函数(一个Get路由请求)。假设这个函数由于一些缘由抛出了一个异常。

@Get()
async findAll() {
  throw new HttpException('Forbidden', HttpStatus.FORBIDDEN);
}
复制代码

ps: 咱们这里使用Http状态码，是由@nestjs/common导入的辅助枚举类型。

• 当客户端请求这个节点，响应看起来像这样

{
  "statusCode": 403,
  "message": "Forbidden"
}
复制代码

• HttpException的构造函数接受两个参数，决定了JSON格式的响应体和各自Http响应的状态码。第一个参数是一个类型：string | object。传入一个字符来自定义错误信息。传入一个属性为status和error的字面量对象为第一个参数而不是字符，来彻底重载响应体。第二个参数应该是一个实际的Http状态码。

@Get()
async findAll() {
  throw new HttpException({
    status: HttpStatus.FORBIDDEN,
    error: 'This is a custom message',
  }, 403);
}
复制代码

而后响应像这样

{
  "statusCode": 403,
  "error": "This is a custom message"
}
复制代码

异常结构

• 建立本身的异常结构是一个很好的实践。这意味着你的Http异常应当继承自基础的HttpException类。结果是Nest将辨识你的异常，自动处理异常的响应。

export class ForbiddenException extends HttpException {
  constructor() {
    super('Forbidden', HttpStatus.FORBIDDEN);
  }
}
复制代码

• 因为ForbiddenException继承自HttpException，他将和内置的异常处理函数无缝衔接，因此咱们能够在findAll()函数中使用

@Get()
async findAll() {
  throw new ForbiddenException();
}
复制代码

Http Exceptions

• 为了减小咱们所写的重复的代码，Nest提供了一系列有用的继承自HttpException的异常。他们都由@nestjs/common包暴露
  • BadRequestException
  • UnauthorizedException
  • NotFoundException
  • ForbiddenException
  • NotAcceptableException
  • RequestTimeoutException
  • ConflictException
  • GoneException
  • PayloadTooLargeException
  • UnsupportedMediaTypeException
  • UnprocessableEntityException
  • InternalServerErrorException
  • NotImplementedException
  • BadGatewayException
  • ServiceUnavailableException
  • GatewayTimeoutException

异常过滤器

• 内置的异常过滤器能够自动地为你处理大部分状况，可是您可能想要彻底控制异常层。例如你想加入logging或者因为一些动态的因素返回不一样的JSON结构的响应。异常过滤器为这个目的而设计。
• 让咱们建立一个异常过滤器来捕获继承自HttpException的异常，而且为他们实现了自定义响应的逻辑。

import { ExceptionFilter, Catch, ArgumentsHost, HttpException } from '@nestjs/common';
import { Request, Response } from 'express';

@Catch(HttpException)
export class HttpExceptionFilter implements ExceptionFilter {
  catch(exception: HttpException, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const response = ctx.getResponse<Response>();
    const request = ctx.getRequest<Request>();
    const status = exception.getStatus();

    response
      .status(status)
      .json({
        statusCode: status,
        timestamp: new Date().toISOString(),
        path: request.url,
      });
  }
}
复制代码

ps: 全部异常过滤器都必须实现ExceptionFilter<T>接口。这须要你提供catch(exception: T, host: ArgumentsHost)方法和签名。T代表了异常的类型。

• @Catch(HttpException)装饰器为一场过滤器绑定了所需的元数据，告诉Nest这个过滤器正在寻找HttpException类型的异常。@Catch()装饰器接受一个参数，或者一个逗号分割的列表。这使你能够一次性设置多种不一样类型的异常。

接口Arguments host

• 让咱们看一看catch()方法的参数，exception参数是当前正在处理的异常对象，而host是一个ArgumentsHost对象。ArgumentsHost是传递给原始请求处理函数的参数的包装器（异常初始化的地方），包含了一个基于应用类型的特定的数组。

export interface ArgumentsHost {
  getArgs<T extends Array<any> = any[]>(): T;
  getArgByIndex<T = any>(index: number): T;
  switchToRpc(): RpcArgumentsHost;
  switchToHttp(): HttpArgumentsHost;
  switchToWs(): WsArgumentsHost;
}
复制代码

• ArgumentsHost提供了一系列便利的方法来帮助咱们在不一样的应用环境下从基础数组中选择正确的参数，ArgumentsHost只不过是一组参数。举个例子，当过滤器使用的是Http应用环境，ArgumentsHost将会提供一个[request, response]数组。然而当当前环境是WebSocket应用环境，它包含一个[client, data]数组。这种方法使你可以访问在自定义catch()方法中最终传递给原始处理函数的任何参数。

绑定过滤器

• 让咱们将HttpExceptionFilter和CatsController的create()函数联系起来。

@Post()
@UseFilters(new HttpExceptionFilter())
async create(@Body() createCatDto: CreateCatDto) {
  throw new ForbiddenException();
}
复制代码

ps: 装饰器@UseFilters()由@nestjs/common包导出。

• 咱们这里使用了装饰器@UseFilters()。相似于@Catch()装饰器，它接受一个过滤器实例，过着一个逗号分割的过滤器实例的列表。这里咱们建立了HttpExceptionFilter的实例。或者你也能够传入类（而不是实例），将实例化的责任交给框架，而且启用依赖注入。

@Post()
@UseFilters(HttpExceptionFilter)
async create(@Body() createCatDto: CreateCatDto) {
  throw new ForbiddenException();
}
复制代码

ps: 尽量地使用类而不是实例来注册过滤器。它减小了内存使用，由于Nest在你的模块中能够轻易地重用同一个类的实例。

• 在上面的例子中，HttpExceptionFilter仅应用于单个create()路由处理函数，使其具备方法范围。异常过滤器能够在不一样的层肯定做用域:方法做用域、控制器做用域或全局做用域。例如，设置一个控制器做用域的过滤器：

@UseFilters(new HttpExceptionFilter())
export class CatsController {}
复制代码

• 此构造函数为在CatsController中定义的每一个路由处理函数设置了HttpExceptionFilter。
• 建立一个全局做用域的过滤器：

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.useGlobalFilters(new HttpExceptionFilter());
  await app.listen(3000);
}
bootstrap();
复制代码

`useGlobalFilters()`方法不为网关或混合应用程序设置过滤器。

• 全局做用域的过滤器在整个应用当中被使用，每一个控制器每一个路由处理函数。按照依赖注入，从任何模块外部注册的全局过滤器(如上例所示，使用useGlobalFilters())不能注入依赖项，由于这是在任何模块的环境以外完成的。你可使用如下构造直接从任何模块注册一个全局范围的过滤器

import { Module } from '@nestjs/common';
import { APP_FILTER } from '@nestjs/core';

@Module({
  providers: [
    {
      provide: APP_FILTER,
      useClass: HttpExceptionFilter,
    },
  ],
})
export class AppModule {}
复制代码

ps: 当使用此方法为过滤器执行依赖项注入时，请注意，不管使用此构造的模块是什么，过滤器实际上都是全局的。这应该在哪里进行？选择定义过滤器(上面示例中的HttpExceptionFilter)地方的模块。而且，useClass不是处理自定义提供者注册的惟一方法。

• 你能够根据须要使用这种方法添加尽量多的过滤器，只需将每一个组件添加到provider数组。

捕获全部

• 为了捕获未处理的异常（无论异常的类型是什么）。装饰器@Catch()传空就能够了。

import { ExceptionFilter, Catch, ArgumentsHost, HttpException, HttpStatus } from '@nestjs/common';

@Catch()
export class AllExceptionsFilter implements ExceptionFilter {
  catch(exception: unknown, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const response = ctx.getResponse();
    const request = ctx.getRequest();

    const status =
      exception instanceof HttpException
        ? exception.getStatus()
        : HttpStatus.INTERNAL_SERVER_ERROR;

    response.status(status).json({
      statusCode: status,
      timestamp: new Date().toISOString(),
      path: request.url,
    });
  }
}
复制代码

• 在上面的例子中，过滤器将捕获全部抛出的异常，无论类型是什么。

继承

• 一般，你将建立彻底自定义的异常过滤器，以知足应用程序需求。然而，在某些例子中，你可能但愿简单地扩展内置的默认全局异常过滤器，并基于某些因素覆盖行为。
• 为了将异常处理委托给基础过滤器，你须要扩展BaseExceptionFilter并调用继承的catch()方法。

import { Catch, ArgumentsHost } from '@nestjs/common';
import { BaseExceptionFilter } from '@nestjs/core';

@Catch()
export class AllExceptionsFilter extends BaseExceptionFilter {
  catch(exception: unknown, host: ArgumentsHost) {
    super.catch(exception, host);
  }
}
复制代码

扩展`BaseExceptionFilter`的方法范围和控制范围的过滤器不该该用new实例化，让框架自动实例化它们。

• 上面的实现只是展现了该方法的结构。扩展异常过滤器的实现将包括你的定制的业务逻辑(例如，处理各类条件)。
• 全局过滤器能够扩展基础过滤器，有两种方法。
• 第一种方法是在实例化自定义的全局过滤器时注入HttpServer参数

async function bootstrap() {
  const app = await NestFactory.create(AppModule);

  const { httpAdapter } = app.get(HttpAdapterHost);
  app.useGlobalFilters(new AllExceptionsFilter(httpAdapter));

  await app.listen(3000);
}
bootstrap();
复制代码

• 第二种方法是使用APP_FILTER标识像这样

---

管道

管道

• 管道是使用装饰器@Injectable()的类，管道应该实现PipeTransform接口

• 管道由两个典型的应用
  1. 转换 —— 将输入的数据转换为所需的数据输出
  2. 校验 —— 校验输入的数据，经过验证则原封不动地传递，不然当数据不正确时抛出异常
• 在这两种状况中，管道对控制器的路由处理函数正在处理的参数进行操做。Nest插入一个在函数调用前插入一个管道，而且管道接受函数指定的参数。任何转换或验证操做都在那时发生，而后使用任何(潜在的)转换后的参数调用路由处理函数。

ps：管道运行在异常区域内。这意味这当管道抛出异常时，由异常层(全局异常过滤器和应用于当前环境的任何异常过滤器)处理。根据上面的说明，当异常在管道中抛出时，显然不会执行控制器方法。

内置管道

• Nest提供了三个开箱即用的管道：ValidationPipe、ParseIntPipe、ParseUUIDPipe。他们从@nestjs/common导出，为了更好地理解它们是如何工做的，让咱们从头开始构建它们。
• 让咱们从ValidationPipe开始。起先咱们简单地传入一个值并马上返回相同的值，就像一个确认函数。

import { PipeTransform, Injectable, ArgumentMetadata } from '@nestjs/common';

@Injectable()
export class ValidationPipe implements PipeTransform {
  transform(value: any, metadata: ArgumentMetadata) {
    return value;
  }
}
复制代码

ps: PipeTransform<T, R>是一个泛型接口，其中T表示输入值的类型，R表示transform()方法的返回类型。

• 每一个管道提供了tranform()方法，由两个参数：
  1. value
  2. metadata
• value是当前处理的参数(在路由处理方法接收它以前)，而metadata是它的元数据。meata对象具备这些属性

export interface ArgumentMetadata {
  readonly type: 'body' | 'query' | 'param' | 'custom';
  readonly metatype?: Type<any>;
  readonly data?: string;
}
复制代码

• 这些属性描述了当前正在处理的参数

type	代表了参数是@body()、@Query()、@Param()或者是一个自定义参数
metatype	为参数提供了元数据，例如字符。注意：若是在路由处理函数的方法签名中省略类型声明，或者使用普通JavaScript，则该值为undefined。
data	传入装饰器的字符。例如：@Body('string')，传空即为undefined

TypeScript的接口（Interface）在转换期间会消失。所以，若是方法参数的类型声明为接口而不是类，则metatype值将为Object。

验证的例子

• 让咱们仔细看看CatsController的create()方法。

@Post()
async create(@Body() createCatDto: CreateCatDto) {
  this.catsService.create(createCatDto);
}
复制代码

• 让咱们关注createCatDto的body参数。它的类型是CreateCatDto

export class CreateCatDto {
  readonly name: string;
  readonly age: number;
  readonly breed: string;
}
复制代码

• 咱们但愿确保对create方法来讲任何传入的请求都包含一个有效的请求体。所以，咱们必须验证createCatDto对象的三个成员。咱们固然能够在路由处理函数中作这件事情，但咱们将会打破单一责任规则(SRP)。另外一种方法是建立一个验证器类并在其中委托任务，可是咱们必须在每一个方法的开头使用这个验证器。那建立一个验证中间件怎么样？这多是一个好主意，可是这没有办法建立能够跨整个应用程序使用的通用的中间件(由于中间件不知道执行环境，包括将要调用的处理函数及其任何参数)。事实证实，这种状况很是适合于管道。因此咱们来作一个。

对象模式验证

• 有几种可用的方法来验证对象，一种常见的方法是使用基于模式的验证。Joi库容许你使用可读的API以很是简单的方式建立模式。让咱们看看一个使用基于joi模式的管道。
• 先安装

$ npm install --save @hapi/joi
$ npm install --save-dev @types/hapi__joi
复制代码

• 在下面的代码示例中，咱们建立了一个简单的类，它接受模式做为构造函数参数。而后咱们应用jo .validate()方法，该方法根据提供的模式验证传入参数。

• 如上所述，验证的管道要么返回未更改的值，要么抛出异常。

• 在下一节中，你将看到咱们如何使用@UsePipes()装饰器为给定的控制器方法提供适当的模式。

import * as Joi from '@hapi/joi';
import { PipeTransform, Injectable, ArgumentMetadata, BadRequestException } from '@nestjs/common';

@Injectable()
export class JoiValidationPipe implements PipeTransform {
  constructor(private readonly schema: Object) {}

  transform(value: any, metadata: ArgumentMetadata) {
    const { error } = Joi.validate(value, this.schema);
    if (error) {
      throw new BadRequestException('Validation failed');
    }
    return value;
  }
}
复制代码

绑定管道

• 绑定管道(将它们绑定到适当的控制器或处理函数)很是简单。咱们使用@UsePipes()装饰器并建立一个管道实例，将一个Joi验证模式传递给它。

@Post()
@UsePipes(new JoiValidationPipe(createCatSchema))
async create(@Body() createCatDto: CreateCatDto) {
  this.catsService.create(createCatDto);
}
复制代码

类验证器

本节中的技术须要TypeScript，若是应用程序是使用普通JavaScript编写的，则不可用

• 让咱们看看验证技术的另外一种可替代的实现。
• Nest能够很好地与类验证器库一块儿工做。这个惊人的库容许您使用基于装饰器的验证。基于装饰器的验证功能很是强大，尤为是与Nest的管道功能结合使用时，由于咱们能够访问处理属性的元类型。在开始以前，咱们须要安装所需的软件包

$ npm i --save class-validator class-transformer
复制代码

• 安装了这些以后，咱们能够向CreateCatDto类添加一些装饰器。

import { IsString, IsInt } from 'class-validator';

export class CreateCatDto {
  @IsString()
  readonly name: string;

  @IsInt()
  readonly age: number;

  @IsString()
  readonly breed: string;
}
复制代码

ps：更多关于类验证器请阅读这里

• 如今咱们能够建立一个ValidationPipe类

import { PipeTransform, Injectable, ArgumentMetadata, BadRequestException } from '@nestjs/common';
import { validate } from 'class-validator';
import { plainToClass } from 'class-transformer';

@Injectable()
export class ValidationPipe implements PipeTransform<any> {
  async transform(value: any, { metatype }: ArgumentMetadata) {
    if (!metatype || !this.toValidate(metatype)) {
      return value;
    }
    const object = plainToClass(metatype, value);
    const errors = await validate(object);
    if (errors.length > 0) {
      throw new BadRequestException('Validation failed');
    }
    return value;
  }

  private toValidate(metatype: Function): boolean {
    const types: Function[] = [String, Boolean, Number, Array, Object];
    return !types.includes(metatype);
  }
}
复制代码

ps: 上面，咱们使用了类转换器库。它是由同一个做者编写的，与类验证器库是同一个做者编写的，所以，它们在一块儿运行得很是好。

• 让咱们看看这段代码。首先，注意transform()函数是异步的。这是可能的，由于Nest同时支持同步和异步管道。咱们这样作是由于一些类验证器验证能够是异步的(利用promise)。
• 接下来注意，咱们使用解构来提取metatype字段(仅从ArgumentMetadata中提取此成员)到metatype参数中。这只是获取完整ArgumentMetadata的简写，而后使用附加语句来分配元类型变量。
• 接下来，注意辅助函数toValidate()。当当前处理的参数是原生JavaScript类型时，它负责绕过验证步骤(这些参数不能附加模式，所以没有理由在验证步骤中运行它们)。
• 接下来，咱们使用类转换器函数plain toclass()将普通JavaScript参数对象转换为类型化对象，以便应用验证。从网络请求反序列化传入的主体时，会没有任何类型的信息。类验证器须要使用前面为DTO定义的验证装饰器，所以须要执行此转换。
• 最后，如前所述，因为这是一个验证管道，它要么返回未更改的值，要么抛出异常。
• 最后一步是绑定ValidationPipe。管道相似于异常过滤器，能够是方法范围的、控制范围的或全局范围的。此外，管道能够是参数做用域的。在下面的示例中，咱们将直接将管道实例绑定到路由参数的@Body()装饰器。

@Post()
async create(
  @Body(new ValidationPipe()) createCatDto: CreateCatDto,
) {
  this.catsService.create(createCatDto);
}
复制代码

• 当验证逻辑只涉及一个指定参数时，参数做用域的管道很是有用。

• 或者，要用方法级别设置管道，可使用@UsePipes()装饰器。

@Post()
@UsePipes(new ValidationPipe())
async create(@Body() createCatDto: CreateCatDto) {
  this.catsService.create(createCatDto);
}
复制代码

• @UesPipe()装饰器由@nestjs/common导出
• 在上面的示例中，当即就地建立了ValidationPipe实例。或者，传递类(而不是实例)，从而将实例化留给框架，并启用依赖项注入。

@Post()
@UsePipes(ValidationPipe)
async create(@Body() createCatDto: CreateCatDto) {
  this.catsService.create(createCatDto);
}
复制代码

• 因为ValidationPipe被建立为尽量通用，因此让咱们将它设置为全局范围的管道，应用于整个应用程序中的每一个路由处理程序。

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.useGlobalPipes(new ValidationPipe());
  await app.listen(3000);
}
bootstrap();
复制代码

ps: 在混合应用程序的状况下，useGlobalPipes()方法不会为网关和微服务设置管道。对于“标准”(非混合)微服务应用程序，useGlobalPipes()在全局安装管道。

• 全局管道用于整个应用程序，用于每一个控制器和每一个路由处理程序。在依赖项注入方面，从任何模块外部注册的全局管道(如上例中使用useGlobalPipes())不能注入依赖项，由于这是在任何模块的环境以外完成的。为了解决这个问题，您可使用如下构造从任何模块直接设置全局管道

import { Module } from '@nestjs/common';
import { APP_PIPE } from '@nestjs/core';

@Module({
  providers: [
    {
      provide: APP_PIPE,
      useClass: ValidationPipe,
    },
  ],
})
export class AppModule {}
复制代码

ps: 当使用此方法为管道执行依赖项注入时，请注意，不管使用此构造的模块是什么，管道实际上都是全局的。这应该在哪里进行?选择定义管道的模块(上面示例中的ValidationPipe)。并且，useClass不是处理自定义提供者注册的惟一方法。了解更多。

转换例子

• 验证不是管道的惟一的案例。在本章的开头，咱们提到管道还能够将输入数据转换为所需的输出。这是可能的，由于transform函数返回的值彻底覆盖了参数的前一个值。何时有用?考虑到有时从客户端传递的数据须要进行一些更改(例如将字符串转换为整数)，而后才能由route处理方法正确处理。此外，一些必需的数据字段可能会丢失，咱们但愿应用默认值，Transformer pipes能够经过在客户端请求和请求处理程序之间插入一个处理函数来执行这些功能。
• 这是一个ParseIntPipe，它负责将字符串解析为整数值。

import { PipeTransform, Injectable, ArgumentMetadata, BadRequestException } from '@nestjs/common';

@Injectable()
export class ParseIntPipe implements PipeTransform<string, number> {
  transform(value: string, metadata: ArgumentMetadata): number {
    const val = parseInt(value, 10);
    if (isNaN(val)) {
      throw new BadRequestException('Validation failed');
    }
    return val;
  }
}
复制代码

• 咱们能够简单地将这个管道绑定到所选的参数，以下所示

@Get(':id')
async findOne(@Param('id', new ParseIntPipe()) id) {
  return await this.catsService.findOne(id);
}
复制代码

• 若是您愿意，可使用ParseUUIDPipe，它负责解析字符串并验证是否为UUID。

@Get(':id')
async findOne(@Param('id', new ParseUUIDPipe()) id) {
  return await this.catsService.findOne(id);
}
复制代码

ps: 当使用ParseUUIDPipe()时，您在版本三、4或5中解析UUID，若是您只须要特定版本的UUID，那么您能够在管道选项中传递一个版本。

• 有了这一点，ParseIntPipe或ParseUUIDPipe将在请求到达相应的处理函数以前执行，确保它老是会收到id参数的整数或uuid(根据使用的管道)。另外一种有用的状况是经过id从数据库中选择一个现有的用户实体

@Get(':id')
findOne(@Param('id', UserByIdPipe) userEntity: UserEntity) {
  return userEntity;
}
复制代码

• 请注意，与全部其余转换管道同样，它接收一个输入值(一个id)并返回一个输出值(一个UserEntity对象)。经过将样板代码从处理函数抽象到公共管道中，这可使您的代码更具声明性和干爽性。

内置的验证管道

• 幸运的是，您没必要本身构建这些管道，由于ValidationPipe和ParseIntPipe是由Nest开箱即用提供的。(请记住ValidationPipe须要同时安装类验证器和类转换器包)。
• 内置的ValidationPipe提供了比咱们在本章中构建的示例更多的选项，为了说明管道的基本机制，本章保持了基本的验证。你能够在这里找到不少例子。
• 其中一个选择就是转换。回想一下前面关于反序列化体对象是普通JavaScript对象的讨论(即，没有咱们的DTO类型)。到目前为止，咱们已经使用管道验证了负载。你可能还记得，在这个过程当中，咱们使用class-transform将普通对象临时转换为类型化对象，以便进行验证。内置的ValidationPipe还能够选择性地返回这个转换后的对象。咱们经过向管道传递配置对象来启用此行为。对于这个选项，传递一个带有字段转换和值true的配置对象

@Post()
@UsePipes(new ValidationPipe({ transform: true }))
async create(@Body() createCatDto: CreateCatDto) {
  this.catsService.create(createCatDto);
}
复制代码

ps: ValidationPipe从@nestjs/common package导出。

• 由于这个管道基于类验证器和类转换器库，因此有许多额外的选项可用。与上面的transform选项同样，您能够经过传递给管道的配置对象来配置这些设置。如下是内置选项

export interface ValidationPipeOptions extends ValidatorOptions {
  transform?: boolean;
  disableErrorMessages?: boolean;
  exceptionFactory?: (errors: ValidationError[]) => any;
}
复制代码

• 除此以外，全部类验证器选项(继承自ValidatorOptions接口)都是可用的

配置	类型	描述
skipMissingProperties	boolean	若是设置为true，验证器将跳过验证对象中缺乏的全部属性的验证。
whitelist	boolean	若是设置为true，validator将剥离不使用任何验证修饰符的任何属性的已验证(返回)对象。
forbidNonWhitelisted	boolean	若是设置为true，则抛出异常而不是剥离非白名单属性验证器。
forbidUnknownValues	boolean	若是设置为true，验证未知对象的尝试将当即失败。
disableErrorMessages	boolean	若是设置为true，验证错误将不会返回给客户端。
exceptionFactory	Function	获取验证错误数组，并返回要抛出的异常对象。
groups	string[]	在对象验证期间使用的数组。
dismissDefaultMessages	boolean	若是设置为true，验证将不使用默认信息。若是没有明确设置错误信息，则该信息始终是undefined的
validationError.target	boolean	表示目标是否应在ValidationError中暴露
validationError.value	boolean	表示验证的值是否应在ValidationError中暴露

ps： 在其存储库中查找有关类验证器包的更多信息。

---

守卫

守卫

• 守卫是一个使用装饰器@Injectable()的类，守卫应该继承CanActivate接口

• 守卫只有一个责任。他们决定了一个请求是否要交予路由函数处理，取决于在运行时出现的某些状况（例如权限、角色、ACL等）。这一般叫作受权。受权（一般和他的兄弟——身份验证——一块儿合做）在传统的Express当中一向是由中间件来处理。中间件对于身份验证是一个好的选择，由于像令牌验证或是在request对象上增长属性和一个特定的路由环境（还有他的元数据）并无很大的关联。
• 可是中间件自己是愚蠢的，他并不知道调用next()方法后哪个路由处理函数将被执行。另外一方面，守卫能够访问ExecutionContext的实例，这样就能准确地知道下一个执行的函数。它们的设计很像异常过滤器、管道和拦截器，让你在request/response循环中在正确的位置插入处理逻辑，并用声明的方式来实现。

ps：守卫会在每一个中间件以后执行，可是会在拦截器和管道以前。

受权守卫

• 正如所说的，受权是守卫的一个很好的案例，由于只有当调用者(一般是通过身份验证的特定用户)具备足够的权限时，才应该使用特定的路由。
• 咱们如今要构建的AuthGuard假设有一个通过身份验证的用户(所以，请求头附加了一个令牌)。它将提取和验证令牌，并使用提取的信息来肯定请求是否能够继续。

import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common';
import { Observable } from 'rxjs';

@Injectable()
export class AuthGuard implements CanActivate {
  canActivate(
    context: ExecutionContext,
  ): boolean | Promise<boolean> | Observable<boolean> {
    const request = context.switchToHttp().getRequest();
    return validateRequest(request);
  }
}
复制代码

• validateRequest()函数中的逻辑能够根据须要简单或复杂。本例的主要目的是展现守卫是如何适应request/response循环
• 每一个守卫必须实现canActivate()函数。函数应该返回一个布尔值，表示了当前请求是否容许经过。他能够同步或异步地返回响应（经过Promise或者Observable）。Nest根据返回值来控制下一个动做：
  • 若是返回true，请求将被处理
  • 若是返回false，Nest将拒绝该请求
• canActivate()函数接受一个参数，ExecutionContext的实例。ExecutionContext继承自ArgumentsHost。咱们在以前异常过滤器的章节中看到过ArgumentsHost。在那里，它是传递给原始处理函数的参数的包装器，而且包含了基于应用类型的不一样的参数数组。有关此主题的更多信息，请参阅异常过滤器。

执行环境

• 经过扩展ArgumentsHost，ExecutionContext提供了关于当前执行过程的更多细节。

export interface ExecutionContext extends ArgumentsHost {
  getClass<T = any>(): Type<T>;
  getHandler(): Function;
}
复制代码

• getHandler()方法返回对将要调用的处理函数的引用。getClass()方法返回这个特定处理函数所属的控制器类的类型。例如，若是当前处理的请求是一个POST请求，目标是CatsController上的create()方法，getHandler()将返回对create()方法的引用，getClass()将返回一个CatsController类型(而不是实例)。

基于角色的身份验证

• 让咱们构建一个功能更强的守卫，它只容许具备特定角色的用户访问。咱们将从一个基本的守卫模板开始，并在接下来的部分中构建它。目前，它容许全部请求继续进行

import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common';
import { Observable } from 'rxjs';

@Injectable()
export class RolesGuard implements CanActivate {
  canActivate(
    context: ExecutionContext,
  ): boolean | Promise<boolean> | Observable<boolean> {
    return true;
  }
}
复制代码

绑定守卫

• 与管道和异常过滤器同样，守卫能够是控制器范围的、方法范围的或全局范围的。下面，咱们使用@ useguard()装饰器设置了一个控制器范围的守卫。这个装饰器可使用单个参数，也可使用逗号分隔的参数列表。‘

@Controller('cats')
@UseGuards(RolesGuard)
export class CatsController {}
复制代码

ps: UseGuards()装饰器由@nestjs/common导出

• 上面，咱们传递了RolesGuard类型(而不是实例)，将实例化的责任留给框架并启用依赖项注入。与管道和异常过滤器同样，咱们也能够就地传递一个实例。

@Controller('cats')
@UseGuards(new RolesGuard())
export class CatsController {}
复制代码

• 上面的构造将守卫附加到此控制器声明的每一个处理程序。若是咱们但愿守卫只应用于一个方法，咱们将在方法级别应用@useguard()装饰器。
• 要设置全局警卫，请使用Nest应用程序实例的useglobalguard()方法

const app = await NestFactory.create(AppModule);
app.useGlobalGuards(new RolesGuard());
复制代码

ps: 在混合应用程序的状况下，useglobalguard()方法不会为网关和微服务设置保护。对于“标准”(非混合)微服务应用程序，useglobalguard()确实在全球安装了这些警卫。

• 全局守卫用于整个应用程序，用于每一个控制器和每一个路由处理函数。在依赖项注入方面，从任何模块外部注册的全局警卫(如上例中使用useglobalguard())不能注入依赖项，由于这是在任何模块的环境以外完成的。为了解决这个问题，您可使用如下构造从任何模块直接设置一个守卫

import { Module } from '@nestjs/common';
import { APP_GUARD } from '@nestjs/core';

@Module({
  providers: [
    {
      provide: APP_GUARD,
      useClass: RolesGuard,
    },
  ],
})
export class AppModule {}
复制代码

ps: 当使用此方法为守卫执行依赖项注入时，请注意，不管使用此构造的模块是什么，守卫实际上都是全局的。这应该在哪里进行?选择定义守卫的模块(在上面的例子中是RolesGuard)。并且，useClass不是处理自定义提供者注册的惟一方法。了解更多。

映射

• 咱们的RolesGuard工做正常，但还不是很智能。咱们尚未利用最重要的守卫特性——执行环境。它还不知道角色，或者每一个处理程序容许哪些角色。例如，CatsController能够为不一样的路由提供不一样的权限方案。其中一些可能只对管理员用户可用，而另外一些则能够对全部人开放。咱们如何以灵活和可重用的方式将角色匹配到路由？
• 这就是定制元数据发挥做用的地方。Nest提供了经过@SetMetadata()装饰器将定制元数据附加到路由处理程序的能力。这个元数据提供了咱们丢失的角色数据，智能守卫须要这些数据来作出决策。让咱们看看如何使用@SetMetadata()

@Post()
@SetMetadata('roles', ['admin'])
async create(@Body() createCatDto: CreateCatDto) {
  this.catsService.create(createCatDto);
}
复制代码

ps: 装饰器@SetMetadata()由nestjs/common包导出

• 经过上述构造，咱们将角色元数据(角色是一个键，而['admin']是一个特定值)附加到create()方法。虽然这样作是有效的，可是在路由中直接使用@SetMetadata()不是很好的作法。相反，建立您本身的装饰器，以下所示

import { SetMetadata } from '@nestjs/common';

export const Roles = (...roles: string[]) => SetMetadata('roles', roles);
复制代码

• 这种方法更简洁、可读性更强，并且是强类型的。如今咱们有了一个自定义的@Roles()装饰器，咱们可使用它来装饰create()方法。

@Post()
@Roles('admin')
async create(@Body() createCatDto: CreateCatDto) {
  this.catsService.create(createCatDto);
}
复制代码

融会贯通

• 如今让咱们回去把它和咱们的RolesGuard绑在一块儿。目前，它只是在全部状况下返回true，容许每一个请求继续。咱们但愿将分配给当前用户的角色与正在处理的当前路由所需的实际角色进行比较，从而使返回值具备条件。为了访问路由的角色(自定义元数据)，咱们将使用Reflector辅助类，它由框架提供，并从@nestjs/common公开。

import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common';
import { Observable } from 'rxjs';
import { Reflector } from '@nestjs/core';

@Injectable()
export class RolesGuard implements CanActivate {
  constructor(private readonly reflector: Reflector) {}

  canActivate(context: ExecutionContext): boolean {
    const roles = this.reflector.get<string[]>('roles', context.getHandler());
    if (!roles) {
      return true;
    }
    const request = context.switchToHttp().getRequest();
    const user = request.user;
    const hasRole = () => user.roles.some((role) => roles.includes(role));
    return user && user.roles && hasRole();
  }
}
复制代码

ps: 在node.js中，一般将受权用户附加到请求对象。所以，在上面的示例代码中，咱们假设该请求。user包含用户实例和容许的角色。在您的应用程序中，您可能会在自定义身份验证守卫(或中间件)中建立关联。

• Reflector类容许咱们经过指定的键轻松地访问元数据(在本例中，键是“roles”;返回到roles.decorator.ts文件和在那里发出的SetMetadata()调用。在上面的示例中，为了提取当前处理的请求方法的元数据，咱们传递了context.getHandler()。记住，getHandler()提供了对路由处理函数的引用。
• 咱们能够经过提取控制器元数据并使用该元数据来肯定当前用户角色，从而使这个守卫更加通用。为了提取控制器元数据，咱们传递context.getClass()而不是context.getHandler()

const roles = this.reflector.get<string[]>('roles', context.getClass());
复制代码

• 当权限不足的用户请求端点时，Nest自动返回如下响应

{
  "statusCode": 403,
  "message": "Forbidden resource"
}
复制代码

注意，在后台，当一个守卫返回false时，框架抛出一个ForbiddenException。若是但愿返回不一样的错误响应，应该抛出本身的特定异常。例如

throw new UnauthorizedException();
复制代码

• 由守卫引起的任何异常都将由异常层(全局异常过滤器和应用于当前环境的任何异常过滤器)处理。

---

拦截器

拦截器

• 拦截器是使用装饰器@injectable的类，拦截器应该实现NestInterceptor接口

• 拦截器具备一组有用的功能，这些功能受到面向方面编程(AOP)技术的启发。他们使之成为可能：
  1. 在方法执行前/后绑定额外的逻辑
  2. 转换函数返回的结果
  3. 转换函数抛出的异常
  4. 扩展基础函数的行为
  5. 根据特定条件彻底重载函数

基础

• 每一个拦截器实现了intercept()方法，接受两个参数。第一个是ExecutionContext的实例（和守卫同样）。ExecutionContext继承自ArgumentsHost。咱们在前面的异常过滤器一章中看到了ArgumentsHost。在那里，咱们看到它是传递给原始处理函数的参数的包装器，并根据应用程序的类型包含不一样的参数数组。

Execution context 执行环境

• 经过扩展ArgumentsHost, ExecutionContext提供了关于当前执行过程的更多细节。这是它的样子

export interface ExecutionContext extends ArgumentsHost {
  getClass<T = any>(): Type<T>;
  getHandler(): Function;
}
复制代码

• getHandler()方法返回对将要调用的路由处理程序的引用，getClass()方法返回这个特定处理程序所属的控制器类的类型。例如，若是当前处理的请求是一个POST请求，目标是CatsController上的create()方法，getHandler()将返回对create()方法的引用，getClass()将返回一个CatsControllertype(而不是实例)。

调用处理函数

• 第二个参数是CallHandler。CallHandler接口实现handle()方法，你可使用该方法在拦截器中的某个点调用路由处理函数。若是在拦截器intercept()方法的实现中不调用handle()方法，则根本不会执行路由处理函数。

部分拦截

• 第一个用例是使用拦截器来记录用户交互(例如，存储用户调用、异步调度事件或计算时间戳)。咱们在下面展现了一个简单的日志拦截器

import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
import { Observable } from 'rxjs';
import { tap } from 'rxjs/operators';

@Injectable()
export class LoggingInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    console.log('Before...');

    const now = Date.now();
    return next
      .handle()
      .pipe(
        tap(() => console.log(`After... ${Date.now() - now}ms`)),
      );
  }
}
复制代码

ps: NestInterceptor<T, R>是一个泛型接口，其中T表示一个Observable<T>(支持响应流)的类型，R是Observable<R>封装的值的类型。

ps: 拦截器，如控制器、提供者、守卫等，能够经过它们的构造函数注入依赖项。

• 因为handle()返回一个RxJs的Observable，因此咱们可使用多种操做符来操做流。在上面的例子中，咱们使用了tap()操做符，在observable流优雅或异常终止时调用匿名日志函数，但不会在其余方面干扰响应循环。

绑定拦截器

• 为了设置拦截器，咱们使用从@nestjs/common导入的@UseInterceptors()装饰器，与管道和守卫同样，拦截器能够是控制器范围的、方法范围的或全局范围的。

@UseInterceptors(LoggingInterceptor)
export class CatsController {}
复制代码

• 使用上述构造，CatsController中定义的每一个路由处理函数都将使用LoggingInterceptor。当有人调用GET /cats端点时，您将在标准输出中看到如下输出

Before...
After... 1ms
复制代码

• 注意，咱们传递了LoggingInterceptor类型(而不是实例)，将实例化的责任留给框架并启用依赖项注入。与管道、守卫和异常过滤器同样，咱们也能够传递一个就地实例。

@UseInterceptors(new LoggingInterceptor())
export class CatsController {}
复制代码

• 如上所述，上面的构造将拦截器附加到此控制器声明的每一个处理函数。若是咱们想将拦截器的范围限制为一个方法，咱们只需在方法级别应用装饰器。

• 为了设置全局拦截器，咱们使用了Nest应用程序实例的useGlobalInterceptors()方法

const app = await NestFactory.create(AppModule);
app.useGlobalInterceptors(new LoggingInterceptor());
复制代码

• 全局拦截器用于整个应用程序，用于每一个控制器和每一个路由处理函数 。在依赖项注入方面，从任何模块外部注册的全局拦截器(使用useGlobalInterceptors()，如上例所示)不能注入依赖项，由于这是在任何模块的环境以外完成的。为了解决这个问题，您可使用如下构造直接从任何模块设置拦截器

import { Module } from '@nestjs/common';
import { APP_INTERCEPTOR } from '@nestjs/core';

@Module({
  providers: [
    {
      provide: APP_INTERCEPTOR,
      useClass: LoggingInterceptor,
    },
  ],
})
export class AppModule {}
复制代码

ps: 当使用此方法为拦截器执行依赖项注入时，请注意，不管使用此构造的模块是什么，拦截器实际上都是全局的。这应该在哪里进行?选择定义拦截器(上例中的LoggingInterceptor)的模块。并且，useClass不是处理自定义提供者注册的惟一方法。了解更多。

响应映射

• 咱们已经知道handle()返回一个Obseverable对象。流包含路由处理函数返回的值，所以咱们可使用RxJS的map()操做符轻松地对其进行修改。

响应映射特性与指定库library-specific的响应策略不兼容(禁止直接使用`@Res()`对象)。

• 让咱们建立TransformInterceptor，它将以一种简单的方式修改每一个响应，以演示流程。它将使用RxJS的map()操做符将响应对象分配给新建立对象的data属性，并将新对象返回给客户端。

import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
import { Observable } from 'rxjs';
import { map } from 'rxjs/operators';

export interface Response<T> {
  data: T;
}

@Injectable()
export class TransformInterceptor<T> implements NestInterceptor<T, Response<T>> {
  intercept(context: ExecutionContext, next: CallHandler): Observable<Response<T>> {
    return next.handle().pipe(map(data => ({ data })));
  }
}
复制代码

ps: 嵌套拦截器同时使用同步和异步intercept()方法。若是须要，您能够简单地将方法切换到async。

• 使用上述构造，当有人调用GET /cats端点时，响应将以下所示(假设路由处理程序返回一个空数组[])

{
  "data": []
}
复制代码

• 拦截器在为跨整个应用程序发生的需求建立可重用的解决方案方面具备很大的价值。例如，假设咱们须要将每次出现的空值转换为空字符串。咱们可使用一行代码来实现这一点，并全局绑定拦截器，这样每一个注册的处理程序都会自动使用它。

import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
import { Observable } from 'rxjs';
import { map } from 'rxjs/operators';

@Injectable()
export class ExcludeNullInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    return next
      .handle()
      .pipe(map(value => value === null ? '' : value ));
  }
}
复制代码

异常映射

• 另外一个有趣的用例是利用RxJS的catchError()操做符覆盖抛出的异常

import {
  Injectable,
  NestInterceptor,
  ExecutionContext,
  BadGatewayException,
  CallHandler,
} from '@nestjs/common';
import { Observable, throwError } from 'rxjs';
import { catchError } from 'rxjs/operators';

@Injectable()
export class ErrorsInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    return next
      .handle()
      .pipe(
        catchError(err => throwError(new BadGatewayException())),
      );
  }
}
复制代码

流重载

• 咱们有时可能但愿彻底避免调用处理函数，而是返回一个不一样的值，这有几个缘由。一个明显的例子是实现缓存以加速响应时间。让咱们来看一个简单的缓存拦截器，它从缓存返回响应。在实际的示例中，咱们但愿考虑其余因素，如TTL、缓存失效、缓存大小等，但这超出了本文的讨论范围。这里咱们将提供一个基本示例来演示主要概念。

import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
import { Observable, of } from 'rxjs';

@Injectable()
export class CacheInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    const isCached = true;
    if (isCached) {
      return of([]);
    }
    return next.handle();
  }
}
复制代码

• 咱们的缓存拦截器有一个硬编码的isCached变量和一个硬编码的响应数组。须要注意的关键点是，咱们在这里返回一个由RxJSof()操做符建立的新流，所以根本不会调用路由处理程序。当有人调用使用CacheInterceptor的端点时，响应(硬编码的空数组)将当即返回。为了建立一个通用的解决方案，您能够利用Reflector并建立一个自定义装饰器。Reflector在守卫一章中有很好的描述。

更多的操做

• 使用RxJS操做符操做流的可能性为咱们提供了许多功能。让咱们考虑另外一个常见的用例。假设您但愿处理路由请求上的超时。当端点在一段时间以后没有返回任何内容时，您但愿使用错误响应终止。下面的构造实现了这一点

import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
import { Observable } from 'rxjs';
import { timeout } from 'rxjs/operators';

@Injectable()
export class TimeoutInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    return next.handle().pipe(timeout(5000))
  }
}
复制代码

• 5秒后，请求进程将被取消。

---

自定义装饰器

自定义路由装饰器

• Nest是围绕一种名为decorator的语言特性构建的。装饰器在许多经常使用的编程语言中都是一个众所周知的概念，但在JavaScript世界中，它们仍然相对较新。为了更好地理解decorator是如何工做的，咱们建议阅读本文。这里有一个简单的定义

An ES2016 decorator is an expression which returns a function and can take a target, name and property descriptor as arguments. You apply it by prefixing the decorator with an @ character and placing this at the very top of what you are trying to decorate. Decorators can be defined for either a class or a property.

参数装饰器

• Nest提供了一组有用的参数装饰器，能够与HTTP路由处理程序一块儿使用。下面是所提供的装饰器和它们所表示的普通Express(或Fastify)对象的列表

@Request()	req
@Response()	res*
@Next()	next
@Session()	req.session
@Param(key?: string)	req.params / req.params[key]
@Body(key?: string)	req.body / req.body[key]
@Query(key?: string)	req.query / req.query[key]
@Headers(name?: string)	req.headers / req.headers[name]

• 此外，您还能够建立本身的自定义装饰器。为何这个有用？
• 在node.js世界中，一般将属性附加到请求对象。而后在每一个路由处理程序中手动提取它们，使用以下代码

const user = req.user;
复制代码

• 为了使代码更具可读性和透明性，您能够建立一个@User()装饰器，并在全部控制器之间重用它。

import { createParamDecorator } from '@nestjs/common';

export const User = createParamDecorator((data, req) => {
  return req.user;
});
复制代码

• 而后，您能够简单地在任何适合须要的地方使用它。

sync findOne(@User() user: UserEntity) {
  console.log(user);
}
复制代码

传入data参数

• 当装饰器的行为取决于某些条件时，可使用data参数将参数传递给装饰器的工厂函数。一个用例是自定义装饰器，它按键从请求对象中提取属性。例如，假设咱们的身份验证层验证请求并将用户实体附加到请求对象。通过身份验证的请求的用户实体可能以下所示

{
  "id": 101,
  "firstName": "Alan",
  "lastName": "Turing",
  "email": "alan@email.com",
  "roles": ["admin"]
}
复制代码

• 让咱们定义一个装饰器，它接受属性名做为键，若是属性名存在，则返回关联的值(若是不存在，则返回未定义的值，或者若是用户对象没有建立，则返回未定义的值)。

import { createParamDecorator } from '@nestjs/common';

export const User = createParamDecorator((data: string, req) => {
  return data ? req.user && req.user[data] : req.user;
});
复制代码

• 下面是如何经过控制器中的@User()装饰器访问特定的属性

@Get()
async findOne(@User('firstName') firstName: string) {
  console.log(`Hello ${firstName}`);
}
复制代码

• 您可使用具备不一样键的相同装饰器来访问不一样的属性。若是用户对象是深度或复杂的，这可使请求处理程序实现更容易、更可读。

和管道一块儿用

• Nest以与内置参数装饰器(@Body()、@Param()和@Query()相同的方式处理定制的参数装饰器。这意味着管道也将为自定义带注释的参数执行(在咱们的示例中，是用户参数)。此外，您还能够将管道直接应用于自定义装饰器

@Get()
async findOne(@User(new ValidationPipe()) user: UserEntity) {
  console.log(user);
}
复制代码

---

overview结束

关于本文

• 本文做为学习nest框架的一篇笔记，对英文官方文档进行了直译、意译和理解。
• 翻译多有变扭之处，是比较大量的工做，后续应该持续会纠正。
• 用做记录本身曾经学习、思考过的问题的一种笔记。
• 用做前端技术交流分享。
• 阅读本文时欢迎随时质疑本文的准确性，将错误的地方告诉我。本人会积极修改，避免文章对读者的误导。

关于我

• 是一只有梦想的肥柴。
• 以为算法、数据结构、函数式编程、js底层原理等十分有趣的小前端。
• 志同道合的朋友请关注我，一块儿交流技术，在前端之路上共同成长。
• 如对本人有任何意见建议尽管告诉我哦～ 初为肥柴，请多多关照～
• 前端路漫漫，技术学不完。今天也是美(diao)好(fa)的一天（ 跪了...orz