Condivisione della tecnologia

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

I design pattern sono soluzioni generali a problemi comuni nella progettazione del software. Di seguito sono riportati alcuni modelli di progettazione comuni, suddivisi in tre categorie principali: modelli creazionali, modelli strutturali e modelli comportamentali.

Modelli Creazionali

Questi modelli forniscono meccanismi per la creazione di oggetti, aumentando la flessibilità e la riusabilità del codice esistente.

1. Modello singleton：

   • Assicurati che ci sia una sola istanza di una classe e fornisci un punto di accesso globale.

2. Modello del metodo di fabbrica：

   • Definisci l'interfaccia per la creazione di oggetti e lascia che le sottoclassi decidano quale classe istanziare.

3. Modello astratto di fabbrica (Fabbrica astratta)：

   • Crea famiglie di oggetti correlati o dipendenti senza specificare esplicitamente classi concrete.

4. Modello costruttore (Costruttore)：

   • Costruisci un oggetto complesso e consenti la costruzione passo dopo passo.

5. Prototipo：

   • Crea una nuova istanza copiando un'istanza esistente, anziché crearne una nuova.

Modelli strutturali

Questi modelli riguardano combinazioni di oggetti o relazioni tra gli oggetti e loro.

1. Modalità adattatore：

   • Permette di risolvere le incompatibilità di interfaccia tra oggetti tramite un "adattatore".

2. Modello decoratore (Decoratore)：

   • Aggiungi dinamicamente ulteriori responsabilità a un oggetto.

3. Modalità proxy (Proxy)：

   • Fornisce un sostituto o un segnaposto per un altro oggetto per controllarne l'accesso.

4. Facciata：

   • Fornisce un'interfaccia unificata di alto livello per accedere a un gruppo di interfacce nel sottosistema.

5. Modalità Bridge (Ponte)：

   • Separare la parte astratta dalla sua implementazione in modo che possano variare indipendentemente.

6. Modalità composita：

   • Raggruppare gli oggetti in una struttura ad albero per rappresentare una gerarchia parte-intero.

7. Modalità peso mosca：

   • Supporta in modo efficiente un gran numero di oggetti a grana fine attraverso la condivisione.

Modelli comportamentali

Questi modelli si concentrano sulla comunicazione tra oggetti, ovvero su come gli oggetti interagiscono tra loro e su come distribuiscono le responsabilità.

1. Strategia：

   • Definisci una serie di algoritmi, incapsulali uno per uno e rendili intercambiabili.

2. Modello del metodo modello (metodo modello)：

   • Definire la struttura dell'algoritmo nel metodo e rinviare l'implementazione alle sottoclassi.

3. Modello osservatore (Osservatore)：

   • Relazione di dipendenza uno-a-molti tra gli oggetti Quando un oggetto cambia stato, tutti gli oggetti che dipendono da esso verranno avvisati e aggiornati automaticamente.

4. Modello iteratore (Iteratore)：

   • Accedi in sequenza ai singoli elementi di un oggetto aggregato senza esporne la rappresentazione interna.

5. Modello di catena di responsabilità：

   • Dare a più oggetti la possibilità di gestire la richiesta, evitando così l'accoppiamento tra il mittente e il destinatario della richiesta.

6. Modalità di comando (Comando)：

   • Incapsula la richiesta come oggetto, consentendo all'utente di parametrizzare il client con richieste diverse.

7. Modalità ricordo：

   • Cattura lo stato interno di un oggetto e salva questo stato all'esterno dell'oggetto senza interrompere l'incapsulamento.

8. Modalità di stato：

   • Consente a un oggetto di modificare il proprio comportamento quando cambia il suo stato interno.

9. Modalità visitatore：

   • Aggiungere nuove funzionalità a una struttura di oggetti (come una struttura composita).

10. Modello mediatore：

    • Definire un oggetto intermedio per semplificare l'interazione tra gli oggetti originali.

11. Modalità interprete (Interprete)：

    • Definire una rappresentazione grammaticale di una lingua e interpretare le frasi definite in quella lingua.

Durante l'ultima intervista, mi è stato chiesto se utilizzare il codice per implementare il modello abbonato-editore. Ho avuto il tempo di simulare questi modelli di progettazione con il codice js.

Per esempio

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 questo esempio,PubSub La classe fornisce le seguenti funzionalità:

• subscribe Il metodo consente agli abbonati di registrare una funzione di richiamata per un evento specifico.
• unsubscribe Il metodo consente agli abbonati di annullare la registrazione delle proprie funzioni di richiamata da eventi specifici.
• unsubscribeAll Il metodo annulla tutte le iscrizioni a un evento specifico.
• emit Il metodo attiva l'evento ed esegue le funzioni di callback di tutti gli abbonati.
• hasSubscribers Il metodo controlla se ci sono iscritti per un evento specifico.