Стиль отступа

Общее обсуждение отступов см. в разделе Отступы (набор текста) .

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

Обзор

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

Структурированные языки, такие как Python и occam , используют отступы для определения структуры вместо использования фигурных скобок или ключевых слов; это называется правилом офсайда . В таких языках отступы имеют значение для языкового процессора (например, компилятора или интерпретатора ). Программист должен соблюдать правила отступов языка, хотя может иметь право выбирать размер отступов.

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

Стиль отступов применяется только к текстовым языкам. В языках визуального программирования нет отступов.

Исследования

Несмотря на повсеместное использование стилей отступов, их ценность мало исследована. Первые эксперименты, проведенные Вейсманом в 1974 году, не показали никакого эффекта. В 2023 году эксперимент Морцека и др. показал значительный положительный эффект для вложенных if операторы, в которых для чтения кода без отступов требуется в среднем на 179 % больше времени, чем для кода с отступом.

Известные стили

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

Пример	Имя
while (x == y) { foo(); bar(); }	Оллман
while (x == y) { foo(); bar(); }	ГНУ
while (x == y) { foo(); bar(); }	Кузнецы
while (x == y) { foo(); bar(); }	К&Р
while (x == y) { foo(); bar(); }	Рэтлифф
while (x == y) { foo(); bar(); }	Хорстманн
while (x == y) { foo(); bar(); }	Пико
while (x == y) { foo(); bar(); }	Лисп
#define W(c,b) {while(c){b}} W(x==y,s();se();)	АПЛ
while x == y: foo() bar()	Питон

Стили C/C++

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

• Размещение фигурных скобок относительно других элементов кода.
• Использование табуляции или пробелов
• Заключение блоков с одним оператором в фигурные скобки. Сторонники ссылаются на то преимущество, что полученный код более безопасен, поскольку вставка оператора не может привести к потоку управления, не согласующемуся с отступами. Указанным недостатком является то, что код длиннее, поскольку для закрывающей скобки блока требуется одна строка (за исключением else if построить и do{}while блокировать).

К&Р

Стиль Кернигана и Ритчи (K&R) обычно используется для кода C и C++ и является основой для многих производных стилей. Он используется в исходном ядре Unix, Кернигана и Ритчи книге «Язык программирования C» , а также Кернигана и Плаугера в книге «Элементы стиля программирования» .

Хотя язык программирования C не дает явного определения этому стилю, он последовательно ему следует. Из книги:

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

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

Пример кода:

int main(int argc, char *argv[])
{
    while (x == y) {
        do_something();
        do_something_else();
        if (some_error)
            fix_issue(); // single-statement block without braces
        else
            continue_as_usual();
    }
    final_thing();
}

Египетские брекеты

Несоосные . скобки многострочных блоков получили прозвище «египетские скобки» (или «египетские скобки») за сходство с руками в некоторых причудливых позах древних египтян

Отдельные заявления

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

One True Brace

Единственный настоящий стиль брекетов (сокращенно 1TBS или OTBS ) похож на стиль K&R, но функции форматируются как блоки с несколькими операторами, с открывающей скобкой на той же строке, что и объявление, а фигурные скобки не опускаются для блока с одним оператором.

bool is_negative(int x) {
    if (x < 0) {
        return true;
    } else {
        return false;
    }
}

Хотя это и не требуется для таких языков, как C/C++, использование фигурных скобок для блоков с одним оператором гарантирует, что вставка оператора не приведет к тому, что поток управления не будет противоречить отступам, как это видно, например, в печально известной ошибке goto error от Apple .

Указанные преимущества включают более короткий код (чем K&R), поскольку начальная фигурная скобка не требует дополнительной строки, а конечная фигурная скобка соответствует оператору, которому она концептуально принадлежит. Одна из издержек этого стиля заключается в том, что завершающая скобка добавляет строку, что может быть частично разрешено в блоках if/else и do/ while.

