Quantos parâmetros são muitos? [fechadas]

Rotinas podem ter parâmetros, isso não é novidade. Você pode definir quantos parâmetros precisar, mas muitos deles dificultam a compreensão e a manutenção de sua rotina.

Obviamente, você pode usar uma variável estruturada como solução alternativa: colocar todas essas variáveis ​​em uma única estrutura e passá-la para a rotina. De fato, o uso de estruturas para simplificar as listas de parâmetros é uma das técnicas descritas por Steve McConnell no Code Complete . Mas como ele diz:

Programadores cuidadosos evitam agrupar dados mais do que é logicamente necessário.

Portanto, se sua rotina possui muitos parâmetros ou você usa uma estrutura para disfarçar uma grande lista de parâmetros, provavelmente está fazendo algo errado. Ou seja, você não está mantendo o acoplamento solto.

Minha pergunta é: quando posso considerar uma lista de parâmetros muito grande? Eu acho que mais de 5 parâmetros, são muitos. O que você acha?

Quando é que algo considerado tão obsceno que pode ser regulamentado, apesar da garantia da 1ª Emenda à liberdade de expressão? Segundo o juiz Potter Stewart, "eu sei quando vejo". O mesmo vale aqui.

Eu odeio fazer regras rígidas e rápidas como essa, porque a resposta muda não apenas dependendo do tamanho e do escopo do seu projeto, mas acho que muda até o nível do módulo. Dependendo do que o seu método está fazendo ou do que a classe deve representar, é bem possível que 2 argumentos sejam muitos e sejam um sintoma de muito acoplamento.

Eu sugeriria que, fazendo a pergunta em primeiro lugar e qualificando sua pergunta tanto quanto você, você realmente sabe tudo isso. A melhor solução aqui não é confiar em um número rígido e rápido, mas procurar análises de projeto e de código entre seus pares para identificar áreas em que você tem baixa coesão e acoplamento rígido.

Nunca tenha medo de mostrar a seus colegas o seu trabalho. Se você tem medo, esse é provavelmente o sinal maior de que algo está errado com o seu código e que você já o conhece .

Uma função só pode ter muitos parâmetros se alguns deles forem redundantes. Se todos os parâmetros forem utilizados, a função deverá ter o número correto de parâmetros. Tome esta função frequentemente usada:

HWND CreateWindowEx
(
  DWORD dwExStyle,
  LPCTSTR lpClassName,
  LPCTSTR lpWindowName,
  DWORD dwStyle,
  int x,
  int y,
  int nWidth,
  int nHeight,
  HWND hWndParent,
  HMENU hMenu,
  HINSTANCE hInstance,
  LPVOID lpParam
);

São 12 parâmetros (9 se você agrupar x, y, weh como um retângulo) e também existem parâmetros derivados do nome da classe. Como você reduziria isso? Deseja reduzir o número mais ao ponto?

Não deixe que o número de parâmetros o incomode, apenas verifique se é lógico e bem documentado e deixe que o intellisense ^{* o} ajude.

^* Outros assistentes de codificação estão disponíveis!

No Código Limpo , Robert C. Martin dedicou quatro páginas ao assunto. Aqui está a essência:

O número ideal de argumentos para uma função é zero (niládico). A seguir vem um (monádico), seguido de perto por dois (diádico). Três argumentos (triádicos) devem ser evitados sempre que possível. Mais de três (poládicos) exigem justificativas muito especiais - e, portanto, não devem ser usadas de qualquer maneira.

Alguns códigos com os quais trabalhei no passado usavam variáveis ​​globais apenas para evitar a passagem de muitos parâmetros.

Por favor, não faça isso!

(Usualmente.)

Se você começar a contar mentalmente os parâmetros na assinatura e combiná-los com a chamada, é hora de refatorar!

Muito obrigado por todas as suas respostas:

• Foi um pouco surpreendente encontrar pessoas que também pensam (como eu) que 5 parâmetros são um bom limite para a sanidade do código.

• Geralmente, as pessoas tendem a concordar que um limite entre 3 e 4 é uma boa regra geral. Isso é razoável, pois as pessoas costumam ter problemas contando mais de 4 coisas.

• Como aponta Milão , em média as pessoas podem manter mais ou menos 7 coisas na cabeça por vez. Mas acho que você não pode esquecer que, ao projetar / manter / estudar uma rotina, você deve ter em mente mais coisas do que apenas parâmetros.

• Algumas pessoas consideram que uma rotina deve ter tantos argumentos quanto necessário. Concordo, mas apenas em alguns casos específicos (chamadas para APIs do SO, rotinas em que a otimização é importante etc.). Sugiro ocultar a complexidade dessas rotinas adicionando uma camada de abstração logo acima dessas chamadas sempre que possível.

