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

29

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

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

против

String longVarName = a + b + c + d
          + e + f;
Nutel
источник
Можете ли вы опубликовать простой пример кода, показывающий оба соглашения?
Майкл
Сначала я попытался бы избежать этой ситуации, используя что-то вроде этого: download.oracle.com/javase/1.4.2/docs/api/java/lang/…
Работа
Ссылка не работает.
Флориан Ф

Ответы:

14

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

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

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

пример

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

против

tax = price * tax_ratio / 100
subtotal = price + tax
Камил Томшик
источник
2
Формула слева неверна. Это должно быть price * (100 + tax_ratio) / 100или просто price * (1 + tax_ratio), в зависимости от того tax_ratio, в процентах или дробных.
Rufflewind
4
Это не отвечает на вопрос. Должен быть закон против таких ответов.
Эдвард Д'Суза
@ EdwardD'Souza Я чувствую то же самое. Но почему был принят ответ?
Руди Vissers
@RudyVissers ответ решает проблему на более глубоком уровне. Это решает проблему необходимости разрыва строки в первую очередь. С этой точки зрения ФП мог бы посчитать это ответом на свою проблему, но это все еще не подходит с точки зрения того, что это вики-сообщество.
Эдвард Д'Суза
эй, я больше не здесь, но это действительно просто - если вы оказались в такой ситуации, вы, вероятно, делаете это неправильно, и вам лучше подумать о рефакторинге кода - или поставить его иначе, после 15 лет программирования я просто больше не волнуюсь о таких вещах, мне
важна
36

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

result = longidentifier +
   short -
   alittlelonger -
   c;

против

result = longidentifier
   + short
   - alittlelonger
   - c;

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

Отто Альмендингер
источник
4
Для ситуаций, где важны операторы (например, математические выражения и т. Д.), Я бы выбрал номер два, потому что, как вы сказали, он гораздо более читабелен. Но для строк я бы выбрал первые варианты, так как операторы «бессмысленны». Они не делают ничего, кроме как объединяют строки, и поскольку строки являются важным элементом, я бы предпочел первые варианты.
Никлас Х
Оба случая имеют свои достоинства. Оба случая лучше, чем поместить все это в одну очень длинную очередь! Я предпочитаю использовать открывающую скобку в начале (даже если она не нужна), а затем выстраивать все под это. Это делает это намного более очевидным.
fast_now
35

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

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

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

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

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

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

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

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

ceilfors
источник
2
Обновленный мой ответ для ясности + соглашение по кодированию Sun.
Ceilfors
google.github.io/styleguide/javaguide.html (ссылка в ответе не работает)
Мартин Пфеффер,
10

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

foo = some_long_expression() +
      some_other_long_expression();

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

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

Дэвид Хаммен
источник
По крайней мере, некоторые языки (например, Python) не используют завершающий двоичный оператор как намек на продолжение строки, но требуют большего. Обратите внимание, что переводы строк внутри символов обычно не учитываются, поэтому вам не нужен явный (и подверженный ошибкам) ​​символ продолжения строки.
3

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

Мартейн Вербург
источник
3

Я считаю, что строка должна начинаться с самого высокого символа в дереве разбора оператора, который вы хотите разбить. Он выделяет оператора, который является наиболее важным в выражении. По той же причине вы ставите 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()
    };
Флориан Ф
источник
2

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

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

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

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

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

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

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

zzzzBov
источник
2

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

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

Кевин Клайн
источник
0

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

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
Joel
источник
1
Этот ответ не добавляет ничего нового к тому, что уже было сказано.
Мартин Питерс