É uma má idéia listar todos os argumentos de função / método em uma nova linha e por quê?

Eu trabalho com alguém que, toda vez que chama uma função, coloca os argumentos em uma nova linha, por exemplo

aFunction(
    byte1,
    short1,
    int1, 
    int2,
    int3,
    int4,
    int5
) ;

Eu acho isso muito irritante, pois significa que o código não é muito compacto, então eu tenho que escanear mais e mais para realmente entender a lógica. Estou interessado em saber se isso é realmente uma má prática e, em caso afirmativo, como convencê-los a não fazer isso?

É apenas uma diretriz de codificação da qual você pode ou não gostar. O importante é que você e seus colegas concordem em usá-lo ou não.

Obviamente, a melhor maneira de aumentar a legibilidade é limitar o número de argumentos.

É uma questão de preferência. Para chamadas de função complicadas onde você deseja documentar cada parâmetro ou onde as variáveis ​​são bastante longas e existem muitas delas, isso pode ser bom.

Por exemplo:

do_complex_op(
      0, //Starting state, always 0, ask Joe why
      X, //X-coord of thingy
      y, //Y-coord of thingy
      73, //in this case, we don't want to use Z but want constant 
      dlogMessageTitle, //message for dialogue title
      dlogMessageText, //message for dialogue contents, don't care about this.
      SomethingIP, //IP of something-or-other server, can be NULL, won't crash.
      someObject.childObject.getValue(key1).HVAL, //very long path to HVAL
      someObject.childObject.getValue(key1).LVAL, //very long path to LVAL
      this.parentWindow.owner.mainTextBox.text.value.trim, //get the trimmed text, untrimmed text causes weird output
      pvrMainSettingForLongBlahs.getObjectByPath(somePath),
      pvrMainSettingForLongBlahs.K_TCA_UPPER_LIMIT,
      pvrMainSettingForLongBlahs.K_ENDPOINT_COMPLIANCE_LEVEL,
 );

Com idiomas que permitem parâmetros nomeados, isso é mais comum se você usar os nomes dos parâmetros (o exemplo está em PL / SQL):

PKG_SOME_TEST_CODE.FN_DO_SOMETHING( in_text => 'test text',
                                    in_id => v_id,
                                    in_ref_id => v_ref_id,
                                    out_array_for_storage => v_bArray); 

Mas concordo que, se a chamada de função for simples e não houver muitos parâmetros, isso pode ser irritante, como:

setColour (
    r,
    g,
    b
 );

Acho muito mais fácil ler como

 setColour(r,g,b);

Para @ammoQ:

rc=a(b,c(d,e(f)))

rc=a(
     b,
     c(
       d,
       e(
         f
        )
      )
    )

Na OMI, tudo o que é incomum é uma prática ruim, a menos que sua superioridade em relação ao estilo usual possa ser comprovada positivamente. “Questão de gosto” é uma desculpa ruim para escrever código mais difícil de ler do que o necessário para a maioria dos programadores, porque um dia uma alma pobre, não acostumada a esse estilo, precisará manter esse código.

Provar que isso é incomum é relativamente fácil, mostra a fonte de exemplos no MSDN ou em sites similares, mostra grandes bases de código-fonte aberto etc. Mostre a saída dos embelezadores de código. Por fim, mostre como todo mundo em sua equipe está fazendo isso. Não aceite um estilo ruim apenas porque alguém é muito teimoso.

Bem, aqui estão algumas iscas de voto negativo. Eu nunca fui acusado de fazer a coisa popular. Claramente, se as coisas couberem em uma linha, então tudo bem, coloque-as em uma linha.

Mas minha principal preocupação não é se o código é "feio" ou "bonito". Minha principal preocupação é como é fácil entender e fazer alterações sem cometer erros.

Se os argumentos são longos e existem muitos, por que não colocá-los em linhas separadas? Na minha opinião, isso facilita a visualização do que são e a alteração, se necessário. Também me dá espaço para anexar um comentário a cada argumento, se eu quiser.

Também quero minimizar a chance de cometer um erro se adicionar ou remover um argumento a uma função, o que é mais provável que ocorra no final de uma lista de argumentos do que no início. Por esse motivo, prefiro colocar a vírgula (,) no início de uma linha do que no final. Então, se, por exemplo, desejo remover ou adicionar um argumento no final da lista, é uma edição em uma linha. Não preciso mexer na vírgula que precisa ir no final de todas as linhas, exceto a última, onde a última deve terminar entre parênteses.

Então (garoto, eu vou ser queimado por isso) eu escrevo assim:

nameOfFunction(firstArgument
    , secondArgument // optional comment
       ...
    , lastArgument   // optional comment
    );

Quando há uma função com de cinco a vinte argumentos, a função não fica assim de uma só vez. Ele cresceu com o tempo, o que significa que houve muitas edições. Qualquer edição não concluída é um erro de sintaxe ou um bug. Então eu não afirmo que isso é bonito. Eu afirmo que ajuda a obter as edições corretas.

(E para aqueles que dizem que eu deveria passar uma estrutura, tudo o que faz é substituir o problema, porque você precisa de várias linhas de código para preencher a estrutura, sem mencionar o código extra para declarar e alocá-la.)

