Quebra de linha antes / depois do operador [fechado]

Enquanto a convenção de código Java da Sun sugere colocar a quebra de linha diante do operador, muitas outras diretrizes discordam dela. Não vejo prós e contras óbvios, então há vantagens em usar um desses estilos em detrimento de outro?

String longVarName = a + b + c + d +
          e + f;

vs

String longVarName = a + b + c + d
          + e + f;

Eu o deixaria em uma linha e, em vez disso, pensaria na legibilidade em termos de nomes (e funções) de variáveis ​​que revelam a intenção.

Quando ficar confuso, é hora de refatorar :

• renomear vars
• introduzir novos vars / funções

Exemplo

subtotal = price * (100 + tax_ratio) / 100`

vs.

tax = price * tax_ratio / 100
subtotal = price + tax

Eu posso imaginar legibilidade sendo um argumento

result = longidentifier +
   short -
   alittlelonger -
   c;

versus

result = longidentifier
   + short
   - alittlelonger
   - c;

No segundo exemplo, os operadores estão bem alinhados e você pode ver facilmente com qual sinal a variável entra na equação. Eu acho que isso também faz sentido para operadores binários, mas com o suporte etc., você deve fazer o que for mais claro.

Normalmente, sigo as diretrizes de estilo mais usadas ou algumas ferramentas padrão de codificação. A vantagem de usar um estilo comumente usado traz benefícios quando você está lendo o código de outras pessoas ou envolvido em um projeto de código aberto, no qual são definidas diretrizes de estilo.

Os estilos mais comuns que eu já vi é o segundo estilo da pergunta. Veja abaixo a lista deles:

Guia de estilo do Google :

Quando uma linha é interrompida em um operador que não é de atribuição, a quebra ocorre antes do símbolo.

Convenção de codificação solar :

Quebre antes de um operador

O valor padrão da verificação Wrap Wrap do operador Checkstyle é nl:

O operador deve estar em uma nova linha

No código, costumo colocar o intervalo após o operador:

foo = some_long_expression() +
      some_other_long_expression();

Aqui, esse operador pendente no final de uma linha é uma grande pista para o leitor de que o código continua. Em idiomas que não possuem terminadores de instrução, esse operador dangling pode servir como uma pista suficiente para o compilador / intérprete de que o código continua (caso contrário, eu precisaria usar alguma construção feia de linha de continuação).

Ao documentar essa expressão (se precisar de documentação), costumo colocar a interrupção diante do operador.

Contanto que você permaneça consistente, saiba que não há nenhuma vantagem real de qualquer maneira. Isso é especialmente importante quando se considera mesclagem de código e espaço em branco.

Acredito que a linha deve começar com o símbolo mais alto na árvore de análise da instrução que você deseja quebrar. Destaca o operador que é mais importante na expressão. É a mesma razão pela qual você coloca um outro no início de uma linha e não no final da linha anterior.

No exemplo a seguir, varrendo a margem esquerda, você vê a estrutura da instrução como um OR de 3 expressões.

if (ch>='A' && ch<='Z'
    || ch>='a' && ch<='z'
    || ch>='0' && ch<='9')
{...}

Abaixo, o || operadores são menos destacados. É menos óbvio que é um || de expressões. Especialmente se as linhas tiverem comprimentos diferentes.

if (ch>='A' && ch<='Z' ||
    ch>='a' && ch<='z' ||
    ch>='0' && ch<='9')
{...}

E apenas para referência, isso é muito errado. O || operadores não são destacados.

if ( ch>='A' && ch<='Z' || ch>='a'
     && ch<='z' || ch>='0' && ch<='9')
{...}

Eu até gosto de colocar vírgulas no início da linha, mesmo que raramente veja isso. Abstendo-me de fazer isso no código compartilhado.

var note:Object =
    { key: key
    , type: 'P'
    , text: someLongProcedureCallGettingTheUserInitials()
       + ": " + getTheTextThatWasTyped()
    };

Para longas equações aritméticas, normalmente faço uma de duas coisas.

deixe tudo em uma única linha:

foo = bar + baz - fizz + buzz + alpha - beta;

Normalmente faço isso para equações que contêm apenas adição e subtração, acho muito fácil digitar erros de multiplicação e divisão que podem atrapalhar seriamente o escopo do operador.

o segundo formato que eu uso são operadores progressivos:

foo = bar;
foo += baz;
foo -= fizz;
foo += buzz;
foo /= alpha - beta;
foo *= spiff;

Não vejo razão para reduzi-lo para uma única linha, a menos que se prove que melhora o desempenho de maneira perceptível. Além disso, não há ambiguidade do que está acontecendo, e há menos chances de colocar um parêntese nos operadores /e *.

Colocar o caractere de concatenação (ou qualquer operador) no início da linha melhora a legibilidade. Nós digitalizamos o código focando no início de cada linha. Quando uma linha começa com um operador, o leitor pode dizer que a linha é uma continuação da instrução anterior, digitalizando esse caractere.

Expressões matemáticas longas são sempre digitadas para que cada nova linha comece com um operador. Não há razão para que o código não deva seguir esta convenção.

Deixe a expressão em uma linha e, se ficar muito longa, divida-a em expressões menores:

days = ((year * months_per_year) + month) * days_per_month + day

torna-se:

months = year * months_per_year + month
days = months * days_per_month + day

Se isso não for possível, acho mais legível interromper o operador e fazer com que o operador comece diretamente abaixo da tarefa anterior (colocá-la abaixo da variável me faz pensar e ser mais recente, o que é chato, pois o objetivo é é facilitar a leitura):

random = years * months_per_year 
         + month * days_per_month 
         + day * hours_per_day 
         + hour * minutes_per_hour 
         + minute * seconds_per_minute 
         + second