NestJS on Dapeng Zhang

NestJS中的async/await的使用

Tue, 15 Jul 2025 09:52:23 +0000

前景

最近在试驾Nestjs，感觉还不错，但是知识点满多的，嗯，暂时还没放弃

在试驾的过程中，遇到一个获取数据逻辑，现在的逻辑这样的，函数如下

@Get('/index')
index(@Res() res: Response) {
 var cats: Promise<Cats[]> = this.catsService.findAll();

 cats.then(data => {
 return res.render('cats/index', {
 message: 'Cats',
 data: data
 })
 }).catch(error => {
 console.log(error);
 })
}

写完之后，发现then…catch，让我想起来，我用Reactjs开发的时候，曾经把这玩意换成了async/await于是，函数修改成如下

@Get('/index')
async index(@Res() res: Response) {
 var cats: Promise<Cats[]> = this.catsService.findAll();

 var data = await cats;

 return res.render('cats/index', {
 message: 'Cats",
 data: data,
 })
}

该写完之后，又让我想起来，我在用Nodejs写接口的时候，需要对await cats的执行做下异常捕获，不然访问的时候直接崩溃，对终端不太友好，于是该写如下

@Get('/index')
async index(@Res() res: Response) {
 var cats: Promise<Cats[]> = this.catsService.findAll();

 try {
 const data = await cats;

 return res.render('cats/index', {
 message: 'Cats",
 data: data,
 })
 } catch (err) {
 // 处理异常逻辑
 console.log(err);
 }
}

建议：使用async/await的情况下，如果遇到异常会导致接口异常，为了能够正常处理逻辑，可以使用try…catch

新手入门NestJS（十五）- 连接数据库

Tue, 15 Jul 2025 09:52:03 +0000

Nestjs中为了连接数据库，提供了@nestjs/typeorm包

在使用之前如果没有安装的话，需要安装下，安装命令如下

npm install --save @nestjs/typeorm typeorm mysql

这里使用MySQL，当然TypeORM也是支持其他关系型数据库的，如PostgreSQL，Oracle，Microsoft SQL Server，还有NoSQL数据库如MongoDB

如果TypeORM安装成功之后，就可以导入TypeOrmModule了

import { TypeOrmModule } from '@nestjs/typeorm';

如何配置MySQL的参数（比如连接的数据库地址、用户名、密码、数据库）

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { AppController } from './app.controller';
import { AppService } from './app.service';

@Module({
 imports: [
 TypeOrmModule.forRoot({
 type: 'mysql',
 host: '127.0.0.1',
 port: 3306,
 username: 'root',
 password: '123456',
 database: 'test',
 entities: [],
 synchronize: true,
 })
 ],
 controllers: [AppController],
 providers: [AppService],
})
export class AppModule {}

forRoot方法提供了所有的配置参数给TypeORM包的createConnection方法，除此之外，还有其他的一些配置参数的属性如下

retryAttempts：默认10，尝试连接数据库的次数
retryDelay：默认3000，尝试连接数据库延迟时间
autoLoadEntities：默认false，如果为true，entities将会被自动加载
keepConnectionAlive：默认false，如果为true，连接在应用被关闭时不会关闭

具体更多的连接配置参数，点击这里查看

数据库配置连接正常之后，就可以正常使用了

app.module.ts完整代码如下

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { Connection } from 'typeorm';

@Module({
 imports: [
 TypeOrmModule.forRoot({
 type: 'mysql',
 host: '127.0.0.1',
 port: 3306,
 username: 'root',
 password: '123456',
 database: 'test',
 entities: [],
 synchronize: true,
 logging: true,
 }),
 ],
 controllers: [AppController],
 providers: [AppService],
})
export class AppModule {
 constructor(private connection: Connection) {}
}

如何连接数据库进行查询和添加

创建Entity

cats/cats.entities.ts代码如下

import { Entity, Column, PrimaryGeneratedColumn } from 'typeorm';

@Entity({ name: 'cats' })
export class Cats {
 @PrimaryGeneratedColumn()
 id: number;

 @Column({ name: 'first_name' })
 firstName: string;

