Форматирование операторов if

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

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

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

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

Он начинается, достаточно невинно, с простого утверждения if.

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

Это все хорошо и хороший.

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

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

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

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

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

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

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

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

Я использую

if (x)
{
    DoSomething();
}

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

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

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

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

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

Если я код:

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";
}

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

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

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

и

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

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

одиночный оператор, если блоки не имеют фигурных скобок:

плюсы:

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

плюсы:

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

в:

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

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

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

     ...
}

кроме того, если я нахожу, что хочу избежать фигурных скобок и встроить код предложения if, я могу выделить их в одну строку, так что очевидно, что кто-то добавляет новые строки в if, что скобки должны быть добавлены

Я использую

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

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

Джоэл Спольски написал хорошую статью: Неправильный Код Выглядит Неправильно

он специально обращается к этой проблеме...

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

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

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

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

он предлагает вам...

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

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

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

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

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

пробел - ваш друг ....

но, опять же, мне нравится:

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

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

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

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

*(будьте осторожны, когда foo(); bar (); был расширением макроса, но это проблема с макросами, а не фигурные скобки с ifs.)

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

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

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

другим способом было бы написать:

(a==b) ? printf("yup true") : printf("nop false");

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

int x = (a==b) ? printf("yup true") : printf("nop false");

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

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

Кажется, что единственный раз, когда нет привязки,-это когда параметр проверяет переменные в начале метода:

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 ...

единственное преимущество-это компактность. Программисту не нужно пробираться через ненужные {}, когда совершенно очевидно, что:

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

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

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

if(x > y)      { xIsGreaterThanY(); }
else if(y > x) { yIsGreaterThanX; }
else           { xEqualsY(); }

это гораздо более читабельным для меня:

if( x > y ){
    xIsGreaterThanY(); 
}else if( x < y){
    yIsGreaterThanX();
}else{
    xEqualsY();
}

это имеет дополнительное преимущество, поощряя людей к абстрактной логике в методы (как я сделал), а не продолжать объединять больше логики во вложенные блоки if-else. Он также занимает три строки, а не Семь, что может сделать его возможно, не нужно прокручивать, чтобы увидеть несколько методов или другой код.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

if (x) doSomething();

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

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

независимо от того, что, это путь я иду! Выглядит лучше всех.

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

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