Resumo dos padrões de design de software

2024-07-12

Padrões de projeto são soluções gerais para problemas comuns em projeto de software. A seguir estão alguns padrões de design comuns, divididos em três categorias principais: padrões de criação, padrões estruturais e padrões comportamentais.

Padrões Criativos

Esses padrões fornecem mecanismos para criação de objetos, aumentando a flexibilidade e a reutilização do código existente.

Padrão singleton：
- Certifique-se de que haja apenas uma instância de uma classe e forneça um ponto de acesso global.
Padrão de Método de Fábrica：
- Defina a interface para criar objetos e deixe as subclasses decidirem qual classe instanciar.
Padrão de fábrica abstrato (fábrica abstrata)：
- Crie famílias de objetos relacionados ou dependentes sem especificar explicitamente classes concretas.
Padrão de construtor (Construtor)：
- Construa um objeto complexo e permita a construção passo a passo.
Protótipo：
- Crie uma nova instância copiando uma instância existente, em vez de criar uma nova.

Padrões Estruturais

Esses padrões lidam com combinações de objetos ou relacionamentos entre objetos e eles.

Modo adaptador：
- Permite que incompatibilidades de interface entre objetos sejam resolvidas através de um “adaptador”.
Padrão de decorador (decorador)：
- Adicione dinamicamente responsabilidades adicionais a um objeto.
Modo proxy (proxy)：
- Fornece um substituto ou espaço reservado para outro objeto para controlar o acesso a ele.
Fachada：
- Fornece uma interface unificada de alto nível para acessar um grupo de interfaces no subsistema.
Modo ponte (ponte)：
- Separe a parte abstrata de sua implementação para que possam variar de forma independente.
Modo composto：
- Agrupe objetos em uma estrutura de árvore para representar uma hierarquia parte-todo.
Modo peso mosca：
- Oferece suporte eficiente a um grande número de objetos refinados por meio do compartilhamento.

Padrões comportamentais

Esses padrões focam na comunicação entre objetos, ou seja, como os objetos interagem entre si e como distribuem responsabilidades.

Estratégia：
- Defina uma série de algoritmos, encapsule-os um por um e torne-os intercambiáveis.
Padrão de método de modelo (método de modelo)：
- Defina a estrutura do algoritmo no método e adie a implementação para subclasses.
Padrão observador (Observador)：
- Relacionamento de dependência um-para-muitos entre objetos Quando um objeto muda de estado, todos os objetos que dependem dele serão notificados e atualizados automaticamente.
Padrão de iterador (Iterador)：
- Acesse elementos individuais em um objeto agregado sequencialmente sem expor sua representação interna.
Modelo de Cadeia de Responsabilidade：
- Dê a vários objetos a chance de lidar com a solicitação, evitando assim o acoplamento entre o remetente e o destinatário da solicitação.
Modo de comando (comando)：
- Encapsula a solicitação como um objeto, permitindo ao usuário parametrizar o cliente com diferentes solicitações.
Modo lembrança：
- Capture o estado interno de um objeto e salve esse estado fora do objeto sem quebrar o encapsulamento.
Modo de estado：
- Permite que um objeto altere seu comportamento quando seu estado interno for alterado.
Modo visitante：
- Adicione novos recursos a uma estrutura de objeto (como uma estrutura composta).
Padrão mediador：
- Defina um objeto intermediário para simplificar a interação entre objetos originais.
Modo intérprete (intérprete)：
- Definir uma representação gramatical de uma língua e interpretar as frases definidas nessa língua.

Durante a última entrevista, fui questionado sobre o uso de código para implementar o padrão assinante-editor. Tive tempo para simular esses padrões de design com código js.

Por exemplo

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

Neste exemplo,PubSub A classe fornece a seguinte funcionalidade:

subscribe O método permite que os assinantes registrem uma função de retorno de chamada para um evento específico.
unsubscribe O método permite que os assinantes cancelem o registro de suas funções de retorno de chamada de eventos específicos.
unsubscribeAll O método cancela todas as assinaturas de um evento específico.
emit O método aciona o evento e executa as funções de retorno de chamada de todos os assinantes.
hasSubscribers O método verifica se há assinantes para um evento específico.

Compartilhamento de tecnologia