 @Column({ name: 'last_name' })
 lastName: string;

 @Column({ name: 'is_active', default: true })
 isActive: boolean;
}

创建Service

cats/cats.service.ts代码如下

import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { Cats } from './cats.entity';

@Injectable()
export class CatsService {
 constructor(
 @InjectRepository(Cats)
 private catsRepository: Repository<Cats>,
 ) {}

 findAll(): Promise<Cats[]> {
 return this.catsRepository.find();
 }

 findOne(id: number): Promise<Cats> {
 return this.catsRepository.findOne(id);
 }

 async remove(id: number): Promise<void> {
 await this.catsRepository.delete(id);
 }

 async create(cats: Cats): Promise<void> {
 await this.catsRepository.save(cats);
 }
}

创建Controller

cats/cats.controller.ts

import { Body, Controller, Get, Post, Res } from '@nestjs/common';
import { Response } from 'express';
import { Cats } from './cats.entity';
import { CatsService } from './cats.service';

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

 @Get('/index')
 index(@Res() res: Response): string {
 this.catsService.findAll();

 var cats: Promise<Cats[]> = this.catsService.findAll();

 cats
 .then((data) => {
 return res.render('cats/index', {
 message: 'Cats',
 data: data,
 });
 })
 .catch((error) => {
 console.log(error);
 });

 return '';
 }

 @Post('/create')
 async create(@Body() catsParam: { firstName: string; lastName: string }) {
 let cats = new Cats();
 cats.firstName = catsParam.firstName;
 cats.lastName = catsParam.lastName;
 cats.isActive = true;
 return await this.catsService.create(cats);
 }
}

创建Module

cats/cats.module.ts

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

@Module({
 imports: [TypeOrmModule.forFeature([Cats])],
 controllers: [CatsController],
 providers: [CatsService],
})
export class CatsModule {}

修改AppModule

app.module.ts

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { CatsModule } from './cats/cats.module';
import { Connection } from 'typeorm';
import { Cats } from './cats/cats.entity';

@Module({
 imports: [
 TypeOrmModule.forRoot({
 type: 'mysql',
 host: '127.0.0.1',
 port: 3306,
 username: 'root',
 password: '123456',
 database: 'test',
 entities: [Cats],
 synchronize: true,
 logging: true,
 }),
 CatsModule,
 ],
 controllers: [AppController],
 providers: [AppService],
})
export class AppModule {
 constructor(private connection: Connection) {}
}

运行项目

npm run start:dev

启动后如果表不存在的话会自动创建表cats

正常启动没有问题之后，先创建一个数据

curl -d 'firstName=cats&lastName=1' 'http://localhost:3000/cats/create'

然后访问http://localhost:3000/cats/index

会看到创建的数据输出

新手入门NestJS（十四）- Modules

Mon, 14 Jul 2025 16:28:02 +0000

新手入门，了解Nest.js的Modules

在Nest.js中，一个带有@Module()装饰器的类，即是一个Module

每个Application都至少有一个Module，root module

同时Nest.js强烈建议使用一个Module作为一个有效的方式来管理你的组件

下面看下如何创建一个Module

创建一个module

创建module的命令如下

nest g module cats

运行后结果如下

$ nest g module cats
CREATE src/cats/cats.module.ts (81 bytes)
UPDATE src/app.module.ts (603 bytes)

创建后默认的代码如下

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

@Module({})
export class CatsModule {}

使用module

下面修改下cats.module.ts，修改后的结果如下

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

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

同时需要修改下app.module.ts

import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { AccountController } from './account/account.controller';
import { DogsController } from './dogs/dogs.controller';
import { CatsModule } from './cats/cats.module';

@Module({
 imports: [CatsModule],
 controllers: [AppController, AccountController, DogsController],
 providers: [AppService],
})
export class AppModule {}

跟没有使用cats.module.ts的时候对比下

import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { CatsController } from './cats/cats.controller';
import { AccountController } from './account/account.controller';
import { DogsController } from './dogs/dogs.controller';
import { CatsService } from './cats/cats.service';
import { CatsModule } from './cats/cats.module';