Источники расходятся во мнениях относительно значения One True Brace Style. Некоторые говорят, что это указанный здесь вариант, в то время как другие говорят, что это «хакерский жаргон» для K&R.

Ядро Linux

Дерево исходного кода ядра Linux выполнено в стиле K&R. Линус Торвальдс советует участникам следовать ему. Атрибуты включают в себя:

• Использует символы табуляции для отступов (не пробелы) и предполагает, что табуляция осуществляется через каждые 8 ​​пробелов.
• Макет скобок соответствует K&R с открытием и закрытием на отдельных строках и открытием нескольких операторов в той же строке, что и управляющее предложение, разделенных пробелом.
• Этикетки в switch оператор выравнивается с окружающим блоком (есть только один уровень отступов)
• Максимальная длина строки — 100 символов, хотя до 2020 года предпочтительнее использовать ограничение в 80 символов.
• Тело составного оператора, состоящее из одного оператора (например, if, while и do- while ), не обязательно заключать в фигурные скобки. Однако если один или несколько подвыражений в if-else оператору требуются фигурные скобки, то оба подоператора должны быть заключены в фигурные скобки:

int power(int x, int y)
{
        int result;

        if (y < 0) {
                result = 0;
        } else {
                result = 1;
                while (y-- > 0)
                        result *= x;
        }
        return result;
}

Ява

Значительная часть кода Java использует вариант стиля K&R, в котором открывающая скобка находится на одной строке не только для блоков внутри функции, но также для объявлений классов или методов. Этот стиль широко распространен во многом благодаря Sun Microsystems. оригинальным руководствам по стилю компании использовал этот вариант K&R, и в результате большая часть стандартного исходного кода Java API написана в этом стиле. Это также популярный стиль отступов для ActionScript и JavaScript , наряду со стилем Allman .

Страуструп

Бьерн Страуструп адаптировал стиль K&R для C++ в своих книгах, таких как «Программирование: принципы и практика с использованием C++» и «Язык программирования C++» .

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

    if (x < 0) {
        puts("Negative");
        negative(x);
    }
    else {
        puts("Non-negative");
        nonnegative(x);
    }

Страуструп расширяет стиль K&R для классов, записывая их следующим образом:

    class Vector {
    public:
        // construct a Vector
        Vector(int s) :elem(new double[s]), sz(s) { }
        // element access: subscripting
        double& operator[](int i) { return elem[i]; }
        int size() { return sz; }
    private:
        // pointer to the elements
        double * elem;
        // number of elements
        int sz;
    };

Страуструп не делает отступов на этикетках public: и private:. Кроме того, в этом стиле открывающая скобка функции начинается с новой строки, а открывающая скобка класса находится на той же строке, что и имя класса.

Страуструп позволяет писать короткие функции в одной строке. Стиль Страуструпа — это именованный стиль отступов, доступный в редакторе Emacs . Страуструп поощряет использование C++ в стиле K&R, как указано в его современном C++ Core Guidelines .

БСД КНФ

В операционных системах Berkeley Software Distribution (BSD) используется стиль, который иногда называют нормальной формой ядра (KNF). Хотя в основном он предназначен для кода ядра, он также широко используется в пользовательском коде. По сути, это тщательно документированный вариант стиля K&R, который используется в исходном коде Unix версий 6 и 7 Bell Labs .

Ядро SunOS и пользовательское пространство используют аналогичный стиль отступов. Как и KNF, он также был основан на документах в стиле AT&T и иногда называется нормальной формой Билла Джоя. Рекомендации SunOS были опубликованы в 1996 году; ANSI C обсуждается кратко. Правильность отступов списка исходных файлов можно проверить с помощью программы cstyle, написанной Биллом Шенноном.

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

Более того, вызовы функций не используют пробел перед круглыми скобками, хотя собственные операторы языка C, такие как if, while, do, switch и return сделать (в случае, если return используется с круглыми скобками). Функции, которые не объявляют локальные переменные в блоке верхнего уровня, также должны оставлять пустую строку после открывающей блочной скобки.

Примеры:

