Если Вы повреждаете долгие строки кода, как Вы располагаете материал с отступом на следующей строке?

Мне нравятся фигурные скобки на их собственной строке, потому что я прекрасный это легче видеть условие и внутренний блок все как один объект (если Вы знаете то, что я имею в виду):

if ((long test 1)
    && (long test 2)
    && (long test 3)) 
{
    code executed if true;
}

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

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

Я пытаюсь материал структуры так, чтобы я мог легко "просканировать" для "материала" :)

По-моему, ширина строки 78 или 80 символов полезна, так как она помогает иметь несколько файлов, открытых друг рядом с другом на том же экране.

Выравнивание, что относительно кавычки Linus Torvalds?:)

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

Я обычно следую за конгломератом Google стиль кодирования C++ (можно адаптировать это к Java также, я предполагаю), и этот стиль кодирования C++.

Единственная причина того, чтобы форматировать код конкретным способом состоит в том, чтобы сделать это читаемым. Это по сути субъективно - делают это способом, который выглядит хорошим и что Вы чувствуете, было бы более читаемым для кого-то смотрящего на код впервые. И я собираюсь маркировать расхожее мнение и сказать, не волнуйтесь ни о каком едином стандарте - по двум причинам

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

2) это не покупает Вас ничто. период. снова, форматирование кода должно просто сделать Ваш код читаемым, имение стандартного способа отформатировать подробные сведения Вашего кода не покупает Вас удобочитаемость.

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

a 
= b
= c
= d
= e
= f
= 0;

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

Перенося очень длинный оператор, я сделаю это, где когда-либо я чувствую, что это имеет смысл... не обязательно на первом отступе. Так:

reallyLongMethodName (paramA,paramB,paramC);

не отформатировать как

reallyLongMethodName (paramA,
    paramB,
    paramC);

но закончился бы больше как

reallyLongMethodName (paramA,
                    paramB,
                    paramC);

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

Для if's и хитрость, я сделал бы что-то как

if((long test 1) 
&& (long test 2) 
&& (long test 3))
{
    code executed if true;
}

Я сказал бы, что действительно не имеет значения, какой метод Вы используете, если это соответствует следующим критериям:

• это разумно
• Вы применяете ту же конвенцию всюду по своему коду.

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

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

Всегда отступ, но если операторы являются особенными; мне нравится выстраивать в линию тесты, и я поместил дополнительное && операторы слева:

if (  (long test 1)
   && (long test 2)
   && (long test 3)) 
{
    code executed if true;
}

Получение по запросу && налево выровняться с if также возможно, но я нахожу, что эта альтернатива тяжелее читает.

Я сохраняю выражения в скобках на уровне их открытия:

if ((long test 1) &&
    (long test 2) &&
    (long test 3)) {
  code executed if true;
}

Это делает это очевидным, в каком уровне каждое выражение.

Я принимаю сторону к, "Не борются с IDE".

Однако мой IDE (Eclipse, Visual Studio) хочет повредиться, строки то, как они повреждаются.

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

У меня есть два простых правила:

1. Блок операторов: одно добавление отступа;
2. Продолжение строки: два добавления отступа или выровненная круглая скобка, независимо от того, что далее располагается с отступом.

Так, в, если случай:

if ((long test 1) &&
        (long test 2) &&
        (long test 3)) {
    code executed if true;
}

У меня есть небольшая вариация на то, что уже записано здесь:

if ((long test 1) &&
    (long test 2) &&
    (long test 3)) 
{
    code executed if true;
}

Мне нравится иметь мои булевы операторы в конце строки.

Долгие имена методов или методы с большим количеством параметров похожи на это:

reallyLongMethodName (paramA,
                      paramB,
                      paramC);

с битами, выровненными с параметрическим усилителем, ранее назвали; не скобка...

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

for(int i = 0; i < MAX; i++)
{
    if(!isPrime(i)) // predefined prime finding func
        continue;

    //now we have only prime values of i
}

Я задал подобный вопрос в прошлом:

Где перенести строку кода, особенно длинные списки аргументов?

Трудность с этим типом вопроса является своим субъективным характером, таким образом, я не смог принять ответ.

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

Необходимо попытаться предотвратить строки записи дольше, чем 80 символов вместо того, чтобы повредить их:

• Попытайтесь минимизировать добавление отступа путем преобразования условий и инкапсуляции кода.

Linus Torvalds: при необходимости больше чем в 3 уровнях добавления отступа Вы завинчены так или иначе,
и должен исправить Вашу программу.

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

bool encapsulatedLongCondition() // Add some parameters
{
  if (!condition1)
    return false;

  if (!condition2)
    return false;

  // ... (Other conditions)

  return true;
}    

if (encapsulatedLongCondition())
{
  // ... (Call some methods, try not to introduce deeper if/loop levels!)
}

Упрощение Вашего условия через булеву алгебру и попытка инвертировать условие и возвращаемое значение могут помочь много.:-)

См. также: Можно ли упростить этот алгоритм? См. также 2: Осуществите рефакторинг для C#, имеет способность помочь Вам с этим. ;-)

• Используйте определения типа и старайтесь избегать длинных имен

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

struct Day
{
  // Some data
};
struct Event
{
  // Some data
};
typedef list<Event> Events;
typedef map<Day, Event> Days;
// Some other container that would else be long...

• ... (Необходимо попытаться проанализировать, почему линия длинна, и найдите решение для нее),

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

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

void longFunctionName(ParameterType1 parameter1, ParameterType2 parameter2,
                      ParameterType3 parameter3, ParameterType4 parameter4)  

Обычно я делаю:

if (condition) {
     something;
}

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

if (
    (long test 1) &&
    (long test 2) &&
    (long test 3)
) {
    code executed if true;
}

Ключевые отличия от ответа rbobby:

1. Операторы в конце каждой строки вместо начала последующих строк, чтобы очень четко указать визуально, что строка является неполной.
2. Разрыв строки в первой строке перед условным элементом - это помогает поддерживать согласованность «формы» кода.
3. Закрывающая скобка без отступа.

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