Devo colocar novas linhas antes ou depois dos operadores binários? [fechadas]

Quando você está em Python ou Javascript, sempre deve colocar operadores binários no final da linha anterior, para evitar que novas linhas encerrem seu código prematuramente; ajuda a detectar erros.

Mas em C ou C ++, isso não é um problema, então estou me perguntando:

Existe alguma razão para eu preferir a segunda versão à primeira?

return lots_of_text
       + 1;

versus

return lots_of_text +
       1;

(Por exemplo, um deles ajuda a evitar outros tipos de erros? Ou é um deles considerado mais legível?)

Como você pode ver nas respostas, não há consenso sobre esse assunto. A menos que você trabalhe em equipe, use o que mais lhe agrada.

Eu prefiro inserir uma nova linha antes dos operadores.

Sempre que tenho que quebrar linhas, geralmente coloco no máximo um termo do mesmo "nível" em uma linha:

Lei da gravitação de Newton em Python:

force = (
    gravitational_constant
    * mass_1
    * mass_2
    / (distance * distance)
)

Compare isso com:

force = (
    gravitational_constant *
    mass_1 *
    mass_2 /
    (distance * distance)
)

Quero saber que "divido pela distância ao quadrado", não quero saber, que "mass_2 fica dividido", porque não é assim que penso em expressões matemáticas.

_{Além disso, geralmente quero saber primeiro o que estou fazendo (operador), antes de me preocupar com o que faço (operandos).}

Ou considere esta instrução SQL complicada:

WHERE
  a = 1
  AND b = 2
  AND c = 3
  AND ( -- or put the OR on one line together with the AND
    d = 3 
    OR e = 1)
  AND x = 5

Isso me permite ver como as condições individuais são conectadas com muita facilidade, apenas deslizando de cima para baixo sem ter que ler todas as linhas até o final para encontrar o operador em vez de:

WHERE
  a = 1 AND
  b = 2 AND
  c = 3 AND
  ( 
    d = 3 OR
    e = 1) AND
  x = 5

Penso no primeiro em termos de " Xé verdade", depois retifico isso dizendo: " E isso também é verdade", o que me parece mais natural do que o contrário. Além disso, acho o primeiro muito mais fácil de analisar visualmente.

Ou um exemplo de PHP:

$text = "lorem ipsum"
      . "dolor sit amet, "
      . "consectetur adipisicing elit, "
      . "sed do eiusmod tempor";

Mais uma vez, posso apenas ler rapidamente na vertical para ver que estou simplesmente concatenando o texto, porque na maioria das vezes sinto que realmente não me importo com o que está dentro das strings / condições.

Claro, eu não aplicaria esse estilo incondicionalmente. Se colocar a nova linha após um operador parecer fazer mais sentido para mim, eu faria isso, mas não consigo pensar em um exemplo no momento.

Quase sempre quebro linhas antes de operadores binários para deixar claro aos leitores do código que essa é a continuação de uma expressão e não a próxima declaração. Isso é importante se a próxima instrução normalmente for recuada. Por exemplo, considere uma instrução if que tenha uma expressão condicional complexa:

if (first_part_of_condition &&
    second_part_of_condition) {
    statement_within_then_part;
}

A segunda parte da expressão condicional é facilmente confundida com a primeira declaração da parte então. Isso pode ser bastante confuso se a primeira parte da condição for longa e o && terminar bem à direita. Compare isso com a alternativa:

if (first_part_of_condition
    && second_part_of_condition) {
    statement_within_then_part;
}

Isso parece um pouco estranho, mas deixa bem claro que a segunda parte da condição não é o início de uma declaração.

Também faço isso em outros contextos, mas a declaração if é a mais importante, pois a indentação é ambígua. Obviamente, pode-se alterar o recuo ou posicionamento da chave, mas isso também parece estranho.

tl; dr a extremidade esquerda da linha é mais significativa para a compreensão rápida da leitura, portanto, colocar o operador na extremidade esquerda é um marcador mais proeminente de que essa é uma expressão contínua, não uma declaração.

Eu sempre usaria o primeiro. Você quer que fique claro o que está fazendo com esse 1 lá. Se eu visse isso e houvesse uma parede de texto acima desse número 1, eu não teria ideia do que estava acontecendo quanto ao uso desse número.

O '+' próximo a 1 deixa claro que, no mínimo, eu estou fazendo algo com o 1 em questão, em vez de sair "Estou todo do seu código ..." sem motivo aparente.

Eu sinto que isso ajuda tremendamente a compreensão de leitura quando uma linha indica que a declaração continua na próxima linha ao ter o operador binário no final e, assim, tornar a declaração incompleta. O ponto e vírgula ausente não é suficiente para que eu entenda imediatamente.

Isso pode ser simplesmente uma questão de hábito, mas, a menos que você trabalhe exclusivamente em linguagens que exijam ponto-e-vírgula (o que acho bastante irrealista, dada a difusão de scripts de shell, makefiles e linguagens como Python), você provavelmente também não terá esse hábito.

EDIT: Giorgio faz uma excelente observação nos comentários: esse uso ecoa pontuação comum , tanto em matemática quanto em línguas naturais. Você escreveria

Eu afundo,
pois nadei

Você não escreveria

Eu afundo
, pois nadei