前言
Deno 是一个新兴的 JavaScript 运行时环境，由 Node.js 的创始人 Ryan Dahl 所创建。Deno 具有许多优秀的特性，例如支持 TypeScript，内置模块化，安全性好等。在 Deno 中，设计模式和 SOLID 原则也是非常重要的，本文将会介绍 Deno 中常用的设计模式和 SOLID 原则，并给出相应的示例代码。
设计模式
1. 单例模式
单例模式是一种创建型设计模式，它保证一个类只有一个实例，并提供一个访问该实例的全局访问点。在 Deno 中，单例模式经常被用来管理全局状态或资源，例如全局配置、数据库连接等。
以下是一个示例代码：
// javascriptcn.com 代码示例
class Singleton {
private static instance: Singleton;
private constructor() {
// do something
}
public static getInstance(): Singleton {
if (!Singleton.instance) {
Singleton.instance = new Singleton();
}
return Singleton.instance;
}
// other methods...
}2. 工厂模式
工厂模式是一种创建型设计模式，它提供了一个创建对象的接口，但是让子类决定实例化哪个类。在 Deno 中，工厂模式经常被用来封装对象的创建，使得代码更加灵活和可扩展。
以下是一个示例代码：
// javascriptcn.com 代码示例
interface Product {
name: string;
}
class ProductA implements Product {
name = 'Product A';
}
class ProductB implements Product {
name = 'Product B';
}
class Factory {
public createProduct(name: string): Product {
switch (name) {
case 'A':
return new ProductA();
case 'B':
return new ProductB();
default:
throw new Error(`Unknown product: ${name}`);
}
}
}
// usage
const factory = new Factory();
const productA = factory.createProduct('A');
const productB = factory.createProduct('B');3. 观察者模式
观察者模式是一种行为型设计模式，它定义了对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖它的对象都会得到通知并自动更新。在 Deno 中，观察者模式经常被用来实现事件驱动的架构。
以下是一个示例代码：
// javascriptcn.com 代码示例
interface Observer {
update(data: any): void;
}
class Subject {
private observers: Observer[] = [];
public addObserver(observer: Observer): void {
this.observers.push(observer);
}
public removeObserver(observer: Observer): void {
const index = this.observers.indexOf(observer);
if (index >= 0) {
this.observers.splice(index, 1);
}
}
public notifyObservers(data: any): void {
for (const observer of this.observers) {
observer.update(data);
}
}
}
// usage
class ConcreteObserver implements Observer {
public update(data: any): void {
console.log(`Received data: ${data}`);
}
}
const subject = new Subject();
const observer = new ConcreteObserver();
subject.addObserver(observer);
subject.notifyObservers('hello');SOLID 原则
SOLID 原则是一组面向对象设计的原则，它们的目标是让软件更加易于理解、扩展、维护和重用。在 Deno 中，SOLID 原则也是非常重要的，它们可以帮助我们编写出高质量的代码。
1. 单一职责原则
单一职责原则（SRP）指的是一个类应该只有一个引起它变化的原因。换句话说，一个类应该只有一个职责。在 Deno 中，我们应该尽量遵守单一职责原则，这样可以使得代码更加清晰和易于维护。
以下是一个示例代码：
// javascriptcn.com 代码示例
class UserService {
public createUser(name: string, email: string): void {
// do something
}
public updateUser(id: number, name: string, email: string): void {
// do something
}
public deleteUser(id: number): void {
// do something
}
}在上面的代码中，UserService 负责用户的创建、更新和删除三个操作，它违反了单一职责原则。我们可以将其拆分成三个单独的类来解决这个问题。
2. 开闭原则
开闭原则（OCP）指的是软件实体（例如类、模块、函数等）应该对扩展开放，对修改关闭。在 Deno 中，我们应该尽量遵守开闭原则，这样可以使得代码更加灵活和可扩展。
以下是一个示例代码：
// javascriptcn.com 代码示例
interface Logger {
log(message: string): void;
}
class ConsoleLogger implements Logger {
public log(message: string): void {
console.log(message);
}
}
class FileLogger implements Logger {
public log(message: string): void {
// write message to file
}
}
class UserService {
private logger: Logger;
constructor(logger: Logger) {
this.logger = logger;
}
public createUser(name: string, email: string): void {
// do something
this.logger.log(`Created user: ${name} (${email})`);
}
}
// usage
const logger = new ConsoleLogger();
const userService = new UserService(logger);
userService.createUser('Alice', 'alice@example.com');在上面的代码中，UserService 依赖于一个 Logger 接口，而不是具体的实现。这样，我们可以随时切换不同的日志实现，而不需要修改 UserService 的代码。
3. 里氏替换原则
里氏替换原则（LSP）指的是子类型必须能够替换掉它们的父类型。换句话说，一个子类应该能够在不改变程序正确性的前提下替换掉它的父类。在 Deno 中，我们应该尽量遵守里氏替换原则，这样可以使得代码更加健壮和可维护。
以下是一个示例代码：
// javascriptcn.com 代码示例
class Rectangle {
constructor(public width: number, public height: number) {}
public getArea(): number {
return this.width * this.height;
}
}
class Square extends Rectangle {
constructor(public sideLength: number) {
super(sideLength, sideLength);
}
public setWidth(width: number): void {
this.width = width;
this.height = width;
}
public setHeight(height: number): void {
this.width = height;
this.height = height;
}
}
// usage
function printArea(rectangle: Rectangle): void {
console.log(`Area: ${rectangle.getArea()}`);
}
const rectangle = new Rectangle(5, 10);
const square = new Square(5);
printArea(rectangle);
printArea(square);
square.setWidth(10);
printArea(square);在上面的代码中，Square 继承自 Rectangle，但是它重写了 setWidth 和 setHeight 方法，使得它们不再遵守 Rectangle 的行为。这违反了里氏替换原则。我们可以通过将 Square 设计成一个独立的类来解决这个问题。
4. 接口隔离原则
接口隔离原则（ISP）指的是客户端不应该依赖于它不需要的接口。换句话说，一个类不应该强制依赖于它不使用的接口。在 Deno 中，我们应该尽量遵守接口隔离原则，这样可以使得代码更加清晰和易于维护。
以下是一个示例代码：
// javascriptcn.com 代码示例
interface UserService {
createUser(name: string, email: string): void;
}
interface UserQueryService {
getUserById(id: number): any;
getUserByEmail(email: string): any;
}
class UserServiceImpl implements UserService, UserQueryService {
public createUser(name: string, email: string): void {
// do something
}
public getUserById(id: number): any {
// do something
}
public getUserByEmail(email: string): any {
// do something
}
}
// usage
const userService = new UserServiceImpl();
userService.createUser('Alice', 'alice@example.com');
const user = userService.getUserById(1);在上面的代码中，UserServiceImpl 实现了 UserService 和 UserQueryService 两个接口。如果我们只需要使用 UserService，那么我们可以将 UserQueryService 设计成一个独立的接口，这样就不会引入不必要的依赖。
5. 依赖倒置原则
依赖倒置原则（DIP）指的是高层模块不应该依赖于低层模块，它们应该依赖于抽象接口。换句话说，依赖关系应该被颠倒过来，即高层模块依赖于抽象接口，而低层模块实现抽象接口。在 Deno 中，我们应该尽量遵守依赖倒置原则，这样可以使得代码更加灵活和可扩展。
以下是一个示例代码：
// javascriptcn.com 代码示例
interface UserRepository {
createUser(name: string, email: string): void;
getUserById(id: number): any;
getUserByEmail(email: string): any;
}
class UserService {
constructor(private userRepository: UserRepository) {}
public createUser(name: string, email: string): void {
this.userRepository.createUser(name, email);
}
public getUserById(id: number): any {
return this.userRepository.getUserById(id);
}
public getUserByEmail(email: string): any {
return this.userRepository.getUserByEmail(email);
}
}
// usage
class InMemoryUserRepository implements UserRepository {
private data: any[] = [];
public createUser(name: string, email: string): void {
this.data.push({ id: this.data.length + 1, name, email });
}
public getUserById(id: number): any {
return this.data.find((user) => user.id === id);
}
public getUserByEmail(email: string): any {
return this.data.find((user) => user.email === email);
}
}
const userRepository = new InMemoryUserRepository();
const userService = new UserService(userRepository);
userService.createUser('Alice', 'alice@example.com');
const user = userService.getUserById(1);在上面的代码中，UserService 依赖于一个 UserRepository 接口，而不是具体的实现。这样，我们可以随时切换不同的 UserRepository 实现，而不需要修改 UserService 的代码。
总结
本文介绍了 Deno 中常用的设计模式和 SOLID 原则，并给出了相应的示例代码。设计模式和 SOLID 原则是编写高质量代码的重要手段，它们可以使得代码更加灵活、可扩展、可维护和可重用。在实际开发中，我们应该尽量遵守这些原则，以提高代码的质量和效率。
来源：JavaScript中文网 ，转载请注明来源 本文地址：https://www.javascriptcn.com/post/65576b1bd2f5e1655d1d2255