@Module({
 imports: [CatsModule],
 controllers: [AppController, CatsController, AccountController, DogsController],
 providers: [AppService, CatsService],
})
export class AppModule {}

可以发现少了对应的CatsController，CatsService

从这个方面可以看出 Nest.js的代码体现了SOLID原则，对代码的维护是很有帮助的。

新手入门NestJS（十三）- Providers - Services

Mon, 14 Jul 2025 16:22:10 +0000

Providers是什么，看下官网的解释

Providers are a fundamental concept in Nest. Many of the basic Nest classes may be treated as a provider – services, repositories, factories, helpers, and so on. The main idea of a provider is that it can inject dependencies; this means objects can create various relationships with each other, and the function of “wiring up” instances of objects can largely be delegated to the Nest runtime system. A provider is simply a class annotated with an @Injectable() decorator.

Services

通过命令行创建 Services

nest g service cats

执行后结果类似如下

$ nest g service cats
CREATE src/cats/cats.service.spec.ts (446 bytes)
CREATE src/cats/cats.service.ts (88 bytes)
UPDATE src/app.module.ts (544 bytes)

创建完src/cats/cats.service.ts代码如下

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

@Injectable()
export class CatsService {}

修改下，修改前提我们添加一个interface

如果创建interface，命令行命令如下

$ nest g interface cat
CREATE src/cat.interface.ts (24 bytes)

创建完src/cat.interface.ts代码如下

export interface Cat {}

修改后src/cats/cats.service.ts的代码如下

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

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

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

 findAll() {
 return this.cats;
 }
}

顺便修改src/cat.interface.ts，代码如下

export interface Cat {
 name: string;
 age: number;
 bread: string;
}

下面看下如何在Controller中应用

constructor(private catsService: CatsService) {}

@Get()
async findAll(@Req() request: Request): Promise<Cat[]> {
 return this.catsService.findAll();
}

@Post()
async create(@Body() createCatDto: CreateCatDto) {
 this.catsService.create(createCatDto);
 console.log(createCatDto);
 return 'This action will create a new cat';
}

上面代码是主要关注的地方

另外需要导入对应的包

import { Cat } from 'src/cat.interface';
import { CatsService } from './cats.service';

然后访问http://127.0.0.1:3000/cats会得到一个空数组

执行下面的命令

$ curl -d 'name=durban1&age=12&bread=1' http://127.0.0.1:3000/cats

然后在访问http://127.0.0.1:3000/cats类似如下的数据

[{"name":"durban1","age":"12","bread":"1"},{"name":"durban1","age":"12","bread":"1"}]

新手入门NestJS（十二）- 控制器所有请求方式实例

Mon, 14 Jul 2025 16:21:38 +0000

这里记录下使用Nest.js中，在控制器中如何添加所有请求方式的方法

第一种请求方式Get

@Get()
findAll() {
 return 'This action will return all dogs';
}

@Get(':id')
findOne(@Param('id') id: string) {
 return `This action will return one ${id} dog`;
}

第二种请求方式Post

@Post()
create(@Body() createDogDto: CreateDogDto) {
 return `This action will add a dog`;
}

第三种请求方式Put

@Put(':id')
update(@Param('id') id: string, @Body() updateDogDto: UpdateDogDto) {
 return `This action will update a dog`;
}

第四种请求方式Delete

@Delete(':id')
remove(@Param('id') id: string) {
 return `This action will remote a dog`;
}

完整的代码如下

import {
 Body,
 Controller,
 Delete,
 Get,
 Param,
 Post,
 Put,
} from '@nestjs/common';
import { CreateDogDto } from 'src/create-dog.dto';
import { UpdateDogDto } from 'src/update-dog.dto';

@Controller('dogs')
export class DogsController {
 @Get()
 findAll() {
 return 'This action will return all dogs';
 }

 @Get(':id')
 findOne(@Param('id') id: string) {
 return `This action will return one ${id} dog`;
 }

 @Post()
 create(@Body() createDogDto: CreateDogDto) {
 return `This action will add a dog`;
 }