while (x == y) {
        something();
        something_else();
}
final_thing();

if (data != NULL && res > 0) {
        if (JS_DefineProperty(cx, o, "data",
            STRING_TO_JSVAL(JS_NewStringCopyN(cx, data, res)),
            NULL, NULL, JSPROP_ENUMERATE) != 0) {
                QUEUE_EXCEPTION("Internal error!");
                goto err;
        }
        PQfreemem(data);
} else {
        if (JS_DefineProperty(cx, o, "data", OBJECT_TO_JSVAL(NULL),
            NULL, NULL, JSPROP_ENUMERATE) != 0) {
                QUEUE_EXCEPTION("Internal error!");
                goto err;
        }
}

static JSBool
pgresult_constructor(JSContext *cx, JSObject *obj, uintN argc,
    jsval *argv, jsval *rval)
{

        QUEUE_EXCEPTION("PGresult class not user-instantiable");

        return (JS_FALSE);
}

Оллман

Стиль Allman назван в честь Эрика Оллмана . Его также иногда называют стилем BSD , поскольку Оллман написал множество утилит для BSD Unix (хотя его не следует путать с другим «стилем BSD KNF»; см. выше).

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

while (x == y)
{
    something();
    something_else();
}

final_thing();

Этот стиль аналогичен стандартному отступу, используемому в языках Pascal и Transact-SQL , где фигурные скобки эквивалентны ключевым словам. begin и end.

(* Example Allman code indentation style in Pascal *)
procedure dosomething(x, y: Integer);
begin
    while x = y do
    begin
        something();
        something_else();
    end;
end;

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

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

// while (x == y)
{
    something();
    something_else();
}

Как это:

// for (int i=0; i < x; i++)
// while (x == y)
if (x == y)
{
    something();
    something_else();
}

Даже так, с условной компиляцией:

    int c;
#ifdef HAS_GETCH
    while ((c = getch()) != EOF)
#else
    while ((c = getchar()) != EOF)
#endif
    {
        do_something(c);
    }

Вариант: Оллман-8

Популярный вариант для использования в образовании. Allman-8 использует отступы в 8 пробелов и ограничение в 80 столбцов варианта K&R для ядра Linux. Этот стиль якобы помогает улучшить читаемость изображения на проекторах. Кроме того, размер отступа и ограничение столбцов помогают создать визуальный сигнал для выявления чрезмерной вложенности блоков кода. Эти преимущества в совокупности помогают предоставить новым разработчикам и учащимся неявное руководство по управлению сложностью кода.

Кузнецы

Стиль Whitesmiths, также иногда называемый стилем Wishart, первоначально использовался в документации для первого коммерческого компилятора C, Whitesmiths Compiler. Он также был популярен на заре Windows, поскольку использовался в трех влиятельных книгах по программированию для Windows: « Руководство программиста по Windows» , Дюранта Карлсона и Яо , « Программирование Windows » Петцольда и «Техники мощного программирования Windows 3.0» и Нортона Яо.

утверждал, что Уайтсмиты, наряду с Оллманом , были наиболее распространенными стилями крепления В 1991 году журнал Jargon File и имели примерно такую ​​же популярность в то время.

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

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

while (x == y)
    {
    something();
    something_else();
    }

final_thing();

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

Пример:

if (data != NULL && res > 0)
    {
    if (!JS_DefineProperty(cx, o, "data", STRING_TO_JSVAL(JS_NewStringCopyN(cx, data, res)), NULL, NULL, JSPROP_ENUMERATE))
        {
        QUEUE_EXCEPTION("Internal error!");
        goto err;
        }
    PQfreemem(data);
    }
else if (!JS_DefineProperty(cx, o, "data", OBJECT_TO_JSVAL(NULL), NULL, NULL, JSPROP_ENUMERATE))
    {
    QUEUE_EXCEPTION("Internal error!");
    goto err;
    }

else if рассматриваются как утверждение, во многом аналогично #elif заявление препроцессора.

GNU

Основная статья: Стандарты кодирования GNU

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

