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

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

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

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

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

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

Я нахожу это:

if ( true ) {
    DoSomething();
} else {
    DoSomethingElse();
}

лучше чем это:

if ( true )
    DoSomething();
else
    DoSomethingElse();

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

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

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

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

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

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

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

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

Расстояние между строками и отступы могут значительно улучшить читаемость.

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

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

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

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. Мелочь, может быть, но поэтому пользуюсь ею.

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

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

я использую

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

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

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

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

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

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

Плюсы:

• меньше персонажей
• более чистый вид

Минусы:

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

As in:

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

Независимо от того, что я иду! Смотрится лучше всего.

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

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

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

Он специально занимается этим вопросом ...

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

In this case the code is 100% correct; it conforms to most coding conventions and there’s nothing wrong with it, but the fact that the single-statement body of the ifstatement is not enclosed in braces may be bugging you, because you might be thinking in the back of your head, gosh, somebody might insert another line of code there

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

… and forget to add the braces, and thus accidentally make foo(i)unconditional! So when you see blocks of code that aren’t in braces, you might sense just a tiny, wee, soupçon of uncleanliness which makes you uneasy.

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

… deliberately architect your code in such a way that your nose for uncleanliness makes your code more likely to be correct.

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

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

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

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

Я бы хотел, чтобы среда IDE обеспечивала такое поведение. Как вы правильно заметили, «правильного» поведения не бывает. Последовательность важнее ... это может быть любой стиль.

Я использую

if (x)
{
    DoSomething();
}

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

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

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

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

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

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

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

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

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

     ...
}

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

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

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

и

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

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

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

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

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

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

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

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

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

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

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

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

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

Он начинается довольно невинно с простого оператора if.

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

Что все хорошо.

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

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

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

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

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

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

if (expr) {
   funcA();
}
else {
   funcB();
}

Или сокращенное обозначение в ограниченных случаях для удобочитаемости:

if (expr) funcA();
else funcB();

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

if (expr)
   funcA();
else
   funcB();

С осторожностью я не помещаю вложенные условные выражения в блоки if / else, чтобы избежать двусмысленности кодера / компилятора. Если что-то сложнее, я использую скобы как на блоках if, так и на 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);
}

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

Похоже, что единственное время, когда запреты на фиксацию не принимаются, - это когда параметры проверяют переменные в начале метода:

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

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

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

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

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

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

Из предложенных вариантов я бы выбрал

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

просто потому, что скобки - это привычка печатать.

На самом деле, как программист, в основном использующий Perl, я, скорее всего, буду использовать

print "x is true" if x;

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

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

if (x)
    x = x + 1;
    printf("%d\n", x);

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

#define FREE(ptr) {free(ptr); ptr = NULL;}

if (x)
    FREE(x);
else
    ...

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

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

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

Я предпочитаю следующее ... я думаю, что это выглядит чище.

if (x)
{
    code;
}
else
{
     other code;
}

Мне не нравятся закрывающие фигурные скобки в одной строке с ключевым словом 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)
{ foo(); }

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

Он также более удобен для точек останова, чем однострочные if. Я также чувствую себя более комфортно в моем мире фигурных скобок на новой строке:

if (x)
{ foo(); }
else
{
   bar();
   baz();
}

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

Один вкладыш - это просто ... один вкладыш и должен оставаться таким:

if (param == null || parameterDoesNotValidateForMethod) throw new InvalidArgumentExeption("Parameter null or invalid");

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

if (something)
{
    for(blablabla)
    {
    }
}else if
{
 //one liner or bunch of other code all get the braces
}else
{
  //... well you get the point
}

При этом ... Я презираю фигурные скобки в одной строке вот так:

if (someCondition) { doSimpleStuff; }

худшего

if (somethingElse){
  //then do something
}

Он более компактный, но мне сложнее следить за подтяжками.

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

    if (someStuff)
        {
  //do something
        }

Другой способ - написать:

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

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

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

Будь прокляты 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 (x)
   DoSomething();

прерывается, если DoSomething впоследствии переопределяется как макрос с несколькими операторами:

#define DoSomething()          statement1 ;statement2 ;

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

#define DoSomething()    do {statement1 ;  statement2 ;  } while (0)

Тем не менее, я признаю, что не следую своему собственному совету; Я обычно не использую фигурные скобки, когда у меня есть (что кажется) единственное утверждение. (От стыда опускает голову.)