 @Put(':id')
 update(@Param('id') id: string, @Body() updateDogDto: UpdateDogDto) {
 return `This action will update a dog`;
 }

 @Delete(':id')
 remove(@Param('id') id: string) {
 return `This action will remote a dog`;
 }
}

新手入门NestJS（十一）- 控制器payloads请求

Mon, 14 Jul 2025 16:21:34 +0000

控制器payloads请求

如果通过Post请求来接收客户端的payloads参数

Nest.js通过使用@Body装饰器

首先创建一个DTO类，create-cats.dto.ts

export class CreateCatDto {
 name: string;
 age: number;
 bread: string;
}

然后修改create方法

import { CreateCatDto } from 'src/create-cats.dto';

@Post()
async create(@Body() createCatDto: CreateCatDto) {
 console.log(createCatDto);
 return 'This action will create a new cat';
}

运行npm run start:dev

我们测试下

$ curl -d 'name=durban&age=12&bread=ddd' http://127.0.0.1:3000/cats
This action will create a new cat

可以看到console.log的输出结果如下

{ name: 'durban', age: '12', bread: 'ddd' }

新手入门NestJS（十）- 控制器异步机制

Mon, 14 Jul 2025 16:21:31 +0000

异步机制

Nest.js也是支持现在javascript的异步机制的，async/await

同时每个async函数必须返回一个Promise

看个简单的例子

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

@Controller('account')
export class AccountController {
 @Get()
 getInfo(@HostParam('account') account) {
 return account;
 }
 @Get('all')
 async findAll(): Promise<any[]> {
 return [];
 }
}

同时Nest.js还可以处理observable streams.

例子如下

import { Controller, Get, HostParam } from '@nestjs/common';
import { Observable, of } from 'rxjs';

@Controller('account')
export class AccountController {
 @Get()
 getInfo(@HostParam('account') account) {
 return account;
 }

 @Get('all')
 findAll(): Observable<any[]> {
 return of([]);
 }
}

上面两个例子在访问的时候都会直接返回一个空数组

新手入门NestJS（九）- 控制器子域名路由

Mon, 14 Jul 2025 16:21:28 +0000

子域路由

@Controller装饰器提供了一个host选项可用，主要用来判断这个控制器在被访问的时候，限制具体的域名来访问

代码如下

@Controller('cats')
@Controller({ host: 'api.gowhich.com' })
export class CatsController {
 @Get()
 findAll(@Req() request: Request): string {
 return 'This action will returns all cats';
 }
}

再举个例子

@Controller('cats')
@Controller({ host: 'api.gowhich.com' })
export class CatsController {
 @Get()
 getInfo(@HostParam('account') account) {
 return account;
 }
}

新手入门NestJS（八）- 控制器重定向、路由参数

Mon, 14 Jul 2025 16:21:21 +0000

重定向

Nest.js提供了一种方式可以重定向路由

方式可以通过使用装饰器@Redirect和res.redirect

这里记录下如何使用装饰器来重定向

@Get('items')
@Redirect('https://www.gowhich.com', 302)
getItems(@Query('version') version) {
 if (version && version == 5) {
 return {
 url: 'https://www.gowhich.com/cats/items/v5',
 };
 }
}

当访问http://127.0.0.1:3000/cats/items，URI会被重定向到https://www.gowhich.com

当访问http://127.0.0.1:3000/cats/items?version=5，URI会被重定向到https://www.gowhich.com/cats/items/v5

获取路由参数

这里说的路由参数值的是，当访问cats/1这样的路由的时候，能否获取到1这个参数值

当然Nest.js也提供了一个非常好用的装饰器@Param

这个装饰器，我们可以使用两种方式来获取到参数

第一种

@Get(':id')
getOne(@Param() param): string {
 return `This action return id #${param.id}`;
}

第二种

@Get(':name')
getName(@Param('name') name): string {
 return `This action return name #${name}`;
}

新手入门Nest.js（七）- 控制器HttpCode、Header信息设置

Mon, 14 Jul 2025 14:55:04 +0000

如何设置状态码

Nest.js通过装饰器@HttpCode来设置状态码，状态码默认200