На макет, популяризированный Ричардом Столлманом , может повлиять его опыт написания кода на Lisp . В Лиспе эквивалентом блока (программы) является объект данных первого класса, и присвоение ему собственного уровня отступов помогает подчеркнуть это, тогда как в C блок — это всего лишь синтаксис. Этот стиль также можно найти в некоторых учебниках по языкам программирования ALGOL и XPL 1960-х и 1970-х годов.

Хотя это и не отступ как таковой, стиль кодирования GNU также включает пробел после имени функции – перед левой скобкой в ​​списке аргументов.

static char *
concat (char *s1, char *s2)
{
  while (x == y)
    {
      something ();
      something_else ();
    }
  final_thing ();
}

Этот стиль сочетает в себе преимущества Allman и Whitesmiths , тем самым устраняя возможный недостаток Whitesmiths, заключающийся в том, что брекеты не выделяются из блока. Одним из недостатков является то, что закрывающая скобка больше не соответствует утверждению, которому она концептуально принадлежит. Другим возможным недостатком является то, что использование двух визуальных уровней отступов для одного концептуального уровня может привести к потере места, но на самом деле это маловероятно, поскольку в системах с одноуровневыми отступами каждый уровень обычно занимает не менее 4 пробелов, что соответствует 2 *. 2 пробела в стиле GNU.

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

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

Стив МакКоннелл в своей книге Code Complete не советует использовать этот стиль: он помечает пример кода, в котором он используется, значком «Coding Horror», символизирующим особо опасный код, и заявляет, что это ухудшает читаемость. также Документация по стилю кодирования ядра Linux не рекомендует использовать этот стиль, призывая читателей сжечь копию стандартов кодирования GNU как «великий символический жест».

Horstmann

Издание 1997 года « Концепции вычислений с основами C++» Кея С. Хорстманна адаптирует Allman , помещая первый оператор блока в ту же строку, что и открывающую скобку. Этот стиль также используется в примерах в «Руководстве пользователя и отчете пользователя Pascal» Дженсена и Вирта .

while (x == y)
{   something();
    something_else();
    //...
    if (x < 0)
    {   printf("Negative");
        negative(x);
    }
    else
    {   printf("Non-negative");
        nonnegative(x);
    }
}
final_thing();

Этот стиль сочетает в себе преимущества Allman, сохраняя вертикальное выравнивание фигурных скобок для удобства чтения и легко идентифицируя блоки с сохранением линии стиля K&R. Однако в издании 2003 года теперь повсюду используется стиль Allman.

Пико

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

stuff(n):
{ x: 3 * n;
  y: do_stuff(x);
  y + x }

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

Рэтлифф

В книге « Программисты за работой » К. Уэйн Рэтлифф, автор популярных dBase -II и -III языков программирования четвертого поколения , обсуждался стиль, похожий на 1TBS, но закрывающая скобка совпадает с отступом вложенного блока. Он отметил, что этот стиль изначально был задокументирован в материалах Digital Research Inc. Этот стиль иногда называют стилем баннера . возможно, из-за сходства со знаменем, висящим на шесте. В этом стиле, который для Whitesmiths то же самое, что K&R для Allman, закрывающий элемент управления имеет такой же отступ, как и последний элемент в списке (и, таким образом, правильно теряет заметность). Для некоторых этот стиль может облегчить визуальное сканирование, поскольку заголовки любого блока — единственное, что выделяется на этом уровне (теоретически, элемент управления закрытием предыдущего блока мешает визуальному потоку заголовка следующего блока в K&R и стили Оллмана). Керниган и Плаугер используют этот стиль в коде Ratfor в Software Tools .

 // In C
 for (i = 0; i < 10; i++) {
     if (i % 2 == 0) {
         do_something(i);
         }
     else {
         do_something_else(i);
         }
     }

Стили языка, производные от C

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

Стиль Лиспа

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

