Розрив лінії до / після оператора [закрито]

У той час як конвенція Java-коду від Sun пропонує встановити перерву лінії перед оператором, багато інших вказівок не згодні з цим. Я не бачу явних плюсів і мінусів, тож чи є переваги використання одного з цих стилів над іншим?

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

проти

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

Я б залишив це в одному рядку і швидше подумати про читабельність з точки зору виявлення намірів (і функцій) змінних імен.

Як тільки він стає безладним, настав час рефактор :

• перейменувати vars
• ввести нові пара / функції

Приклад

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

vs.

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

Я можу уявити, що читаність є аргументом

result = longidentifier +
   short -
   alittlelonger -
   c;

проти

result = longidentifier
   + short
   - alittlelonger
   - c;

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

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

Найпоширеніші стилі, які я бачив, - це другий стиль у питанні. Дивіться нижче список їх:

Посібник зі стилю Google :

Коли лінія розбита у оператора без призначення, перерва настає перед символом.

Конвенція про кодування НД :

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

Значення за замовчуванням " Checkstyle Operator Wrap " - це nl:

Оператор повинен бути на новій лінії

У коді я схильний ставити перерву після оператора:

foo = some_long_expression() +
      some_other_long_expression();

Ось оператор, що звисає в кінці рядка, є великою підказкою для читача, що код триває. У мовах, які не мають терміналів операторів, цей вивішений оператор може служити достатньою підказкою для компілятора / інтерпретатора, що код продовжується (інакше мені доведеться використовувати якусь потворну конструкцію рядка продовження).

Під час документування цього виразу (якщо йому потрібна документація) я схильний ставити перерву перед оператором.

Поки ви залишаєтеся послідовними, тоді знайте, що жодної реальної переваги немає. Це особливо важливо при розгляді злиття коду та пробілу.

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

У наступному прикладі, скануючи лівий край, ви бачите структуру оператора як АБО з 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