Padrão - Flyweight
Tags: javascript, node, architecture, cleancode
Published: 2023-02-09 00:13:20


![Pattern Flyweight](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/zvlu8ywh8v2qehe90hv3.png)


O padrão Flyweight é um padrão de design de software que foi introduzido por GoF (Gang of Four) no livro "Design Patterns: Elements of Reusable Object-Oriented Software". O objetivo deste padrão é ajudar a minimizar o uso de memória, permitindo compartilhar objetos idênticos entre várias partes da aplicação, em vez de criar objetos independentes para cada instância.

O padrão Flyweight é um padrão de design de software que permite compartilhar objetos idênticos em vez de criar uma instância independente para cada uso. Isso é feito para reduzir o uso de memória e melhorar o desempenho, especialmente em aplicações grandes ou com muitos objetos semelhantes. O padrão separa o estado compartilhado, que é armazenado no objeto Flyweight, do estado não compartilhado, que é mantido pelo cliente. O padrão Flyweight é útil para otimizar aplicações que possuem muitos objetos idênticos com pequenas variações.

O padrão Flyweight é útil em aplicações que precisam lidar com muitos objetos semelhantes, especialmente quando há preocupações com desempenho e uso de memória. Alguns exemplos comuns incluem:

- Jogos: onde há muitos personagens semelhantes na tela, como inimigos ou soldados.
- Aplicações de interface gráfica do usuário: onde há muitos controles semelhantes na tela, como botões ou caixas de texto.
- Sistemas financeiros: onde há muitas transações semelhantes, como transferências bancárias ou compras.

O padrão Flyweight é uma abordagem eficaz para otimizar aplicações que lidam com muitos objetos semelhantes, permitindo compartilhar objetos idênticos em vez de criar instâncias independentes para cada uso.

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

```js
class Coffee {
  constructor(flavor, price) {
    this.flavor = flavor;
    this.price = price;
  }
}

class CoffeeShop {
  constructor() {
    this.coffees = [];
  }

  takeOrder(flavor, table) {
    this.coffees[table] = CoffeeFlavorFactory.getCoffeeFlavor(flavor);
    console.log("Coffee flavor of table " + table + " is " + this.coffees[table].getFlavor());
  }
}

class CoffeeFlavorFactory {
  constructor() {
    this.flavors = [];
  }

  static getCoffeeFlavor(flavor) {
    if (!this.flavors[flavor]) {
      this.flavors[flavor] = new Coffee(flavor, Math.floor(Math.random() * 10));
    }
    return this.flavors[flavor];
  }

  getTotalCoffeeFlavorsMade() {
    return this.flavors.length;
  }
}

let coffeeShop = new CoffeeShop();

coffeeShop.takeOrder("Cappuccino", 1);
coffeeShop.takeOrder("Cappuccino", 2);
coffeeShop.takeOrder("Espresso", 3);
coffeeShop.takeOrder("Cappuccino", 4);
coffeeShop.takeOrder("Espresso", 5);

console.log("Total Coffee Flavors Made: " + CoffeeFlavorFactory.getTotalCoffeeFlavorsMade());

```


Neste exemplo, criamos uma classe Coffee que representa um tipo de café e uma classe CoffeeShop que representa a loja de café. A classe CoffeeFlavorFactory é usada para criar objetos Coffee compartilhados. Quando um cliente faz uma encomenda, a loja de café chama o método takeOrder da classe CoffeeShop, que, por sua vez, chama o método getCoffeeFlavor da classe CoffeeFlavorFactory. Se o objeto Coffee já estiver sido criado, ele será retornado, caso contrário, um novo objeto será criado. Desta forma, o padrão Flyweight é implementado e o uso de memória é otimizado.

_Simples, né ?_


Existem várias vantagens em usar o padrão Flyweight que incluem:

- Otimização de memória: O padrão Flyweight permite que objetos semelhantes compartilhem dados e recursos, o que ajuda a reduzir o uso de memória.
- Melhor desempenho: Além de otimizar o uso de memória, o padrão Flyweight também pode melhorar o desempenho geral da aplicação, já que é mais rápido criar e recuperar objetos compartilhados do que criar objetos novos.
- Maior flexibilidade: O padrão Flyweight permite que os objetos compartilhados sejam usados em diferentes contextos, o que aumenta a flexibilidade da aplicação.
- Reutilização de código: Com o padrão Flyweight, é possível reutilizar código comum entre objetos semelhantes, o que pode levar a uma manutenção mais fácil e confiável do código.
- Menor complexidade: Ao lidar com objetos semelhantes, o padrão Flyweight simplifica o código e a lógica da aplicação, tornando-a mais fácil de entender e manter.


**Conclusão**

O padrão Flyweight é um padrão de projeto de software que otimiza o uso de memória e melhora o desempenho em aplicações que lidam com muitos objetos semelhantes.


Espero ter ajudado, até a próxima.