• usuario tem algumas idéias interessantes sobre isso. Se você não quiser ler os comentários dele, resumo para você: em poucas palavras, depende :

  Eu odeio fazer regras rígidas e rápidas como essa, porque a resposta muda não apenas dependendo do tamanho e do escopo do seu projeto, mas acho que muda até o nível do módulo. Dependendo do que o seu método está fazendo ou do que a classe deve representar, é bem possível que 2 argumentos sejam muitos e sejam um sintoma de muito acoplamento.

  A moral aqui é não ter medo de mostrar seu código aos colegas, discutir com eles e tentar "identificar áreas onde você tem baixa coesão e acoplamento rígido" .

• Finalmente, acho que wnoise concorda muito com Nick e conclui sua contribuição satírica com essa visão poética (veja os comentários abaixo) da arte da programação:

  Programar não é engenharia. A organização do código é uma arte porque depende de fatores humanos, que dependem muito do contexto para qualquer regra rígida.

Esta resposta assume um idioma OO. Se você não estiver usando um - pule esta resposta (em outras palavras, não é uma resposta independente do idioma).

Se você estiver passando mais de três parâmetros (principalmente tipos / objetos intrínsecos), não é "muitos", mas pode haver uma chance de criar um novo objeto.

Procure grupos de parâmetros passados ​​para mais de um método - mesmo um grupo passado para dois métodos quase garante que você deva ter um novo objeto lá.

Então você refatora a funcionalidade em seu novo objeto e não acredita no quanto isso ajuda seu código e seu entendimento da programação OO.

Parece que existem outras considerações além do mero número, aqui estão algumas que vêm à mente:

1. relação lógica com o objetivo principal da função x configurações pontuais

2. Se forem apenas sinalizadores de ambiente, o agrupamento pode ser muito útil

Um dos epigramas de programação conhecidos de Alan Perlis (recontado no ACM SIGPLAN Notices 17 (9), setembro de 1982) afirma que "Se você tem um procedimento com 10 parâmetros, provavelmente perdeu alguns".

De acordo com Steve McConnell no Code Complete , você deve

Limite o número de parâmetros de uma rotina a cerca de sete

Para mim, quando a lista cruza uma linha no meu IDE, é um parâmetro a mais. Eu quero ver todos os parâmetros em uma linha sem quebrar o contato visual. Mas essa é apenas a minha preferência pessoal.

Eu geralmente concordo com 5, no entanto, se houver uma situação em que eu preciso de mais e for a maneira mais clara de resolver o problema, eu usaria mais.

Sete coisas na memória de curto prazo?

1. Nome da função
2. Valor de retorno da função
3. Objetivo da função
4. Parâmetro 1
5. Parâmetro 2
6. Parâmetro 3
7. Parâmetro 4

Nos Piores 5 Snippets de Código , verifique o segundo, "Isso é um construtor". Possui mais de 37 ⋅ 4 ≈ 150 parâmetros:

Aqui um programador escreveu esse construtor [...] Alguns de vocês podem pensar que sim, é um grande construtor, mas ele usou as ferramentas automáticas de geração de código do eclipse [.] NOO, nesse construtor houve um pequeno bug que eu descobri, o que me fez concluir que este construtor foi escrito à mão. (a propósito, essa é apenas a parte superior do construtor, não está completa).

Um mais que o necessário. Não pretendo ser simplista, mas há algumas funções que necessariamente precisam de algumas opções. Por exemplo:

void *
mmap(void *addr, size_t len, int prot, int flags, int fildes, off_t offset);

Existem 6 argumentos, e cada um deles é essencial. Além disso, não há um vínculo comum entre eles para justificá-los. Talvez você possa definir "struct mmapargs", mas isso seria pior.

De acordo com as práticas recomendadas do Perl , 3 é aceitável, 4 é demais. É apenas uma orientação, mas em nossa loja é isso que tentamos seguir.

Eu mesmo desenharia o limite para funções públicas em 5 parâmetros.

IMHO, listas longas de parâmetros são aceitáveis ​​apenas em funções auxiliares particulares / locais que devem ser chamadas apenas de alguns locais específicos no código. Nesses casos, talvez você precise repassar muitas informações de estado, mas a legibilidade não é uma grande preocupação, pois apenas você (ou alguém que manterá seu código e deve entender os fundamentos do seu módulo) precisa se preocupar com chamando essa função.

Uma questão relacionada que você deve considerar é quão coesa é a rotina. Um grande número de parâmetros pode ser um cheiro que está lhe dizendo que a própria rotina está tentando fazer muito e, portanto, é suspeita de coesão. Concordo que um número rígido e rápido de parâmetros provavelmente é impossível, mas acho que uma rotina de alta coesão implicaria um número baixo de parâmetros.

