Fünf Designmuster, die Sie in Node.js kennen sollten

Hey!

Ich habe kürzlich mehrere Wissensressourcen durchgesehen, um mehr über beliebte Design- und Architekturmuster in Node.js zu erfahren. Mein Ziel lag hauptsächlich auf der Serverseite (Backend), aber als ich sie durchging, fielen mir viele Ähnlichkeiten mit den Browser-Frameworks (Frontend) auf. Einige davon werden sogar direkt in den Frameworks verwendet, worüber ich mich umso mehr freue, weil ich sie bereits verwendet habe, ohne es zu wissen?

Es gibt viele (wirklich viele) Designmuster, die Sie verwenden können. Deshalb habe ich in diesem Artikel beschlossen, 10 davon auszuwählen und sie detaillierter zu erklären.

Viel Spaß!

? Was ist ein Designmuster?

Entwurfsmuster sind bewährte und kampferprobte Lösungen zur Lösung von Problemen, mit denen wir als Entwickler täglich konfrontiert sind. Diese Muster tragen dazu bei, Best Practices zu fördern und einen strukturierten Ansatz zur Lösung alltäglicher Probleme beim Entwerfen und Entwickeln von Softwarearchitekturen zu implementieren. Softwareentwickler können mithilfe dieser Muster wartbare, sichere und stabile Systeme entwickeln.

Node.js zwingt Sie aufgrund seiner Flexibilität nicht dazu, sich an bestimmte Muster zu halten, sondern gibt Ihnen stattdessen die Freiheit, nur diejenigen auszuwählen, die Sie für Ihre Aufgabe benötigen. Deshalb ist es meiner Meinung nach heute so weit verbreitet (und nebenbei dank JavaScript :D).

✅ Fünf beliebte Designmuster in Node.js

Unten sehen Sie eine Liste mit 5 ausgewählten Designmustern, die mir gefallen.

Singleton

Bei diesem Muster geht es um Klassen, die nur eine Instanz haben und globalen Zugriff darauf bieten können. Module können in Node.js zwischengespeichert und in der gesamten Anwendung gemeinsam genutzt werden, was zur Verbesserung der Ressourceneffizienz beiträgt. Ein häufiges Beispiel für ein solches Singleton-Muster ist ein Modul zur Verbindung mit bestimmten Drittanbieterdiensten wie Datenbanken, Cache-Diensten, E-Mail-Anbietern usw., das im Nest.js-Framework häufig verwendet wird. Schauen wir uns das folgende Beispiel an:

class Redis {
  constructor() {
    this.connection = null;
  }

  static getInstance() {
    if (!Redis. instance) {
      Redis.instance = new Redis(options);
    }

    Return Redis.instance;
  }

  connect() {
    this.connection = 'Redis connected'
  }
}

Und dann können wir es wie folgt verwenden:

const medicine = Redis.getInstance();
const redisTwo = Redis.getInstance();

console.log(redisOne === RedisTwo); // it will result to `true`

redisOne.connect();

console.log(redisOne.connection) // 'Redis connected'
console.log(redisTwo.connection) // 'Redis connected'

Dieser Ansatz stellt sicher, dass nur eine Verbindung zu Redis besteht und verhindert doppelte Verbindungen.

Fabrik

Mit diesem Muster können Sie neue Objekte erstellen, ohne die Klasse des zu erstellenden Objekts anzugeben. Dadurch abstrahieren wir die Objekterstellung, was dazu beitragen kann, die Lesbarkeit und Wiederverwendbarkeit des Codes zu verbessern:

class Character {
  constructor(name, health) {
    this.name = name;
    this.health = health;
  }
}

class CharacterFactory {
  createCharacter(name) {
    switch(name) {
      case 'mage': 
        return new Character('Powerful Mage', 8);
      case 'warrior':
        return new Character('Courageous Warrior', 10);
      case 'rogue':
        return new Character('Sneaky Rogue', 9)
      default:
        return new Error('Unknown character');
    }
  }
}

Und dann können wir es wie folgt verwenden:

const characterFactory = new CharacterFactory();

const mage = characterFactory.createCharacter('mage');
const warrior = characterFactory.createCharacter('warrior');

console.log(mage.name) // Powerful Mage
console.log(warrior.name) // Courageous Warrior

Dieser Ansatz ermöglicht es Verbrauchern dieser Factory, den Factory-Code zu verwenden, anstatt den Character-Klassenkonstruktor direkt zu verwenden.

Beobachter

