Padrão - Composite
Published: 2023-01-25 15:28:09


![Pattern compositor](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/j3fyia6bm8koi4p9m0l7.jpg)

O padrão Compositor é um padrão de projeto de software que foi descrito pela primeira vez no livro "Design Patterns: Elements of Reusable Object-Oriented Software" (Padrões de Projeto: Elementos de Software Orientado a Objetos Reutilizáveis) escrito por Erich Gamma, Richard Helm, Ralph Johnson e John Vlissides, mais conhecido como "Gang of Four" (GoF). 

O padrão Compositor é um padrão de projeto de software que permite a criação de estruturas hierárquicas de objetos e fornece uma interface para trabalhar com essas estruturas de forma uniforme, independentemente do tipo de objeto contido nelas. Ele permite que você crie objetos que compõem outros objetos, formando uma estrutura de objetos aninhada.

A ideia principal do padrão Compositor é permitir que os objetos sejam agrupados em estruturas hierárquicas, como uma árvore, onde cada nó é um objeto composto de outros objetos. Cada objeto tem uma interface comum, permitindo que os objetos sejam tratados de forma semelhante, independentemente de sua posição na hierarquia. Isso permite a construção de estruturas complexas usando objetos simples e fáceis de entender, tornando o código mais fácil de manter e estender.

Exemplos comuns de uso do padrão compositor incluem a criação de documentos com texto, imagens e tabelas, a criação de interfaces gráficas de usuário com painéis aninhados e a criação de estruturas de arquivos complexas com pastas e arquivos.

O padrão Compositor pode ser utilizado em várias situações para solucionar problemas de projeto comuns, alguns exemplos incluem:

- Criação de documentos com texto, imagens e tabelas: O padrão Compositor pode ser usado para criar objetos que representam diferentes tipos de elementos de documento, como texto, imagens e tabelas, e permitir que esses objetos sejam agrupados em estruturas hierárquicas para formar um documento completo.
- Criação de interfaces gráficas de usuário (GUIs) com painéis aninhados: O padrão Compositor pode ser usado para criar objetos que representam diferentes tipos de componentes de interface gráfica de usuário, como botões, caixas de texto e painéis, e permitir que esses objetos sejam agrupados em estruturas hierárquicas para formar uma interface gráfica de usuário completa.
- Criação de estruturas de arquivos complexas com pastas e arquivos: O padrão Compositor pode ser usado para criar objetos que representam diferentes tipos de elementos de estrutura de arquivos, como pastas e arquivos, e permitir que esses objetos sejam agrupados em estruturas hierárquicas para formar uma estrutura de arquivos completa.
- Criação de estruturas de objetos complexas, como árvores, grafos, listas encadeadas e listas de objetos.
- Criação de sistemas de jogo, onde os objetos são agrupados em hierarquias para formar cenários e elementos de jogo.
- Criação de sistemas de renderização 3D, onde os objetos são agrupados em hierarquias para formar modelos 3D e cenários.
- Criação de sistemas de simulação, onde os objetos são agrupados em hierarquias para formar sistemas e sub-sistemas.
- Criação de sistemas de inteligência artificial, onde os objetos são agrupados em hierarquias para formar agentes e sub-agentes.


Segue abaixo um simples exemplo de código usando o padrão Compositor.

```js
class FileSystemItem {
  constructor(name) {
    this.name = name;
  }

  getName() {
    return this.name;
  }

  getSize() {
    return 0;
  }
}

class File extends FileSystemItem {
  constructor(name, size) {
    super(name);
    this.size = size;
  }

  getSize() {
    return this.size;
  }
}

class Directory extends FileSystemItem {
  constructor(name) {
    super(name);
    this.items = [];
  }

  addItem(item) {
    this.items.push(item);
  }

  removeItem(item) {
    this.items = this.items.filter(i => i !== item);
  }

  getSize() {
    return this.items.reduce((size, item) => size + item.getSize(), 0);
  }
}

const home = new Directory('Home');
const documents = new Directory('Documents');
const resume = new File('resume.pdf', 1024);
const budget = new File('budget.xlsx', 2048);

documents.addItem(resume);
documents.addItem(budget);
home.addItem(documents);

console.log(home.getName()); // "Home"
console.log(home.getSize()); // 3072

```

A classe FileSystemItem é a classe base com uma interface comum para todos os elementos de estrutura de arquivos. Ela tem um nome e um método getName() que retorna esse nome, e um método getSize() que retorna 0 (pois é uma classe base e não sabe o tamanho do item).
A classe File estende FileSystemItem e tem uma propriedade adicional "size". Ela também sobreescreve o método getSize() para retornar o tamanho do arquivo.
A classe Directory também estende FileSystemItem e tem uma propriedade "items" que é um array de elementos de estrutura de arquivos. Ele tem métodos addItem(item) e removeItem(item) para adicionar e remover elementos, respectivamente. Ele também tem um método getSize() que retorna o tamanho total de todos os seus elementos filhos, usando o método reduce.
Em seguida, criamos uma instância da classe Directory chamada home e outra chamada documents. Depois criamos as instâncias de File chamadas resume e budget. Adicionamos esses arquivos a pasta de documentos, e por fim adicionamos a pasta de documentos a pasta home.
Por fim, imprimimos o nome da pasta home e o tamanho total de seus elementos.


_Simples, né ?_

O padrão Compositor é útil quando precisamos trabalhar com estruturas de objetos compostos, onde um objeto pode conter outros objetos e esses objetos podem ser tanto simples quanto compostos. Ele permite que você trabalhe com essas estruturas de forma uniforme, independentemente de seus elementos serem simples ou compostos.

Exemplos de usos comuns do padrão Compositor incluem:

- Estruturas de arquivos e pastas, onde pastas podem conter arquivos e outras pastas, e é necessário calcular o tamanho total de todos os elementos.
- Estruturas de documentos, onde documentos podem conter outros documentos, como parágrafos, imagens e tabelas, e é necessário percorrer a estrutura para imprimir o documento.
- Estruturas de menus, onde menus podem conter outros menus e itens de menu, e é necessário percorrer a estrutura para exibir o menu.
- Estruturas de componentes de interface do usuário, onde componentes podem conter outros componentes, como botões e caixas de seleção, e é necessário percorrer a estrutura para rastrear eventos.


**Conclusão**

O padrão Compositor é um padrão de projeto que permite trabalhar com estruturas de objetos compostos de forma uniforme, independentemente de seus elementos serem simples ou compostos. Ele permite a criação de estruturas hierárquicas, onde objetos podem conter outros objetos, e esses objetos podem ser tanto simples quanto compostos. 

Espero ter ajudado, até a próxima.