Традиционный вариант этого стиля в Лиспе предпочитает чрезвычайно узкие уровни отступов (обычно два пробела), поскольку код Лиспа обычно вложен очень глубоко, поскольку в Лиспе есть только выражения , без отдельного класса операторов ; Аргументы функции обычно имеют отступ до одного и того же уровня, чтобы проиллюстрировать их общий статус внутри заключающего выражения. Это также связано с тем, что, если оставить в стороне фигурные скобки, Lisp традиционно является очень кратким языком, в котором опускаются даже распространенные формы простого шаблонного кода как неинформативные, такие как else ключевое слово в if : then | else блок, вместо этого отображая его равномерно как (if expr1 expr2 expr3).

// C
for (i = 0; i < 10; i++)
    {if (i % 2 == 0)
        {do_something(i);}
     else
        {do_something_else(i);
         do_third_thing(i);}}

 

;; Lisp
(dotimes (i 10)
  (if (= (rem i 2) 0)
      (do-something i)
    (progn
      (do-something-else i)
      (do-third-thing i))))

^{Примечание: progn — это процедура последовательного вычисления нескольких подвыражений для эффектов , при этом отбрасываются все возвращаемые значения, кроме конечного (n-го). Если все возвращаемые значения желательны, values будет использована процедура.}

Стиль Haskell

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

braceless = do
  text <- getContents
  let
    firstWord = head $ words text
    bigWord = map toUpper firstWord
  putStrLn bigWord

braceful = do
  { text <- getContents
  ; let
      { firstWord = head $ words text
      ; bigWord = map toUpper firstWord
      }
  ; putStrLn bigWord
  }

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

Стиль APL

В качестве примера того, насколько краток обычно APL, вот реализация ступенчатой ​​функции для Game of Life:

life←{⊃1⍵∨.∧3 4=+/+⌿¯1 0 1∘.⊖¯1 0 1⌽¨⊂⍵}

Стиль APL C напоминает краткий стиль кода APL и обычно используется в их реализациях. Этот стиль был впервые предложен Артуром Уитни и широко используется при реализации K , собственного проекта Артура. Язык программирования J также реализован в этом стиле. Примечательно, что не все реализации APL используют этот стиль C, а именно: GNU APL и Dyalog APL.

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

Стиль Python

Python не использует фигурные скобки. Отступ определяет блоки в так называемом правиле «вне игры» .

for i in range(10):
    if i % 2 == 0:
        do_something(i)
    else:
        do_something_else(i)
        do_third_thing(i)

Условно отступ составляет четыре пробела. Вкладки также возможны.

Размер отступа

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

Эксперимент, проведенный с кодом PASCAL в 1983 году, показал, что размер отступов существенно влияет на понятность. Оптимальными оказались размеры отступов от 2 до 4 символов. Для Ruby , многих языков сценариев оболочки и некоторых форм форматирования HTML обычно используются два пробела на уровень отступа.

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

Табуляция против пробела

Обычно программист использует текстовый редактор, который предоставляет позиции табуляции через фиксированные интервалы (количество пробелов), чтобы помочь сохранить пробелы в соответствии со стилем. Этот интервал называется шириной табуляции . Иногда программист хранит код с символами табуляции — по одному на каждое нажатие клавиши табуляции, или они хранят последовательность пробелов, количество которых равно ширине табуляции.

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

У программистов нет единого мнения по поводу хранения символов табуляции. Сторонники хранения символов табуляции ссылаются на простоту набора текста и меньший размер текстовых файлов, поскольку один символ табуляции служит для нескольких пробелов. Оппоненты, такие как Джейми Завински , заявляют, что использование пробелов вместо этого увеличивает межплатформенную переносимость . Другие, например, авторы стандартов кодирования WordPress , утверждают обратное: жесткие вкладки повышают переносимость. Опрос 400 000 лучших репозиториев на GitHub показал, что пробелы встречаются чаще.

