Padrões de design: padrão Flyweight no TypeScript

Bem-vindo à série Design Patterns in TypeScript , que apresenta alguns padrões de design úteis no desenvolvimento da Web usando o TypeScript.

9 padrões de design que todo engenheiro deve conhecer

Padrões de design são muito importantes para desenvolvedores web e podemos escrever códigos melhores dominando-os. Neste artigo, usarei o TypeScript para apresentar o padrão Flyweight.

O padrão Flyweight é executar a tecnologia de compartilhamento para suportar efetivamente um grande número de objetos refinados, evitar a sobrecarga de um grande número de pequenas classes com o mesmo conteúdo (como consumo de memória) e permitir que todos compartilhem uma classe.

A empresa UPhone é um fabricante de telefones celulares, pode produzir telefones UPhone em massa, a maioria dos dados do telefone celular, como modelo e tela, são os mesmos, uma pequena parte dos dados não é a mesma. como tamanho da memória e número de série.

class UPhone {
  constructor(model: string, screen: number, 
    memory: number, sn: number) {}
}
let uphones = [];
for (let i = 0; i < 10000; i++) {
  let memory = i % 2 == 0 ? 64 : 128;
  uphones.push(new UPhone("8U", 5.0, memory, i));
}

Existem dois conceitos importantes no padrão flyweight: estado interno e estado externo.

• estado interno : a parte compartilhada dentro do objeto flyweight que não muda com a mudança do ambiente externo.
• estado externo : o estado que não pode ser compartilhado é o estado externo que muda conforme o ambiente muda.

A seguir, apresentaremos como usar o padrão flyweight para resolver o problema anterior. Para entender melhor o código a seguir, vejamos primeiro o diagrama UML correspondente:

A maioria dos telefones UPhone no exemplo acima tem o mesmo modelo, tela e memória, então essa parte dos dados pode ser compartilhada, que são os dados inerentes ao modelo flyweight, então definimos a classe flyweight correspondente ao UPhone como segue:

class UPhoneFlyweight {
  constructor(model: string, screen: number, memory: number) {}
}

Na UPhoneFlyweightclasse, existem três propriedades de membro de model, screene memory. Além das classes de peso-mosca, também precisamos de uma fábrica de peso-mosca para manter esses dados:

class FlyweightFactory {
  private phonesMap: Map<string, UPhoneFlyweight> = new Map();
public get(model: string, screen: number, memory: number):  
   UPhoneFlyweight {
    const key = model + screen + memory;
    if (!this.phonesMap.has(key)) {
      this.phonesMap.set(key, new UPhoneFlyweight(model, 
        screen, memory));
    }
    return this.phonesMap.get(key)!;
  }
}

Como o número de série de cada UPhone é único, essa propriedade precisa ser usada como um estado externo. Com base na UPhoneFlyweightclasse, vamos atualizar a classe definida anteriormente UPhone:

class UPhone {
  constructor(flyweight: UPhoneFlyweight, sn: number) {}
}

Além disso, para criar objetos UPhone com mais facilidade, continuamos definindo uma UPhoneFactoryclasse:

class UPhoneFactory {
  private static flyweightFactory: FlyweightFactory = 
    new FlyweightFactory();
public getUPhone(model: string, screen: number, 
     memory: number, sn: number) {
       const flyweight: UPhoneFlyweight = 
         UPhoneFactory.flyweightFactory.get(
           model, screen, memory
         );
       return new UPhone(flyweight, sn);
  }
}

const uphoneFactory = new UPhoneFactory();
let uphones = [];
for (let i = 0; i < 10000; i++) {
  let memory = i % 2 == 0 ? 64 : 128;
  uphones.push(uphoneFactory.getUPhone("8U", 5.0, memory, i));
}
console.log(
  "UPhoneFlyweight count:",
  UPhoneFactory.flyweightFactory.phonesMap.size
);

UPhoneFlyweight count: 2

class UPhoneFlyweight {
  constructor(model: string, screen: number, memory: number) {}
}

      

• Um programa usa um grande número de objetos semelhantes, que causam uma grande sobrecarga de memória;
• A maior parte do estado de um objeto pode se tornar externo e, eliminando o estado externo de um objeto, um grande número de objetos pode ser substituído por relativamente poucos objetos compartilhados.

Se você tiver alguma dúvida, sinta-se à vontade para me deixar uma mensagem. Continuarei a apresentar outros padrões mais tarde, se você estiver interessado, pode me seguir no Medium ou no Twitter .

Se você quiser aprender TypeScript, não perca a série Mastering TypeScript .

Com mais de 30 artigos, você não ficará confuso ao aprender TypeScript