Technologieaustausch

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Entwurfsmuster sind allgemeine Lösungen für häufige Probleme beim Softwaredesign. Im Folgenden sind einige gängige Entwurfsmuster aufgeführt, die in drei Hauptkategorien unterteilt sind: Gestaltungsmuster, Strukturmuster und Verhaltensmuster.

Schöpfungsmuster

Diese Muster stellen Mechanismen für die Objekterstellung bereit und erhöhen so die Flexibilität und Wiederverwendbarkeit von vorhandenem Code.

1. Singleton-Muster：

   • Stellen Sie sicher, dass es nur eine Instanz einer Klasse gibt, und stellen Sie einen globalen Zugriffspunkt bereit.

2. Factory-Methodenmuster：

   • Definieren Sie die Schnittstelle zum Erstellen von Objekten und lassen Sie Unterklassen entscheiden, welche Klasse instanziiert werden soll.

3. Abstraktes Fabrikmuster (Abstrakte Fabrik)：

   • Erstellen Sie Familien verwandter oder abhängiger Objekte, ohne explizit konkrete Klassen anzugeben.

4. Builder-Muster (Builder)：

   • Erstellen Sie ein komplexes Objekt und ermöglichen Sie den schrittweisen Aufbau.

5. Prototyp：

   • Erstellen Sie eine neue Instanz, indem Sie eine vorhandene Instanz kopieren, anstatt eine neue zu erstellen.

Strukturelle Muster

Diese Muster befassen sich mit Kombinationen von Objekten oder Beziehungen zwischen Objekten und ihnen.

1. Adaptermodus：

   • Ermöglicht die Lösung von Schnittstelleninkompatibilitäten zwischen Objekten über einen „Adapter“.

2. Dekorationsmuster (Dekorateur)：

   • Fügen Sie einem Objekt dynamisch zusätzliche Verantwortlichkeiten hinzu.

3. Proxy-Modus (Proxy)：

   • Stellt einen Stellvertreter oder Platzhalter für ein anderes Objekt bereit, um den Zugriff darauf zu steuern.

4. Fassade：

   • Bietet eine einheitliche High-Level-Schnittstelle für den Zugriff auf eine Gruppe von Schnittstellen im Subsystem.

5. Bridge-Modus (Bridge)：

   • Trennen Sie den abstrakten Teil von seiner Implementierung, damit sie unabhängig voneinander variieren können.

6. Composite-Modus：

   • Gruppieren Sie Objekte in einer Baumstruktur, um eine Teil-Ganze-Hierarchie darzustellen.

7. Fliegengewichtsmodus：

   • Unterstützen Sie effizient eine große Anzahl feinkörniger Objekte durch gemeinsame Nutzung.

Verhaltensmuster

Diese Muster konzentrieren sich auf die Kommunikation zwischen Objekten, also darauf, wie Objekte miteinander interagieren und wie sie Verantwortlichkeiten verteilen.

1. Strategie：

   • Definieren Sie eine Reihe von Algorithmen, kapseln Sie sie einzeln und machen Sie sie austauschbar.

2. Vorlagenmethodenmuster (Vorlagenmethode)：

   • Definieren Sie den Rahmen des Algorithmus in der Methode und verschieben Sie die Implementierung auf Unterklassen.

3. Beobachtermuster (Beobachter)：

   • Eins-zu-viele-Abhängigkeitsbeziehung zwischen Objekten: Wenn ein Objekt seinen Status ändert, werden alle davon abhängigen Objekte benachrichtigt und automatisch aktualisiert.

4. Iteratormuster (Iterator)：

   • Greifen Sie nacheinander auf einzelne Elemente in einem Aggregatobjekt zu, ohne dessen interne Darstellung offenzulegen.

5. Modell der Verantwortungskette：

   • Geben Sie mehreren Objekten die Möglichkeit, die Anfrage zu bearbeiten, und vermeiden Sie so eine Kopplung zwischen Sender und Empfänger der Anfrage.