Многие текстовые редакторы, включая Notepad++ , TextEdit , Emacs , vi и nano , можно настроить либо на сохранение символов табуляции при вводе с помощью клавиши табуляции, либо на преобразование их в пробелы (в зависимости от настроенной ширины табуляции), чтобы символы табуляции не добавляется в файл при нажатии клавиши табуляции. Некоторые редакторы могут преобразовывать символы табуляции в пробелы и наоборот.

Некоторые пейджеры текстовых файлов , такие как less , можно настроить на ширину табуляции. Некоторые инструменты, такие как развернуть / свернуть, можно конвертировать на лету с помощью фильтров.

Автоматизация стиля

Инструмент может автоматизировать код форматирования в соответствии со стилем отступов, например Unix. indent команда.

Emacs предоставляет команды для изменения отступов, включая нажатие Tab по заданной строке. M-x indent-region код отступов.

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

Потеря блоков из виду

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

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

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

Чтобы не потерять след управляющих операторов, таких как forможно использовать большой отступ, например жесткую табуляцию шириной 8 единиц, а также разбивать большие функции на более мелкие и более читаемые функции. Linux реализован таким образом, используя стиль K&R.

Некоторые текстовые редакторы позволяют программисту переключаться между двумя соответствующими фигурными скобками блока. Например, vi переходит к фигурной скобке, заключающей в себе тот же блок, что и блок под курсором, при нажатии клавиши % ключ. Поскольку текстовый курсор next ключ (т. n клавиша) сохраняет информацию о направлении позиционирования (независимо от того, up или down ранее была нажата клавиша), макрос точки (кнопка . key) затем можно было бы использовать для размещения текстового курсора на следующей фигурной скобке, учитывая подходящий стиль кодирования. Вместо этого проверка границ блока с помощью % Ключ может использоваться для обеспечения соблюдения стандарта кодирования.

Другой способ сохранить распознавание блоков — использовать комментарии после закрывающей скобки. Например:

for (int i = 0; i < total; i++) {
    foo();
} //for (i)

if (x < 0) {
   bar();
} //if (x < 0)

Недостатком является сохранение одного и того же кода в нескольких местах — над и под блоком.

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

Вставка заявления

Стиль K&R предотвращает распространенную ошибку, возникающую при вставке строки кода после управляющего оператора – перед открывающей скобкой. Вставленная строка приводит к тому, что блок отделяется от управляющего оператора.

Учитывая этот стартовый код:

for (int i = 0; i < 10; i++)
{
    do_something();
} //for (i)

do_something будет вызван 10 раз. Затем он модифицируется путем добавления новой второй строки:

for (int i = 0; i < 10; i++)
    do_something_else();
{
    do_something(); // called once!
} //for (i)

Исходный блок (строки 3–5) больше не является телом for цикл и выполняется только один раз. Далее комментарий в строке 5 становится неверным.

Стиль K&R позволяет избежать этой проблемы, размещая управляющий оператор и открывающую скобку на одной строке.

Оригинал:

for (int i = 0; i < 10; i++) {
    do_something();
} //for (i)

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

for (int i = 0; i < 10; i++) {
    do_something_else();
    do_something();
} //for (i)

См. также

• Вторичные обозначения
• Подсветка синтаксиса
• Отступ (набор текста) § Отступ в программировании
• Bachmanity Insanity , эпизод из Кремниевой долины, посвященный этой теме.
• Форматёр исходного кода

Внешние ссылки

• Стиль C: Стандарты и рекомендации: Определение стандартов программирования для профессиональных программистов на C , Prentice Hall, ISBN   0-13-116898-3 / ISBN   978-0-13-116898-5 (полный текст также доступен в Интернете). Стрейкер, Дэвид (1992).
• Контекстный отступ
• Стандарты кодирования GNU
• Программы форматирования исходного кода в Curlie

Табуляции и пробелы

• Табуляция против пробелов: Вечная священная война Джейми Завински
• Почему я предпочитаю отсутствие табуляций в исходном коде Адама Спирса
• Почему мне нравится иметь вкладки в исходном коде (в архиве)
• Эластичные табуляции – решение проблемы табуляции и пробелов