Форматирование если Операторы

Мне не нравятся закрывающие фигурные скобки на той же строке со следовать ключевым словом:

if (x) {
    print "x is true";    
} else {
    do something else;
}

Это мешает к remove/comment-out просто выражение else. Путем помещения следовать ключевого слова на следующую строку я могу обмануть, например, редакторов, которые позволяют мне выбрать диапазон строк и комментировать/не комментировать их внезапно.

if (x) {
    print "x is true";    
}
//else {
//    do something else;
//}

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

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

/* I type one liners with brackets like this */
if(0){return(0);}
/* If else blocks like this */
if(0){
    return(0);
}else{
    return(-1);
}

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

Я всегда предпочитаю это:

if (x) doSomething();

if (x) {
    doSomthing();
    doOtherthing();
}

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

Независимо от того, что, это - путь, я иду! Это смотрит лучшее.

If(x)
{
    print "Hello World !!"
}
Else
{
    print "Good bye!!"
}

Если Вам любопытно, каковы названия различных стилей форматирования кода, Википедия имеет статью о Стилях Отступа.

Если Вы делаете что-то вроде этого:

if(x)
{
    somecode;
}
else
{
    morecode;
}

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

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

пока это последовательно среди команды, Вы работаете в затем, это не имеет значения слишком много

то, что все делают то же, является главным

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

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

Мне сильно не нравится любой стиль, который помещает тест if и тело на той же строке.

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

Всегда использование фигурных скобок является хорошей идеей, но стандартный ответ, который это всегда дается "что, если кто-то добавляет строку кода и забывает добавлять фигурные скобки?" довольно слабая причина.

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

Это начинается, невинно достаточно, с простым если оператор.

if (condition)
    do_something();
else
    do_something_else();

Который является всем хорошо и хороший.

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

if (condition)
    if (condition2)
        do_something();
else
    do_something_else();

Вы видите проблему? Это может выглядеть правильным, но компилятор видит его по-другому. Это видит его как это:

if (condition)
    if (condition2)
        do_something();
    else
        do_something_else();

Что означает что-то совершенно другое. Компилятор не заботится о форматировании. Еще идет с ближайшим если. Люди, с другой стороны, полагаются на форматирование и могут легко пропустить проблему.

Я использую

if (x)
{
    DoSomething();
}

для нескольких строк, но я предпочитаю без скобки лайнеры:

if (x)
   DoSomething();
else
   DoSomethingElse();

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

Я всегда использую

if(x) 
{
    print "x is true";    
}

игнорирование фигурных скобок может привести к кому-то поддерживающему код, по ошибке думая, что они добавляют к выражению if, если они добавляют строку после текущей строки.

if
{
// code
}
else 
{
// else code
}

потому что мне нравится, когда блоки кода выстраиваются в линию (включая их фигурные скобки).

Как Матовый (3 выше), я предпочитаю:

if (x)
{
    ...statement1
    ...statement2
}

и

if (x)
    ...statement
else
    ...statement

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

Я склоняюсь только к одной строке, когда я тестирую на, нарушают условия в начале функции, потому что мне нравится сохранять этот код максимально простым и ненарушенным

public void MyFunction(object param)
{
     if (param == null) return;

     ...
}

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

Если я кодирую:

if(x) 
    print "x is true";

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

if(x) 
    print "x is true";
    print "x is still true";

который привел бы к логической ошибке, по сравнению с:

if(x) { 
    print "x is true";
    print "x is still true";
}

Таким образом, фигурные скобки совершают такие логические ошибки, легче считать и избежать, я нахожу.

Отдельный оператор, если блоки, испытывающие недостаток в фигурных скобках:

Профессионалы:

• меньше символов
• более чистый взгляд

Недостатки:

• однородность: не все, если блоки выглядят одинаково
• потенциал для ошибок при добавлении операторов к блоку: пользователь может забыть добавлять фигурные скобки, и новый оператор был бы не быть покрытым если.

Как в:

if(x) 
    print "x is true";
    print "something else";

Я использую

if (cond) {
  ...
} else {
  ...
}

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

Joel Spolsky написал хорошую статью: Создание Взгляда Неверного кода Неправильно

Он конкретно решает эту проблему …

if (i != 0)  
    foo(i);

В этом случае код является на 100% правильным; это соответствует большинству конвенций кодирования и нет ничего неправильно с ним, но то, что тело отдельного оператора оператора "if" не включается в фигурные скобки, может прослушивать Вас, потому что Вы могли бы думать позади головы, черт возьми, кто-то мог бы вставить другую строку кода там

if (i != 0)
    bar(i);
    foo(i);

… и забывают добавлять фигурные скобки и таким образом случайно делать нечто (i) безусловным! Таким образом, когда Вы видите блоки кода, которые не находятся в фигурных скобках, Вы могли бы обнаружить просто крошечное, крошечное, soupçon нечистоплотности, которая делает Вас обеспокоенными.

Он предполагает что Вы …

… сознательно проектируют Ваш код таким способом, которым Ваш нос для нечистоплотности делает Ваш код более вероятно, чтобы быть корректным.

Пробел является Вашим другом....

но с другой стороны мне нравится:

if (foo)
{
    Console.WriteLine("Foobar");
}

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

if (x)
   print "x is true"
for (int i=0; i<10; i++)
   print "y is true"

И т.д. Если кто-то должен добавить другой оператор затем, он может просто добавить фигурные скобки. Даже если у Вас нет R# или чего-то подобного, это - очень маленькое соглашение.

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

Серьезно, когда прошлый раз, когда у Вас была ошибка в любом коде где угодно, который был причиной, которую кто-то сделал:

if (a)
  foo();
  bar();

Да, никогда...* Единственное реальное 'про' здесь должно просто соответствовать стилю окружающего кода и покинуть эстетические сражения детям, которые просто вышли из колледжа.

* (протест, являющийся, когда нечто (); панель (); было макрорасширение, но это - проблема w/макросы, не фигурные скобки w/IFS.)

if (x) {
    print "x is true";    
}
else {
    do something else;
}

Я всегда ввожу фигурные скобки. Это - просто хорошая привычка. По сравнению со взглядами ввод не является "работой".

Отметьте пространство перед условным выражением. Это помогает ему не походить на вызов метода.

if (x)
{
    print "x is true";
}

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

В единственное время, без заключения в фигурные скобки, кажется, принят, когда переменные проверки параметра в начале метода:

public int IndexOf(string haystack, string needle)
{
    // check parameters.
    if (haystack == null)
        throw new ArgumentNullException("haystack");
    if (string.IsNullOrEmpty(needle))
        return -1;

    // rest of method here ...

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

• метод выходит на любом истинном ответвлении
• довольно очевидно, что это все 1 лайнер

Тем не менее я всегда был бы {} для логики программы по причинам, указанным другими. При отбрасывании фигурных скобок, слишком легко мысленно заключить в фигурные скобки, когда это не там, и представьте тонкие дефекты кода.

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

До удобочитаемости я предпочитаю следующее:

// Do this if you only have one line of code
// executing within the if statement
if (x)
    print "x is true";

// Do this when you have multiple lines of code
// getting executed within the if statement    
if (x)
{
    print "x is true";
}

Для меня фигурные скобки помогают видеть поток программы. Это также помогает добавить оператор к телу если оператор. Когда нет фигурных скобок, необходимо добавить фигурные скобки для добавления другого оператора.

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