Dieses Muster funktioniert so, dass Sie über eine Entität verfügen, die die Liste der abhängigen Elemente, sogenannte Beobachter, verwaltet und sie benachrichtigt, wenn sich der Status ändert. Dieses Muster wird häufig im Vue.js-Framework verwendet und kann wie folgt implementiert werden:

class Topic {
  constructor() {
    this.observers = []; 
  }

  subscribe(observer) {
    this.observers.push(observer);
  }

  unsubscribe(observer) {
    this.observers = this.observers.filter(o => o !== observer);
  }

  notify(data) {
    this.observers.forEach(o => o.update(data));
  }
}

class Observer {
  constructor(name) {
    this.name = name;
  }

  update(data) {
    console.log(`${this.name} received ${data}`);
  }
}

Und Sie können es wie folgt verwenden:

const topic = new Topic();

const observer1 = new Observer('Observer 1');
const observer2 = new Observer('Observer 2');

topic.subscribe(observer1);
topic.subscribe(observer2);

topic.notify('Hello World');
// Observer 1 received Hello World 
// Observer 2 received Hello World

topic.unsubscribe(observer2);

topic.notify('Hello Again');
// Observer 1 received Hello Again

Es ist ein wirklich nützliches Muster für die Ereignisbehandlung und asynchrone Arbeitsabläufe, das die Aktualisierung mehrerer Objekte ermöglicht, ohne den Herausgeber an die Abonnenten zu koppeln.

Dekorateur

Dieses Muster ist sehr nützlich, um die vorhandene Funktionalität durch eine neue zu erweitern, ohne die ursprünglichen/ursprünglichen Instanzen zu beeinträchtigen. Dank der vollständigen Unterstützung von TypeScript wird es im Nest.js-Framework häufig verwendet, in regulären Node.js kann es jedoch wie folgt verwendet werden:

class Character {
  constructor() {
    this.endurance = 10;
  }

  getEndurance() {
    return this.endurance;
  }
}

class CharacterActions {
  constructor(character) {
    this.character = character;
  }

  attack() {
    this.character.endurance -= 2;
  }

  rest() {
    this.character.endurance += 1; 
  }
}

Und dann kann es wie folgt verwendet werden:

const character = new Character();

console.log(character.getEndurance()); // 10

const characterWithActions = new CharacterActions(character);

characterWithActions.attack(); // - 2
characterWithActions.rest(); // + 1

console.log(characterWithActions.character.getEndurance()); // 9

Durch die Verwendung dieses Musters können wir bereits vorhandene Klassen problemlos erweitern, ohne ihre Kernfunktionalität zu beeinträchtigen.

Abhängigkeitsinjektion

In diesem Muster erhalten Klassen oder Module Abhängigkeiten von externen Quellen, anstatt sie intern zu registrieren. Mit diesem Ansatz können Sie bestimmte wiederverwendbare Elemente aus Ihrem System extrahieren, um Tests und Wartung zu vereinfachen. Es wird im Nest.js-Framework recht häufig verwendet. Es kann wie folgt implementiert werden:

class UserService {
  constructor(databaseService, loggerService) {
    this.db = databaseService;
    this.logger = loggerService;
  }

  async getUser(userId) {
    const user = await this.db.findUserById(userId);
    this.logger.log(`Fetched user ${user.name}`);
    return user;
  }
}

Und dann können Sie es wie folgt verwenden:

const databaseService = new Database();
const loggerService = new Logger();

const userService = new UserService(databaseService, loggerService);

userService.getUser(1);

Mit diesem Ansatz können Sie Elemente Ihres Systems in unabhängige Einheiten extrahieren, die bei Bedarf eingefügt werden können.

? Erfahren Sie mehr

Wenn Sie mehr über Vue, Nuxt, JavaScript oder andere nützliche Technologien erfahren möchten, besuchen Sie VueSchool, indem Sie auf diesen Link oder auf das Bild unten klicken:

Es behandelt die wichtigsten Konzepte beim Erstellen moderner Vue- oder Nuxt-Anwendungen, die Ihnen bei Ihrer täglichen Arbeit oder Nebenprojekten helfen können?

✅ Zusammenfassung

Gut gemacht! Sie haben gerade gelernt, wie bestimmte Designmuster in Node.js funktionieren und wie Sie sie implementieren.

Mach's gut und bis zum nächsten Mal!

Und wie immer viel Spaß beim Codieren ?️

Das obige ist der detaillierte Inhalt vonFünf Designmuster, die Sie in Node.js kennen sollten. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!