@Get()
@HttpCode(204)
itemError(): string {
 return 'This action return 204 error';
}

HttpCode从@nestjs/common包中导入

Header信息是可以自定义的，Nest.js也提供了一个@Header装饰器来帮助我们添加Header信息

@Get()
@Header('Cache-Control', 'none')
itemCustomHeader(): string {
 return 'This action custom header';
}

Header从@nestjs/common包中导入

新手入门NestJS（六）- 控制器Resources、路由通配符

Mon, 14 Jul 2025 14:54:56 +0000

Nest.js控制中的Resources

前面介绍了路由中如何通过GET方式访问路由，Nest.js还支持Post、Delete、Patch、Options、Head和All等

下面看下如何使用Post

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

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

 @Post()
 create(): string {
 return 'This action will create a new cat';
 }
}

项目运行起来后，做个简单的测试

$ curl -d '' http://127.0.0.1:3000/cats
This action will create a new cat

可以看到，post请求的时候访问到了create()方法

Route通配符

看个简单的例子

@Get('x*z')
find() {
 return 'This action uses a wildcard';
}

然后启动项目做下面几个测试

$ curl http://127.0.0.1:3000/cats/xyz
This action uses a wildcard

$ curl http://127.0.0.1:3000/cats/xyyz
This action uses a wildcard

$ curl http://127.0.0.1:3000/cats/xyyzz
This action uses a wildcard

从上面的输出可以观察到，输出的内容都是一致的，说明访问的路由其实调用了同一个方法

'x*z'路由将会匹配xyz,xyyz,xyyzz等，?,+,*,()都可以被用在路由的路径中

新手入门NestJS（五）- 控制器Request

Mon, 14 Jul 2025 14:54:52 +0000

一个控制器的目的是接收来自应用的一个请求

那么如何来处理这个请求，以及如何接收一个请求

Nest.js提供了一个Request Object

先看下之前写的一个例子

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

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

我们想知道如何在这个例子中获取request中的参数

修改代码如下

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

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

http obejct包括了所有http的属性，比如http query 参数、http header、body、parameters等

但是在Nest.js中已经提供了专用的装饰器比如@Body、@Query等

其他的罗列在下面了


`@Request()`	`req`
`@Response(), @Res()`*	`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]`
`@Ip()`	`req.ip`

新手入门NestJS（四）- 控制器路由

Mon, 14 Jul 2025 14:54:49 +0000

一个控制器的目的是接收来自应用的一个请求

路由机制控制了控制器接收哪个请求

通常每个控制器都有多于一个的路由，而且不同的路由能够执行不同的操作

为了创建一个基本的控制器，Nest.js使用了一个类和装饰器。

装饰器关联类然后允许Nest.js创建一个路由Map

路由

下面看个简单的例子，如下代码

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

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

这里提示一点

Nest提供了一个非常方便的创建控制的命令

nest g controller cats

执行后得到下面的结果

$ nest g controller cats
CREATE src/cats/cats.controller.spec.ts (478 bytes)
CREATE src/cats/cats.controller.ts (97 bytes)
UPDATE src/app.module.ts (322 bytes)

我们看下src/app.module.ts文件

diff --git a/src/app.module.ts b/src/app.module.ts
index 8662803..7bc3188 100644
--- a/src/app.module.ts
+++ b/src/app.module.ts
@@ -1,10 +1,11 @@
 import { Module } from '@nestjs/common';
 import { AppController } from './app.controller';
 import { AppService } from './app.service';
+import { CatsController } from './cats/cats.controller';

 @Module({
 imports: [],
- controllers: [AppController],
+ controllers: [AppController, CatsController],
 providers: [AppService],
 })
 export class AppModule {}

其实自动帮我们更新module中的代码，然后创建了对应的控制器，非常方便，大大提高了开发效率

然后运行

npm run start:dev

得到如下输出

