Разрыв строки до / после оператора [закрыт]

Хотя соглашение Java по коду Sun предлагает ставить разрыв строки перед оператором, многие другие рекомендации с ним не согласны. Я не вижу очевидных плюсов и минусов, так есть ли преимущества использования одного из этих стилей над другим?

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

против

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

Я бы оставил это в одной строке и скорее подумал бы о удобочитаемости с точки зрения раскрывающих намерения имен переменных (и функций).

Как только это станет грязным, пришло время провести рефакторинг :

• переименовать переменные
• ввести новые переменные / функции

пример

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

против

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

Я могу представить читабельность как аргумент

result = longidentifier +
   short -
   alittlelonger -
   c;

против

result = longidentifier
   + short
   - alittlelonger
   - c;

Во втором примере операторы выстроены в ряд, и вы можете легко увидеть, с каким знаком переменная входит в уравнение. Я думаю, что это также имеет смысл для бинарных операторов, но с брекетами и т. Д. Вы должны просто делать то, что понятнее.

Я обычно следую наиболее часто используемым рекомендациям по стилю или определенным стандартным инструментам кодирования. Преимущество использования широко используемого стиля дает преимущества, когда вы читаете код других людей или участвуете в проекте с открытым исходным кодом, где установлены рекомендации по стилю.

Наиболее распространенные стили, которые я видел, - это второй стиль в вопросе. Смотрите ниже их список:

Руководство по стилю Google :

Когда в операторе не присваивания строка разрывается, разрыв идет перед символом.

Конвенция по кодированию от солнца :

Перерыв перед оператором

Checkstyle Operator Wrap контроля встречается «сек значение по умолчанию является п:

Оператор должен быть на новой линии

В коде я стараюсь ставить разрыв после оператора:

foo = some_long_expression() +
      some_other_long_expression();

Здесь этот висячий оператор в конце строки является большим подсказкой для читателя, что код продолжается. В языках, в которых нет терминаторов операторов, этот висячий оператор может служить достаточным признаком для компилятора / интерпретатора, что код продолжается (в противном случае мне пришлось бы использовать некую уродливую конструкцию строки продолжения).

При документировании этого выражения (если оно нуждается в документировании) я склонен ставить перед оператором разрыв.

Пока вы остаетесь последовательным, то знайте, что в любом случае нет никакого реального преимущества. Это особенно важно при рассмотрении слияний кода и пробелов.

Я считаю, что строка должна начинаться с самого высокого символа в дереве разбора оператора, который вы хотите разбить. Он выделяет оператора, который является наиболее важным в выражении. По той же причине вы ставите else в начале строки, а не в конце предыдущей строки.

В следующем примере, просматривая левое поле, вы видите структуру оператора в виде ИЛИ из 3 выражений.

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

Ниже || операторы менее выделены. Менее очевидно, что это || выражений. Особенно если бы линии были разной длины.

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

И просто для справки, это очень неправильно. || операторы вообще не подсвечены.

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

Мне даже нравится ставить запятые в начале строки, хотя я редко это вижу. Я воздерживаюсь от этого на общем коде.

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

Для длинных арифметических уравнений я обычно делаю одну из двух вещей.

оставьте все в одной строке:

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

Обычно я делаю это для уравнений, содержащих только сложение и вычитание, и мне очень легко сделать опечатку с умножением и делением, которая может серьезно испортить область действия оператора.

Второй формат, который я использую - это прогрессивные операторы:

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

Я не вижу смысла сокращать его до одной строки, если не будет доказано, что это заметно улучшит производительность. Кроме того, нет никакой двусмысленности о том, что происходит , где и есть меньше шансов теряется скобкой для /и *операторов.

Размещение символа конкатенации (или любого оператора) в начале строки улучшает читабельность. Мы сканируем код, ориентируясь на начало каждой строки. Когда строка начинается с оператора, читатель может сказать, что строка является продолжением предыдущего оператора, отсканировав этот один символ.

Длинные математические выражения всегда набираются так, чтобы каждая новая строка начиналась с оператора. Нет причин, по которым код не должен следовать этому соглашению.

Оставьте выражение в одной строке, и если оно станет слишком длинным, разбейте его на более мелкие выражения:

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

будет выглядеть так:

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

Если это невозможно, то я нахожу более читабельным разрыв перед оператором, и оператор начинает прямо под предыдущим присваиванием (если поставить его ниже переменной, мне приходится думать и повторяться, что раздражает, учитывая, что цель это сделать вещи проще для чтения)

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