Funções ideais
Num mundo ideal funções são pequenas, muito bem definidas, possuem uma única responsabilidade e não crescem, mas no mundo real isso não é uma realidade, funções tendem a crescer, mesmo que tenham uma única função de fato.
Imagine uma função de uma aplicação veterinária que deve dizer ao usuário qual comida é adequada para um determinado animal, de forma simples a função seria mais ou menos dessa forma:
function properFoodForAnimal(anAnimal: string): string {
let food;
if ("dog" === anAnimal.toLowerCase()) food = "beef meat";
if ("cat" === anAnimal.toLowerCase()) food = "fish meat";
if ("owl" === anAnimal.toLowerCase()) food = "rat meat";
if ("monkey" === anAnimal.toLowerCase()) food = "banana";
if ("horse" === anAnimal.toLowerCase()) food = "corn";
return `Animal ${anAnimal} will eat ${food}`;
}
Note que a medida em que a veterinária "expandir o seu mercado" e novos animais forem atendidos essa função tende a crescer ganhando novos ifs.
Para evitar que isso aconteça podemos aplicar o design pattern chain of responsibility.
Chain of Responsibility
É um padrão de projeto comportamental muito utilizado quando temos uma cadeia (chain) de situações que lidam com o mesmo escopo como a escolha de uma comida, calculo de um preço, filtragem de campos dentre outras.
Esse padrão permite que vários objetos manipulem a solicitação sem que haja acoplamento entre o trecho de código que envia a requisição e seus receptores. Podemos facilmente identificar esse padrão no nosso código através da interface a qual a solução é implementada.
interface Handler {
setNext(handler: Handler): Handler;
handle(request: string): string;
}
Procedimento
Sempre que vamos começar a refatorar um trecho de código temos de nos certificar que aquele trecho possui uma suite de testes robusta que vai nos assegurar de não causar nenhum bug, então a primeira coisa que vamos fazer é justamente escrever os testes para a função.
describe("Proper food for animal", () => {
it("should return the correct phrase containing the proper for a dog", () => {
let phrase = properFoodForAnimal("dog");
expect(phrase).toBe("Animal dog will eat beef meat");
});
it("should return the correct phrase containing the proper for a cat", () => {
let phrase = properFoodForAnimal("cat");
expect(phrase).toBe("Animal cat will eat fish meat");
});
it("should return the correct phrase containing the proper for a owl", () => {
let phrase = properFoodForAnimal("owl");
expect(phrase).toBe("Animal owl will eat rat meat");
});
it("should return the correct phrase containing the proper for a monkey", () => {
let phrase = properFoodForAnimal("monkey");
expect(phrase).toBe("Animal monkey will eat banana");
});
it("should return the correct phrase containing the proper for a horse", () => {
let phrase = properFoodForAnimal("horse");
expect(phrase).toBe("Animal horse will eat corn");
});
});
Escritos os testes iniciamos a refatoração, primeiramente criando a interface AnimalFoodHandler que é nada além da interface genérica do pattern apresentada anteriormente.
interface ProperFoodHandler {
setNext(handler: ProperFoodHandler): ProperFoodHandler;
handle(anAnimal: string): string;
}
Pode parecer desnecessário a primeira vista nomear essa interface de forma tão específica uma vez que a proposta é que ela seja genérica, mas isso impede outros programadores de aplicar handlers não adequados para aquela situação já que o intellisense do ts avisará que os objetos não são do mesmo tipo.
O próximo passo então é criarmos as classes handlers para cada animal que temos no código hoje, como todo handler possui a mesma estrutura e lida com o mesmo domínio podemos fazer o uso de herança e polimorfismo para deixar o nosso código ainda mais claro. Vamos criar uma classe abstrata de handler da qual se derivarão as classes filhas.
export class AbstractFoodHandler implements IFoodHandler {
private nextHandler: IFoodHandler | undefined;
next(handler: IFoodHandler): IFoodHandler {
this.nextHandler = handler;
return handler;
}
handle(anAnimal: string): string | null {
if (this.nextHandler) {
return this.nextHandler.handle(anAnimal);
}
return null;
}
}
Agora podemos ter handlers concretos derivado da classe abstrata de forma com que haja um handler para cada situação, assim sendo temos
DogFoodHandler.ts
export class DogFoodHandler extends AbstractFoodHandler {
handle(anAnimal: string): string | null {
if ("dog" === anAnimal.toLowerCase())
return `Animal dog will eat beef meat`;
return super.handle(anAnimal);
}
}
CatFoodHandler.ts
export class CatFoodHandler extends AbstractFoodHandler {
handle(anAnimal: string): string | null {
if ("cat" === anAnimal.toLowerCase())
return `Animal cat will eat fish meat`;
return super.handle(anAnimal);
}
}
OwlFoodHandler.ts
export class OwlFoodHandler extends AbstractFoodHandler {
handle(anAnimal: string): string | null {
if ("owl" === anAnimal) return `Animal owl will eat rat meat`;
return super.handle(anAnimal);
}
}
MonkeyFoodHandler.ts
export class MonkeyFoodHandler extends AbstractFoodHandler {
handle(anAnimal: string): string | null {
if ("monkey" === anAnimal.toLowerCase())
return `Animal monkey will eat banana`;
return super.handle(anAnimal);
}
}
HorseFoodHandler.ts
export class HorseFoodHandler extends AbstractFoodHandler {
handle(anAnimal: string): string | null {
if ("horse" === anAnimal.toLowerCase()) return `Animal horse will eat corn`;
return super.handle(anAnimal);
}
}
Ainda podemos criar um arquivo index.ts para facilitar a exportação de arquivos.
import { CatFoodHandler } from "./CatFoodHandler";
import { DogFoodHandler } from "./DogFoodHandler";
import { MonkeyFoodHandler } from "./MonkeyFoodHandler";
import { OwlFoodHandler } from "./OwlFoodHandler";
import { HorseFoodHandler } from "./HorseFoodHandler";
const catHandler = new CatFoodHandler();
const monkeyHandler = new MonkeyFoodHandler();
const owlHandler = new OwlFoodHandler();
const horseHandler = new HorseFoodHandler();
const handler = new DogFoodHandler();
handler
.next(catHandler)
.next(owlHandler)
.next(monkeyHandler)
.next(horseHandler);
export { handler };
O código final da nosssa aplicação ficará assim:
export function properFoodForAnimal(anAnimal: string): string | null {
return handler.handle(anAnimal);
}
Assim, se quisermos adicionar uma nova condição dentro desse fluxo de código basta criarmos uma nova classe concreta de Handler, inicializá-la e colocá-la na cadeia dentro do arquivo index.ts.
Top comments (0)