[Nest] 9167 - 2020-09-26 11:41:33 PM [NestFactory] Starting Nest application...
[Nest] 9167 - 2020-09-26 11:41:33 PM [InstanceLoader] AppModule dependencies initialized +21ms
[Nest] 9167 - 2020-09-26 11:41:33 PM [RoutesResolver] AppController {}: +9ms
[Nest] 9167 - 2020-09-26 11:41:33 PM [RouterExplorer] Mapped {, GET} route +13ms
[Nest] 9167 - 2020-09-26 11:41:33 PM [RouterExplorer] Mapped {/index, GET} route +4ms
[Nest] 9167 - 2020-09-26 11:41:33 PM [RouterExplorer] Mapped {/dynamic, GET} route +5ms
[Nest] 9167 - 2020-09-26 11:41:33 PM [RoutesResolver] CatsController {/cats}: +4ms
[Nest] 9167 - 2020-09-26 11:41:33 PM [RouterExplorer] Mapped {/cats, GET} route +4ms
[Nest] 9167 - 2020-09-26 11:41:33 PM [NestApplication] Nest application successfully started +4ms

从输出中可以看出，/cats路由已经添加，当访问/cats的时候，会执行findAll()的方法，同时还是一个Get请求

新手入门NestJS（三）- 如何使用View

Mon, 14 Jul 2025 14:54:40 +0000

前面记录了如何安装Nest.js以及如何创建项目

都是很简单，没有太多可以介绍的，但是作为web开发，最关系的是如何调用视图（View）

官方也有文档，点击这里

1、如何展示一个页面

方式也很简单，主要原理是整合了express框架，然后通过express设置模版引擎，这里使用的模板引擎是hbs

我们看下如何配置

先安装hbs

npm install --save hbs

然后打开项目根目录下面的main.ts

将里面的bootstrap()方法修改如下

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

 app.setBaseViewsDir(join(__dirname, '..', 'views'));
 app.setViewEngine('hbs');

 await app.listen(3000);
}

上面的代码就是配置模版引擎

main.ts最后代码如下

import { Controller, Get, Render } from '@nestjs/common';
import { AppService } from './app.service';

@Controller()
export class AppController {
 constructor(private readonly appService: AppService) {}

 @Get()
 getHello(): string {
 return this.appService.getHello();
 }

 @Get('/index')
 @Render('index')
 getIndex() {
 return {};
 }
}

如何调用视图

1、在根目录（不是src目录）下创建public和views文件夹

2、在views目录中创建index.hbs

添加代码如下

<!DOCTYPE html>
<html>

<head>
 <meta charset="utf-8" />
 <title>App</title>
</head>

<body>
 Message
</body>

</html>

3、controller中调用视图（View）

代码如下

import { Controller, Get, Render, Res } from '@nestjs/common';
import { AppService } from './app.service';
import { Response } from 'express';

@Controller()
export class AppController {
 constructor(private readonly appService: AppService) {}

 @Get()
 getHello(): string {
 return this.appService.getHello();
 }

 @Get('/index')
 @Render('index')
 getIndex() {
 return {};
 }

 @Get('/dynamic')
 getDynamic(@Res() res: Response) {
 return res.render('index');
 }
}

其中官网也介绍了两种调用视图的方式

第一种，静态视图

@Get('/index')
@Render('index')
getIndex() {
 return {};
}

将视图文件的名称index，添加到Render修饰器里面，然后函数返回对应的变量值就可以了

第二种，动态视图，访问的路由一样的情况，需要根据逻辑来展示不同的视图

@Get('/dynamic')
getDynamic(@Res() res: Response) {
 return res.render('index');
}

方法中传入res参数并在参数前面加上@Res修饰器，然后调用res.render就可以了，这样配置后就可以正常写View了，后面记录下静态文件相关的使用

2、如何添加静态文件

修改main.ts

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

 // 添加静态文件目录配置
 app.useStaticAssets(join(__dirname, '..', 'public'));
 // 添加视图文件目录配置
 app.setBaseViewsDir(join(__dirname, '..', 'views'));
 app.setViewEngine('hbs');

 await app.listen(3000);
}

修改index.hbs

<!DOCTYPE html>
<html>

<head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1">
 <title>App</title>
 <link href="/bootstrap/css/bootstrap.min.css" rel="stylesheet" />
</head>