6. Befehlsmodus (Befehl)：

   • Kapselt die Anfrage als Objekt und ermöglicht es dem Benutzer, den Client mit verschiedenen Anfragen zu parametrisieren.

7. Erinnerungsmodus：

   • Erfassen Sie den internen Zustand eines Objekts und speichern Sie diesen Zustand außerhalb des Objekts, ohne die Kapselung zu zerstören.

8. Zustandsmodus：

   • Ermöglicht einem Objekt, sein Verhalten zu ändern, wenn sich sein interner Zustand ändert.

9. Besuchermodus：

   • Fügen Sie einer Objektstruktur (z. B. einer Verbundstruktur) neue Funktionen hinzu.

10. Mediatormuster：

    • Definieren Sie ein Zwischenobjekt, um die Interaktion zwischen Originalobjekten zu vereinfachen.

11. Dolmetschermodus (Interpreter)：

    • Definieren Sie eine grammatikalische Darstellung einer Sprache und interpretieren Sie die in dieser Sprache definierten Sätze.

Während des letzten Interviews wurde ich nach der Verwendung von Code zur Implementierung des Abonnenten-Herausgeber-Musters gefragt. Ich hatte Zeit, diese Entwurfsmuster mit js-Code zu simulieren.

Zum Beispiel

class PubSub {
  constructor() {
    this.events = {}; // 存储事件名称和对应的订阅者回调函数数组
  }

  // 订阅事件
  subscribe(event, callback) {
    if (!this.events[event]) {
      this.events[event] = []; // 如果事件不存在，初始化一个空数组
    }
    this.events[event].push(callback); // 将回调函数添加到订阅者的数组
  }

  // 取消订阅事件
  unsubscribe(event, callback) {
    if (!this.events[event]) {
      return;
    }
    this.events[event] = this.events[event].filter(cb => cb !== callback); // 移除指定的回调函数
  }

  // 取消特定事件的所有订阅
  unsubscribeAll(event) {
    if (this.events[event]) {
      delete this.events[event]; // 删除所有订阅者
    }
  }

  // 触发事件，使用 emit 作为方法名
  emit(event, data) {
    if (this.events[event]) {
      // 执行所有订阅者的回调函数
      this.events[event].forEach(callback => callback(data));
    }
  }

  // 检查是否有订阅者
  hasSubscribers(event) {
    return this.events[event] && this.events[event].length > 0;
  }
}

// 使用示例
const eventCenter = new PubSub();

// 订阅 'message' 事件
eventCenter.subscribe('message', (data) => {
  console.log(`Message received: ${data}`);
});

// 订阅 'greet' 事件
eventCenter.subscribe('greet', (name) => {
  console.log(`Hello, ${name}!`);
});

// 触发 'message' 事件
eventCenter.emit('message', 'Hello, Pub/Sub!');

// 触发 'greet' 事件
eventCenter.emit('greet', 'World');

// 取消对 'message' 事件的订阅
const myCallback = (data) => {
  console.log(`My callback received: ${data}`);
};
eventCenter.subscribe('message', myCallback);
eventCenter.unsubscribe('message', myCallback);

// 再次触发 'message' 事件，myCallback 不会被调用
eventCenter.emit('message', 'This message will not be received by myCallback');
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

In diesem Beispiel,PubSub Die Klasse bietet die folgende Funktionalität:

• subscribe Mit dieser Methode können Abonnenten eine Rückruffunktion für ein bestimmtes Ereignis registrieren.
• unsubscribe Mit dieser Methode können Abonnenten ihre Rückruffunktionen von bestimmten Ereignissen abmelden.
• unsubscribeAll Die Methode kündigt alle Abonnements für ein bestimmtes Ereignis.
• emit Die Methode löst das Ereignis aus und führt die Callback-Funktionen aller Teilnehmer aus.
• hasSubscribers Methode prüft, ob Abonnenten für ein bestimmtes Ereignis vorhanden sind.