97 soa exatamente certo.

Menos e você perde flexibilidade.

Eu paro em três parâmetros como regra geral. Mais e é hora de passar uma matriz de parâmetros ou um objeto de configuração, o que também permite que parâmetros futuros sejam adicionados sem alterar a API.

Uma restrição de comprimento em uma lista de parâmetros é apenas mais uma restrição. E restrição significa violência aplicada. Parece engraçado, mas você pode não ser violento mesmo durante a programação. Apenas deixe o código ditar as regras. É óbvio que, se você tiver muitos parâmetros, o corpo do método function / class será grande o suficiente para utilizá-los. E trechos de código grandes geralmente podem ser refatorados e divididos em partes menores. Assim, você obtém uma solução contra ter muitos parâmetros como bônus grátis, pois eles são divididos entre os menores pedaços de código refatorados.

Uma coisa que eu apontaria da perspectiva do desempenho é que, dependendo de como você passa parâmetros para um método, a passagem de muitos parâmetros por valor atrasará o programa, pois cada parâmetro deve ser copiado e, em seguida, colocado na pilha.

Usar uma única classe para abranger todos os parâmetros funcionaria melhor porque um único parâmetro passado por referência seria elegante, limpo e rápido!

Segundo mim, pode haver casos em que você excederá 4 ou algum número fixo. Coisas a serem observadas

1. Seu método está fazendo muito e você precisa refatorar.
2. Você pode considerar usar uma coleção ou alguma estrutura de dados.
3. Repensar o design da sua turma, talvez algumas coisas não precisem ser contornadas.

Do ponto de vista da facilidade de uso ou da facilidade de leitura do código, acho que quando você precisa digitar sua assinatura de método, isso deve fazer com que você pare e pense: a menos que se sinta impotente e todos os esforços para reduzir a assinatura levam a nenhum resultado. Algumas bibliotecas muito boas no passado e no presente usam mais de 4-5 carrinhos de bebê.

Minha regra geral é que preciso lembrar os parâmetros por tempo suficiente para olhar para uma chamada e dizer o que ela faz. Então, se eu não consigo olhar para o método e, em seguida, mudar para a chamada de um método e lembrar qual parâmetro faz o que, então há muitos.

Para mim, isso equivale a cerca de 5, mas eu não sou tão brilhante. Sua milhagem pode variar.

Você pode criar um objeto com propriedades para reter os parâmetros e passá-lo se exceder o limite que você definir. Consulte o livro Refatoração de Martin Fowler e o capítulo sobre como simplificar as chamadas de método.

Depende bastante do ambiente em que você está trabalhando. Tomemos, por exemplo, javascript. Em javascript, a melhor maneira de passar parâmetros é usar objetos com pares de chave / valor, o que, na prática, significa que você tem apenas um parâmetro. Em outros sistemas, o ponto ideal será às três ou quatro.

No final, tudo se resume ao gosto pessoal.

Concordo que 3 é bom, 4 é demais como orientação. Com mais de três parâmetros, você está inevitavelmente executando mais de uma tarefa. Mais de uma tarefa deve ser dividida em métodos separados.

No entanto, se eu olhasse para o projeto mais recente em que trabalhei, as exceções seriam muitas e a maioria dos casos seria difícil de reduzir para três parâmetros.

Se eu tiver 7 a 10 parâmetros em uma rotina, analiso agrupá-los em uma nova classe, mas não se essa classe não passasse de um monte de campos com getters e setters - a nova classe precisa fazer algo diferente de valores aleatórios e Fora. Caso contrário, eu prefiro aturar a longa lista de parâmetros.

É um fato conhecido que, em média, as pessoas podem manter 7 +/- 2 coisas na cabeça por vez. Eu gosto de usar esse princípio com parâmetros. Supondo que todos os programadores sejam pessoas inteligentes acima da média, eu diria que tudo que é 10+ é demais.

BTW, se os parâmetros forem semelhantes de alguma forma, eu os colocaria em um vetor ou lista em vez de uma estrutura ou classe.

Basearia minha resposta na frequência com que a função é chamada.

Se é uma função init que é chamada apenas uma vez, deixe 10 parms ou mais, quem se importa.

Se for chamado várias vezes por quadro, então eu tendem a fazer uma estrutura e apenas passar um ponteiro para ela, pois isso tende a ser mais rápido (supondo que você não esteja reconstruindo a estrutura todas as vezes).

De acordo com Jeff Bezos, da Amazon, não pode mais do que ser alimentado com duas pizzas :