
O código composable descreve classes e funções que podem ser prontamente combinadas para criar construções de nível superior mais poderosas. A capacidade de composição se compara favoravelmente a formas alternativas de reutilização de código, como herança orientada a objetos. Ele defende a criação de pequenas unidades independentes que são tratadas como blocos de construção para sistemas maiores.
Componibilidade e inversão de controle
O código composable é frequentemente um objetivo e efeito das estratégias de Inversão de Controle (IoC). Técnicas como injeção de dependência funcionam com componentes autocontidos que são passados (“injetados”) nos locais onde são necessários. Este é um exemplo de IoC – o ambiente externo é responsável por resolver as dependências das camadas de código mais profundas que ele chama.
O conceito de composição encapsula as peças específicas que você pode fornecer e como elas são integradas. Um sistema combinável consistirá em unidades distintas de funcionalidade, cada uma com uma única responsabilidade. Processos mais complexos são desenvolvidos “compondo” várias dessas unidades em uma nova maior.
Exemplos de Componibilidade
Aqui está um exemplo de três unidades funcionais possíveis:
interface LogMessage { public function getMessage() : string; } interface Mailable { public function getEmailContent() : string; } interface RelatesToUser { public function getTargetUserId() : int; }
Agora vamos adicionar uma implementação de logger à mistura:
interface Logger { public function log(LogMessage $message) : void; } final class SystemErrorLogMessage implements LogMessage, Mailable { public function __construct( protected readonly \Exception $e) {} public function getMessage() : string { return "Unhandled error: " . $this -> e -> getMessage(); } public function getEmailContent() : string { return $this -> getMessage(); } }
Vamos agora considerar outro tipo de mensagem de log:
final class UserLoggedInLogMessage implements LogMessage, Mailable, RelatesToUser { public function __construct( protected readonly int $UserId) {} public function getMessage() : string { return "User {$this -> UserId} logged in!"; } public function getEmailContent() : string { return $this -> getMessage(); } public function getTargetUserId() : int { return $this -> UserId; } }
Aqui estamos vendo os benefícios da composição. Ao definir a funcionalidade do aplicativo como interfaces, as implementações de classes concretas são livres para misturar e combinar as peças de que precisam. Nem toda mensagem de log tem um usuário associado; algumas mensagens podem ser inelegíveis para alertas de e-mail se forem de baixa prioridade ou contiverem informações confidenciais. Manter as interfaces autocontidas permite criar implementações flexíveis para cada situação.
Os exemplos acima são escritos em PHP, mas podem ser replicados em qualquer linguagem orientada a objetos. A capacidade de composição não se limita ao código OOP: também é um aspecto fundamental da programação funcional. Aqui, comportamentos complexos são obtidos encadeando pequenas funções. As funções podem levar de outros funções como argumentos e retornam um novo função de ordem superior como resultado.
const square = x => (x * x); const quadruple = x => (x * 4); // 16 console.log(compose(square, quadruple)(2));
Este exemplo mínimo de JavaScript usa o compose-function biblioteca para compor square e quadruple unidades em outra função que eleva ao quadrado e depois quadruplica sua entrada. O compose() função utilitária aceita outras funções para compor em conjunto; ele retorna uma nova função que chama a cadeia de entradas em sequência.
Você também encontrará a capacidade de composição em estruturas modernas de desenvolvimento com componentes. Aqui está um exemplo de um conjunto simples de componentes React:
const UserCard = ({user, children}) => ( <div> <h1>{user.name}</h1> {children} </div> ); const UserAvatar = ({user}) => { if (user.avatarId) { return <img src={`/avatars/${user.avatarId}.png`} />; } else return <img src={`/avatars/generic.png`} />; }; const UserCardWithAvatar = ({user}) => ( <UserCard user={user}> <UserAvatar user={user} /> </UserCard> );
Cada componente é mantido simples, preocupando-se apenas com uma parte específica da funcionalidade geral. Você pode renderizar o UserCard por conta própria ou compor uma nova variante com um avatar ou qualquer outro componente React. O UserCard não é complicado pela lógica responsável por renderizar o arquivo de imagem de avatar correto.
Composição x Herança
As linguagens orientadas a objetos geralmente alcançam a reutilização de código por meio de herança. Escolher a herança como sua estratégia padrão pode ser um erro caro que dificulta a manutenção de um projeto ao longo do tempo.
A maioria dos idiomas não suporta herança múltipla, portanto, suas opções para combinações complexas de funcionalidade são limitadas. Aqui está a mensagem de log de refatoração anterior em um modelo de herança semelhante:
class LogMessage implements LogMessage { public function __construct( public readonly string $message) : void; } class LogMessageWithEmail extends LogMessage implements Mailable { public function getEmailContent() : string { return "New Log Message: {$this -> message}"; } } class LogMessageWithUser extends LogMessage implements RelatedToUser { public function __construct( public readonly string $message, public readonly int $userId) {} public function getTargetUserId() : int { return $this -> userId; } }
Essas aulas podem parecer úteis para começar. Agora você não precisa de implementações de mensagens de log específicas como nossa UserLoggedInMessage classe. Porém, há um grande problema: se você precisar escrever uma mensagem de log relacionada a um usuário e enviar um e-mail, não há classe para isso. Você poderia escrever um LogMessageWithEmailAndUser mas você estaria começando a descer a ladeira escorregadia de cobrir todas as permutações possíveis com implementações de classes concretas “genéricas”.
Apesar desses problemas, o código usando herança para esse tipo de modelo de relacionamento permanece predominante em projetos grandes e pequenos. Ele tem casos de uso válidos, mas geralmente é implementado pelos motivos errados. Pequenas unidades que podem ser compostas baseadas em interfaces e funções são mais versáteis, fazem você pensar no panorama geral do seu sistema e tendem a criar código mais sustentável com menos efeitos colaterais.
Uma boa regra para herança é usá-la quando um objeto é algo mais. A composição geralmente é a melhor escolha quando um objeto tem algo mais:
- Registro / E-mail – Uma mensagem de log não é inerentemente um e-mail, mas pode ter conteúdo de e-mail associado a ele. O Log deve incluir o conteúdo do Email como uma dependência. Se nem todos os Logs tiverem um componente de Email, a composição deve ser usada conforme mostrado acima.
- Usuário/Administrador – O Administrador herda todos os comportamentos do Usuário e adiciona alguns novos. Poderia ser um bom caso para herança –
Administrator extends User.
Alcançar a herança muito cedo pode restringi-lo mais tarde, pois você encontra mais cenários exclusivos em seu aplicativo. Manter as unidades de funcionalidade tão pequenas quanto possível, defini-las como interfaces e criar classes concretas que misturam e combinam essas interfaces é uma maneira mais eficiente de conceituar sistemas complexos. Isso facilita a reutilização de seus componentes em locais diferentes.
Resumo
Código composável refere-se à fonte que combina unidades modulares independentes em pedaços maiores de funcionalidade. É uma personificação de relacionamentos “tem-a” entre diferentes entidades. O mecanismo de composição real depende do paradigma que você está usando; para linguagens OOP, você deve programar para interfaces em vez de classes concretas, enquanto os domínios funcionais geralmente o orientam para uma boa composição por design.
Ser proativo no uso de técnicas que podem ser compostas leva a um código mais resiliente, pouco acoplado, mais fácil de raciocinar e mais adaptável a casos de uso futuros. A criação de blocos que podem ser compostos geralmente é o ponto de partida mais eficaz quando você está refatorando sistemas de grande escala. Embora alternativas como herança também tenham funções válidas, elas são menos aplicáveis e mais propensas ao uso indevido do que a composição, injeção de dependência e IoC.
Fonte Adicione ao Google Notícias



