3 minutos de leitura
Autor(a)
Fique por dentro de conteúdos, insights e oportunidades do universo tech. Receba novidades e lançamentos direto no seu e-mail.
Pode ser difícil ler uma invocação de método ou de construtor quando temos muitos parâmetros. Isso piora se tivermos parâmetros do mesmo tipo. Um exemplo em Ruby:
Titular.new("Hugo Roque", "Josemar Nunes", "Antonio")
O que esse construtor recebe como parâmetros? O que esses nomes representam? Lendo simplesmente dessa forma, só podemos chutar. Há muitas formas de atenuar esse problema. Uma das soluções seria utilizar tinytypes, criando classes, como Dependente, que possuem um ou pouquíssimos atributos, servindo mais como uma forma de tipificar e explicitar com o que trabalhamos, evitando a "programação orientada a strings". Em Java é comum utilizarmos o design pattern Builder, evitando construtores gigantes e complexos. Dessa forma o código acima seria algo como:
Refatoração em Java: early return na prática
Ler mais
RaspberryPi com Grappa
Ler maisJava 6, as APIs de XML, Webservices e classloaders
Ler mais
Titular hugo = new TitularBuilder() .nome("Hugo Roque") .dependentes("Josemar Nunes", "Antonia Roque") .build();
Em Ruby, é comum passarmos hashes como argumento, inclusive muitas gems que usamos no dia a dia utilizam essa técnica. Se estivermos usando o ActiveRecord e precisarmos procurar os 5 primeiros usuários por ordem de criação, podemos utilizar o seguinte código:
Usuario.find(:all, order: "created\_at DESC", offset: 1)
Já no caso do nosso Titular, a chamada seria feita da seguinte maneira:
hugo = Titular.new(nome: "Hugo Roque", dependentes: ```"Josemar Nunes", "Antonia Roque"
)
Que já melhora bastante a leitura na chamada do método, mas piora a legibilidade do código que define o método:
class Titular attr\_reader :nome, :dependentes
def initialize(options={}) @nome = options```:nome
@dependentes = options```:dependentes
end end
Observe que não está claro na assinatura do método as informações que ele precisa, teremos que olhar a implementação para descobrir o que receberemos na hash. Além da expressividade, podemos deixar de passar um parâmetro e nada irá nos alertar, todos os parâmetros se tornam opcionais. O Ruby 2.0promete uma forma nativa de nomear os parâmetros, facilitando tanto a leitura quanto a escrita das invocações. Veja uma possível invocação que poderemos fazer no futuro:
class Titular def initialize(nome: "padrao", dependentes: \[\]) @nome = nome @dependentes = dependentes end end hugo = Titular.new(nome: "Hugo Roque", dependentes: ```"Josemar Nunes", "Antonia Roque"
)
Isso trará muitas vantagens para a forma como desenvolveremos, porém a versão 2.0 do Ruby tem previsão de lançamento para fevereiro de 2013. Enquanto essa novidade não chega, algumas soluções provisórias foram desenvolvidas, eu mesmo implementei a gem named-parameterque disponibiliza uma forma de simular esses parâmetros nomeados de forma limpa e simples. Através da gem, invocamos o método como se estivéssemos recebendo uma hash, mas definimos da seguinte maneira:
class Titular extend NamedParameter
named def initialize(nome, dependentes) @nome = nome @dependentes = dependentes end end
E você, como evita uma grande quantidade de parâmetros?
Avalie este artigo