Nest 使用笔记
前置篇:TypeScript——Nest 课前的 TS 速览
NestJS 课前要备好的 TypeScript:基础类型、泛型与 keyof、工具类型、类/接口/抽象类、装饰器,最后用一个泛型 Repository 综合案例串起来。
- Nest
- Node.js
- TS
TypeScript介绍
TypeScript 是 Microsoft 开发的一款开源脚本语言,它的编译器同样是开源的。TypeScript 在 JavaScript 的基础上加入了静态类型系统,最初是为了解决 JavaScript 代码规模变大后出现的类型问题;同时它还增加了一些 JavaScript 没有的高级特性,例如装饰器、接口、泛型等。
TypeScript 更接近 Java、C++、PHP 等面向对象语言,适合用来开发大型企业级应用。它是专为 JavaScript 大规模应用而设计的,包含 JavaScript 现有的所有功能。TypeScript 代码需要先编译成 JavaScript 才能运行,编译后可以运行在任意浏览器或 Node.js 环境中。
为什么要学习TS
TypeScript 是目前较为流行的编程语言,属于强类型语言,拥有一套类型机制,可以在编译时进行类型检查,从而提高代码的编写效率。它在 JavaScript 语法的基础上,重点解决了 JavaScript 自身类型系统的不足。TypeScript 拥有面向对象编程语言的主要特性,相比 JavaScript,使用 TypeScript 可以明显提升代码的可靠程度。
TypeScript与JavaScript对比有什么优势
TypeScript 可以使用 JavaScript 中的所有代码,它是为了方便 JavaScript 的开发而创建的。相比 JavaScript,TypeScript 有以下优势:
- 引入了”类”和”模块”的概念,可以把数据、函数和类封装到模块中。
- 可以在编码时检查错误,有助于提高开发效率。
- 面向对象的特性增加了代码的可读性。
- 使代码的重构变得更加容易。
- 适合用于开发大型应用。
| 对比项目 | JavaScript | TypeScript |
|---|---|---|
| 类型 | 弱类型 | 强类型 |
| 模块化 | 不支持 | 支持 |
| 泛型 | 不支持 | 支持 |
| 接口 | 不支持 | 支持 |
| 浏览器使用 | 支持 | 不支持(需编译) |
安装TS
npm install -g typescript
打开终端输入 tsc -v 可以查看 TS 的版本号。
创建Ts程序文件
例如创建 demo.ts,内容如下:
const text: string = "hello world";
console.log(text);
终端中输入 tsc demo.ts && node demo.js:
tsc demo.ts把 ts 文件编译成 js 文件。node demo.js执行 js 文件并输出结果。
TS中的数据类型
TypeScript 支持 JavaScript 的全部基础类型,并额外提供了枚举、元组、字面量类型等。下面是常用数据类型的写法:
// 字符串
const str: string = "hello";
// 数字
const num: number = 100;
// 布尔值
const flag: boolean = true;
// 空对象
const n: null = null;
// 未定义
const u: undefined = undefined;
// 唯一标识
const s: symbol = Symbol();
// 大整数
const b: bigint = 123n;
// 数组 [] / Array<T>
const arr1: number[] = [1, 2, 3];
const arr2: Array<string> = ["a", "b"];
// 对象类型
const obj: { name: string; age: number } = { name: "张三", age: 18 };
// 元组 Tuple:已知长度和每个位置类型的数组
const tuple: [string, number] = ["ts", 2026];
// 函数类型
type Fn = (a: number, b: number) => number;
const add: Fn = (x, y) => x + y;
// void:函数没有返回值
function log(): void {
console.log("test");
}
// never:永远不会正常返回(死循环、抛出异常)
function error(): never {
throw new Error("报错");
}
// any:任意类型,关闭类型检查(尽量少用)
let data: any = 999;
data = "abc";
// unknown:类型安全的 any,不能直接操作,必须先做类型缩小
let unk: unknown = "hello";
// unk.toUpperCase(); // 报错:unknown 不能直接调用方法
if (typeof unk === "string") {
unk.toUpperCase(); // 正确:这里已经收窄为 string
}
// 枚举类型
enum Status {
Success = 200,
Error = 500,
}
// 复合高级常用类型
// 1. 联合类型 |
let v: string | number;
// 2. 交叉类型 &
type A = { name: string };
type B = { age: number };
type C = A & B;
// 3. 字面量类型
type Dir = "left" | "right";
let d: Dir = "left";
// 4. Record:键值对映射,键类型 K,值类型 V
const scores: Record<string, number> = {
math: 90,
english: 85,
};
函数的重载
函数重载允许同一个函数名根据不同的参数类型,返回不同类型的结果。重载由多组重载签名和一份实现签名组成:
function load(a: number): number;
function load(a: string): string;
// 实现签名,对外不可见,必须兼容所有重载
function load(a: number | string): number | string {
return a;
}
load(1); // 返回 number
load("1"); // 返回 string
// load(true); // 报错:没有匹配的重载
对象声明
声明对象类型时,可以标记属性为只读、必选或可选:
let obj: {
readonly bookName: string; // 只读属性,初始化后不能再修改
bookPrice: number; // 必选属性
author?: string; // 可选属性,可以不存在
};
泛型中的extends/keyof
在泛型中,extends 不再表示”继承”,而是表示约束,用来限制泛型参数必须满足某种结构。
interface HasLength {
length: number;
}
// 约束 T 必须具有 length 属性
function logLength<T extends HasLength>(arg: T): T {
console.log(arg.length);
return arg;
}
logLength("hello"); // 字符串有 length,正确
logLength([1, 2, 3]); // 数组有 length,正确
// logLength(123); // 报错:number 没有 length 属性
把 extends 和 keyof 结合起来,就能安全地读取对象的属性,并自动推导返回值类型:
function getProp<T, K extends keyof T>(obj: T, key: K): T[K] {
return obj[key];
}
const user = { name: "张三", age: 18 };
getProp(user, "name"); // 返回 string
getProp(user, "age"); // 返回 number
// getProp(user, "sex"); // 报错:"sex" 不是 user 的属性
条件类型
条件类型类似三元表达式,根据类型关系判断结果。这里的 extends 表示”约束 / 是否可赋值”,而不是继承:
// X 是否能赋值给 Y,是返回 true,否则返回 false
type condition<X, Y> = X extends Y ? true : false;
type r1 = condition<10, 10>; // true
type r2 = condition<"a", "b">; // false
// 类型适配:根据传入类型决定结果是 number 还是 string
type condition<T> = T extends number ? number : string;
type num = condition<1>; // number
type str = condition<"1">; // string
let a: num = 1;
let b: str = "1";
条件判断联合类型
当 extends 右侧是联合类型时,会把左侧分发到联合的每个成员上分别判断:
type x = "a";
type y = "a" | "b";
type z = x extends y ? string : number; // string
let str: z = "a";
console.log("str的类型为:" + typeof str);
keyof
keyof 是类型运算符,接收一个对象类型,返回它所有属性名组成的联合字面量类型。它只在编译期生效,属于类型层面的操作,编译后会被擦除。
// 基本用法
interface User {
name: string;
age: number;
}
// keyof User → "name" | "age"
type UserKey = keyof User;
let k: UserKey = "name"; // 正确
k = "age"; // 正确
// k = "sex"; // 报错
// 作用于对象字面量类型
type Obj = { id: number; title: string };
type K = keyof Obj; // "id" | "title"
// 作用于基础类型,得到该类型原型上的所有属性
type T1 = keyof string;
// number | "toString" | "charAt" | ... 字符串原型上的所有属性
type T2 = keyof number;
// number 原型方法的联合类型
映射类型
映射类型可以基于已有类型按规则生成新类型,TypeScript 内置了一批常用的工具类型。
- 1.Partial:把所有属性变成可选属性。
type Book = {
bookName: string;
bookNumber: number;
};
type R = Partial<Book>;
/*
type R = {
bookName?: string;
bookNumber?: number;
}
*/
- 2.Required:把所有可选属性变成必选属性。
type Book = {
bookName?: string;
bookNumber?: number;
};
type R = Required<Book>;
/*
type R = {
bookName: string;
bookNumber: number;
}
*/
- 3.Readonly:把所有属性变成只读属性。
type Book = {
bookName: string;
bookNumber: number;
};
type R = Readonly<Book>;
/*
type R = {
readonly bookName: string;
readonly bookNumber: number;
}
*/
- 4.Pick:从已有类型中挑选出指定的属性。
type Book = {
bookName: string;
bookNumber: number;
author: string;
};
type R = Pick<Book, "bookName" | "author">;
/*
type R = {
bookName: string;
author: string;
}
*/
- 5.Omit:从已有类型中排除指定的属性。
type Book = {
bookName: string;
bookNumber: number;
author: string;
};
type R = Omit<Book, "bookName" | "author">;
/*
type R = {
bookNumber: number;
}
*/
- 6.Exclude:从联合类型中排除可赋值给指定类型的成员。
type Book = {
bookName: string;
bookNumber: number;
author: string;
};
type R = Exclude<keyof Book, "bookName">;
/*
type R = "bookNumber" | "author";
*/
- 7.Record:构造一个键类型为 K、值类型为 V 的对象类型。它本质上就是一个映射类型
{ [P in K]: V },常用来做键值对映射。
// 键 K 只能是 string | number | symbol 的联合
type ErrorCode = 400 | 404 | 500;
type StatusMap = Record<ErrorCode, string>;
const statusMap: StatusMap = {
400: "参数错误",
404: "资源不存在",
500: "服务器错误",
};
// 字符串键的键值对映射
const scores: Record<string, number> = {
math: 90,
english: 85,
};
其它常用工具类型
除了上面的映射类型工具,还有几个在日常开发(尤其是 NestJS 里写 DTO、推断类型时)非常常用:
// 1. ReturnType:获取函数的返回值类型
function getUser() {
return { name: "张三", age: 18 };
}
type UserResult = ReturnType<typeof getUser>;
// { name: string; age: number }
// 2. Parameters:获取函数参数组成的元组类型
type AddFn = (a: number, b: string) => boolean;
type AddArgs = Parameters<AddFn>;
// [a: number, b: string]
// 3. ReadonlyArray / readonly T[]:只读数组,不能 push、pop,也不能改下标
const list: ReadonlyArray<number> = [1, 2, 3];
// list.push(4); // 报错:只读数组没有 push 方法
// list[0] = 9; // 报错:只读数组不能赋值
类型收窄
定义:将不精确的类型推导为精确类型的过程。常见的收窄方式包括 typeof、instanceof、相等判断等。
function testMethod(x: string | Date, y: string) {
if (x === y) {
// 这里 x 收窄为 string
} else if (x instanceof Date) {
// 这里 x 收窄为 Date
}
}
类的使用
public:可以在类的内部和外部访问,也是默认修饰符。private:只能在类的内部访问,子类和其他类的实例都无法访问。protected:只能在类的内部和子类中访问,其他类的实例无法访问。
class Book {
private bookName: string = "TypeScript";
public bookNumber: number = 123456;
protected libraryName: string = "市民图书馆";
}
抽象类
TypeScript 的抽象类是一种不能被实例化的特殊类,通过关键字 abstract 声明。抽象类既可以包含具体的属性和方法,也可以包含抽象方法。抽象方法同样用 abstract 声明,且只能出现在抽象类中。
大多数情况下,抽象类用来做属性和方法的约束,要求子类必须拥有指定的属性和方法。
abstract class Library {
libraryName: string = "图书馆";
constructor(libraryName: string) {
this.libraryName = libraryName;
}
// 抽象方法,只有声明没有实现
abstract output(): void;
}
class Book extends Library {
// 子类必须实现抽象方法
output() {
console.log("名称 : ", this.libraryName);
}
}
interface(接口)
TypeScript 接口的定义和 Java 接口类似。接口只给出属性和方法的约定,并不给出具体实现,它是一系列抽象属性和方法的声明。接口中的方法都是抽象的,需要由具体的类去实现。接口可以理解为一种规范的定义,在程序中起到限制和规范的作用。
interface Animal {
name: string;
age: number;
call: () => string;
}
const dog: Animal = {
name: "旺柴",
age: 3,
call: () => "汪汪",
};
接口可以被 class 实现。一个类只能继承一个父类,但可以实现多个接口;实现接口的类必须完成接口中所有的定义。接口比抽象类更轻量和灵活。
class Cat implements Animal {
name: string;
age: number;
constructor(name: string, age: number) {
this.name = name;
this.age = age;
}
call() {
return "喵喵";
}
}
泛型
泛型是程序语言中的一种特性,可以提高代码的重用性。泛型把类型参数化:当两个方法的功能相似、参数个数一致、只是参数类型不同时,就可以用泛型把它们合并成一个方法。可以把泛型理解为”类型的变量”。
class A<T> {
constructor(private readonly generic: T) {}
}
// 调用时传入具体的类型
const a = new A<boolean>(true);
const b = new A<number>(100);
// 在类方法中使用类层级泛型 T
class Container<T> {
constructor(private readonly generic: T) {}
// 直接使用类定义的泛型 T
getValue(): T {
return this.generic;
}
// 参数使用 T(如果 generic 不是 readonly,可以赋值)
setValue(val: T): void {
// this.generic = val;
}
}
const ins = new Container<number>(100);
const v = ins.getValue(); // v: number
// 方法额外定义独立泛型(方法自有泛型,和类 T 互不干扰)
class Mapper<T> {
constructor(private readonly generic: T) {}
// <U> 是方法自己的泛型,仅当前方法有效
map<U>(fn: (origin: T) => U): U {
return fn(this.generic);
}
}
const ins = new Mapper<string>("hello");
const res = ins.map((s) => s.length); // res: number
装饰器
装饰器是一种特殊类型的声明,主要作用是给已有的类、方法、属性或参数添加新的行为。常见的装饰器有类装饰器、属性装饰器、方法装饰器和参数装饰器。根据写法可以分为普通装饰器和装饰器工厂,区别在于普通装饰器不能传参,而装饰器工厂可以传参。
要想使用装饰器,需要先在 tsconfig.json 中开启 experimentalDecorators。在项目目录中执行 tsc --init 会自动生成 tsconfig.json,关键字段如下:
{
"compilerOptions": {
"target": "es2016",
"module": "nodenext",
"strict": true,
"experimentalDecorators": true,
"sourceMap": true,
"skipLibCheck": true
}
}
1. 类装饰器
类装饰器接收被装饰的类作为参数,可以替换或扩展这个类。下面是一个带日志的类装饰器:
function Log<T extends new (...args: any[]) => any>(target: T): T {
return class extends target {
constructor(...args: any[]) {
super(...args);
console.log(`创建实例:${target.name}`);
}
};
}
@Log
class User {
constructor(public name: string) {}
}
new User("张三"); // 控制台输出:创建实例:User
2. 方法装饰器
方法装饰器接收三个参数:类的原型、方法名、属性描述符。下面是一个打印方法耗时的方法装饰器:
function LogTime(
target: any,
propertyKey: string,
descriptor: PropertyDescriptor,
) {
const original = descriptor.value;
descriptor.value = function (...args: any[]) {
console.time(propertyKey);
const result = original.apply(this, args);
console.timeEnd(propertyKey);
return result;
};
return descriptor;
}
class Calculator {
@LogTime
sum(a: number, b: number): number {
return a + b;
}
}
new Calculator().sum(1, 2); // 控制台输出 sum: 0.x ms
装饰器是 NestJS 的核心机制之一,NestJS 中的 @Controller()、@Get()、@Injectable() 等本质上都是装饰器工厂。
综合案例
下面把接口、泛型约束、类装饰器、方法装饰器组合起来,模拟一个 NestJS 风格的”泛型数据访问层”,这是理解 NestJS Provider 和 Repository 思想的雏形。
// 1. 用 interface 定义实体结构
interface BaseEntity {
id: number;
}
interface User extends BaseEntity {
name: string;
age: number;
}
// 2. 类装饰器:给 Repository 打日志
function LogClass<T extends new (...args: any[]) => any>(target: T): T {
return class extends target {
constructor(...args: any[]) {
super(...args);
console.log("实例化 Repository");
}
};
}
// 3. 方法装饰器:打印方法调用与参数
function LogMethod(
target: any,
key: string,
desc: PropertyDescriptor,
): PropertyDescriptor {
const fn = desc.value;
desc.value = function (...args: any[]) {
console.log(`调用 ${key},参数:`, args);
return fn.apply(this, args);
};
return desc;
}
// 4. 泛型 + 约束:T 必须满足 BaseEntity
@LogClass
class Repository<T extends BaseEntity> {
constructor(private list: T[]) {}
@LogMethod
findById(id: number): T | undefined {
return this.list.find((item) => item.id === id);
}
}
// 使用
const userRepo = new Repository<User>([
{ id: 1, name: "张三", age: 18 },
{ id: 2, name: "李四", age: 20 },
]);
userRepo.findById(1); // 控制台输出:调用 findById,参数:[1]
这个案例串起了 NestJS 前置的几个关键 TS 能力:用接口约束数据结构、用泛型 extends 复用代码、用装饰器在不修改业务逻辑的前提下附加横切逻辑。