Eu também não chamaria. A melhor prática em que trabalhei geralmente era fazer com que as chamadas de função estivessem todas em uma linha, a menos que você tivesse que rolar horizontalmente qualquer quantia significativa para ver a chamada inteira. É um julgamento, mas eu definitivamente diria que, para colocar todos funções assim está fora de linha, a menos que esse seja o padrão estabelecido por sua organização.

É por isso que é uma boa prática para uma organização estabelecer um conjunto de guias aos quais todos os programadores devem aderir. É tudo sobre consistência e legibilidade.

Torna mais fácil:

• Reordenar argumentos.
• Comente ou desative argumentos.
• Veja exatamente qual argumento mudou quando você vê diferenças no seu sistema de controle de versão
• Evite recuar e agrupar tudo ao adicionar ou remover um argumento ou alterar o nome da função. (Mesmo que o editor recue automaticamente, você ainda estará criando muitas alterações inúteis no espaço em branco que dificultam o acompanhamento das alterações no sistema de controle de versão.)

Eu diria que as chamadas de função devem estar todas em uma linha, a menos que excedam significativamente a largura do código padrão (geralmente 80 caracteres, geralmente causa de argumentos :-).

Não vejo nenhuma vantagem nesse estilo. Parece subjetivamente feio, e acho difícil ao pesquisar código. Por exemplo, você pode procurar rapidamente e ver se a função é chamada com um determinado parâmetro passado como NULL. Isso é fácil visualmente quando todos os parâmetros estão em uma linha e mais difícil quando eles são divididos assim.

Eu sempre vi esse estilo em declarações ou definições de funções , mas nunca em uma chamada (até agora). Às vezes, faz sentido, pois permite adicionar um comentário para parâmetros individuais mais claramente. Parece que ele copiou esse estilo para ligações sem realmente conhecer as razões subjacentes a ela. Você tem um bom argumento contra e ele não parece ter um bom voto, então você tem meu voto, mas não sou eu quem você deve convencer.

É contra os padrões de codificação da empresa?

Caso contrário, inicie uma discussão sobre os padrões e o que as pessoas gostariam que mudassem. Lembre-se de trazer isso como uma das coisas que você gostaria de mudar.

Tenha uma discussão completa sobre por que você acha que isso não é útil e espero que você ganhe o dia. Você nunca sabe que seu colega pode convencê-lo de que o caminho dele é o melhor, afinal;)

Depois de ter um padrão atualizado, é documentado o que todos deveriam estar codificando; portanto, se o seu colega persistir, você poderá aumentá-lo nas revisões de código.

Pode parecer estranho para você, mas facilita o trabalho no código. Ao refatorar, você pode comentar argumentos individuais com muita facilidade e verificar seu refatorador antes de excluir as coisas. Você também pode comentar e substituir temporariamente tipos facilmente.

Também é mais fácil de ler do que:

int f(int, int, int,
      char, double, int
      X const&, Y)
{}

Eu não fui tão extremo quanto você está mostrando (já que não há nomes nos parâmetros, isso não ajuda muito), mas adquiri o hábito de dividir cada parâmetro em sua própria linha ou não fazer divisão.

A parte importante é que seu código pode ser impresso ou exibido em telas padrão de 80 cores e ainda assim legível.

Você raramente obterá uma resposta honesta de um programador para algo assim. Todos responderão apenas com o que fazem ou não. A verdade é que, por mais que todos lutemos com isso às vezes, a única "má prática" aqui é a sua própria inflexibilidade.

Você precisa ser brutalmente honesto consigo mesmo para poder distinguir entre coisas que são realmente ruins e coisas que apenas o incomodam. A verdade é que, em C / C ++ e linguagens similares, você raramente encontrará uma prática de indentação que tenha um efeito tangível na compreensibilidade do código. A maioria das discussões sobre esse tipo de coisa tem ambos os lados empilhados, com pessoas fazendo argumentos ridículos e fingidos para tentar justificar sua preferência pessoal.

O que, para minha leitura ..., é exatamente o que você está solicitando nesta pergunta: um argumento ridículo e falso para justificar sua preferência pessoal.

Para ser honesto, depende da pessoa. Eu diria que para funções complexas, como demonstrado pelo primeiro exemplo de FrustratedWithForms, então sim; caso contrário, um grande NÃO. Então, novamente, é por isso que prefiro aplicar a funcionalidade IDE do código arbitrariamente.

"Estou interessado em saber se isso é realmente uma má prática ..."

Sim, é uma prática ruim, exceto quando a lista de variáveis ​​é anormalmente longa. Mas, nesse caso, o problema provavelmente se deve ao design da função. Por que não passar um objeto que encapsula muitos dos parâmetros?

"... e se sim, como posso convencê-los a não fazer isso?"

Amarre-os e continue fazendo cócegas até eles concordarem em parar com essa porcaria.

Por que você está desperdiçando ciclos com uma preocupação tão trivial? Basta iniciar o seu confiável IDE, abrir o arquivo e reformatar. Voila! Será da forma que você quiser.

Agora vamos para a questão realmente importante - vi ou emacs, LOL.

Eu diria que, se os argumentos se encaixarem em uma linha, faça-o. Caso contrário, um argumento por linha garante grande legibilidade.

foo(arg1, arg2, arg3, arg4, arg5)

vs.

foo(
    arg1=arg1,
    arg2=arg2,
    arg3=arg3,
    arg4=arg4,
    arg5=arg5,
    arg6=arg6,
    arg7=arg7
)