<body>
 <header>
 <nav class="navbar navbar-light bg-light">
 <div class="container-fluid">
 <a class="navbar-brand" href="#">Navbar</a>
 </div>
 </nav>
 </header>
 <div class='container'>
 Message
 </div>
 <script src="/bootstrap/js/bootstrap.min.js"></script>
</body>

</html>

同时在项目根目录下面建立public目录，添加自己的静态文件，我这里添加的是bootstrap的静态文件

3、如何动态的展示一个页面（页面参数传递）

修改app.controller.ts

import { Controller, Get, Render } from '@nestjs/common';
import { AppService } from './app.service';

@Controller()
export class AppController {
 constructor(private readonly appService: AppService) {}

 @Get()
 getHello(): string {
 return this.appService.getHello();
 }

 @Get('/index')
 @Render('index')
 getIndex() {
 return { message: 'Index Page' };
 }
}

修改index.hbs

<!DOCTYPE html>
<html>

<head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1">
 <title>App</title>
 <link href="/bootstrap/css/bootstrap.min.css" rel="stylesheet" />
</head>

<body>
 <header>
 <nav class="navbar navbar-light bg-light">
 <div class="container-fluid">
 <a class="navbar-brand" href="#">Navbar</a>
 </div>
 </nav>
 </header>

 <div class="container">
 {{ message }}
 </div>

 <script src="/bootstrap/js/bootstrap.min.js"></script>
</body>

</html>

新手入门NestJS（二）-如何安装 NestJS

Mon, 14 Jul 2025 14:54:37 +0000

Nest.js如何安装

这个过程其实官网也有 - 点击这里

这里做个简单的概述

1、安装nodejs

2、全局安装nest.js，命令如下

npm i -g @nestjs/cli

3、创建项目

nest new project-name

是不是很简单

4、运行项目

npm run start

如果是开发的话

npm run start:dev

新手入门NestJS（一）- 为什么选用NestJS

Mon, 14 Jul 2025 14:54:34 +0000

最近开发一个小的项目
出于几点考虑，最后选择了这个Nest.js

1、方便部署，部署不复杂
2、语法不难
3、提供了很多够用的工具

首先我想到的是用PHP的框架，毕竟用起来很方便，但是想来想去似乎php的安装有点复杂，也许有人会说，那么多提供了现成的php服务器，随便搞一个，部署起来很方便。
说的没错，但我的情况是，我想自己买台服务器，需要自己部署，因为别人部署的我也不是很放心
另外php的安装说实话，我头痛的几个问题就是，安装php的时候，你要知道自己项目用到了哪些扩展，需要根据这个扩展指定对应的安装参数，这个第一次安装还好，后期项目迁移就不好了
如果我有记录能一下子找到还好如果找不到，就比较头痛
估计也有人会说，现在的docker不是很好用，我想说的是，作为一个初来乍到的开发者，如果能给我足够的空间而且性价比高的话我会考虑的，一般一个docker安装下来出去本身代码大小，加上docker镜像的大小，空间很快被占用了
所以我比较熟悉的Laravel、Yii2等框架，我放弃了

于是开始思考我熟悉的另外一门用Python开发的框架，一个是Flask，一个是Django
思来想去，最后也是放弃了
第一个Django的重量级，以及配置的复杂性，Django是不考虑了。另外我自己以为很精简的Flask，虽然可扩展性高，但是社区似乎不活跃，经常用的库也是没有怎么更新了，关键是flask并没有经常更新，感觉不够火热
所以Flask，Laravel被我放弃了

最后熟悉的另外一门Javascript，后端Nodejs
让我眼前一亮，但是最近几年也不是很火
而且比较火的Express、Koajs等框架，也都是非常精简，至于工具的话，还是没有一个好的生态圈
但是唯一让我发下Nest.js这个框架还是不错的选择

第一个部署上就不说了，安装好node之后，代码库拉过来，install一下就可以部署完成
第二个语法真的不难，现在不管前端后端，稍微会程序开发的，Javascript还是多多少少就会的，外加Typescript的协助，可以在开发上很顺手
第三个工具够用，可以去官网看看文档，这里不多介绍
之后我在继续分享关于Nest.js的使用体验