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

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

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

Обзор

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

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

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

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

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

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

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

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

Пример	Имя
в то время как ( Икс == y ) { Foo (); бар (); }	Оллман
в то время как ( Икс == y ) { Foo (); бар (); }	ГНУ
в то время как ( Икс == y ) { Foo (); бар (); }	Кузнецы
в то время как ( Икс == y ) { Foo (); бар (); }	К&Р
в то время как ( Икс == y ) { Foo (); бар (); }	Рэтлифф
в то время как ( Икс == y ) { Foo (); бар (); }	Хорстманн
в то время как ( Икс == y ) { Foo (); бар (); }	Пико
в то время как ( Икс == y ) { Foo (); бар (); }	Лисп
#define W(c,b) { while(c){b}} W ( x == y , s (); se ();)	АПЛ
в то время как 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  (); 
          если   (  some_error  ) 
             fix_issue  ();    // блок с одним оператором без фигурных скобок 
         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  ; 
      }   Еще   { 
         вернуть   ложь  ; 
      } } 
 } 

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

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

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

Ядро Linux

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

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

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

          если   (  y   <   0  )   { 
                 результат   =   0  ; 
          }   Еще   { 
                 результат   =   1  ; 
                  while   (  y  --   >   0  ) 
                         результат   *=   x  ; 
          } 
         вернуть   результат  ; 
  } 

Ява

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

Страуструп

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

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

    if   (  x   <   0  )   { 
         puts  (  «Отрицательный»  ); 
          отрицательный  (  х  ); 
      } 
     else   { 
         puts  (  "Неотрицательный"  ); 
          неотрицательный  (  x  ); 
      } 

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

    class   Vector   { 
     public  : 
         // создаем Vector 
         Vector  (  int   s  )   :  elem  (  new   double  [  s  ]),   sz  (  s  )   {   } 
         // доступ к элементу: индексация 
         double  &   оператор  [](  int   i  )   {   return   elem  [  я  ];    } 
         int   size  ()   {   return   sz  ;    } 
     Private  : 
         // указатель на элементы 
         double   *   elem  ; 
          // количество элементов 
         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  )   { 
         что-то  (); 
          что-то другое  (); 
  } 
 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  (  " Внутренняя ошибка!"  ); 
                  перейти   к ошибке  ; 
          } 
         PQfreemem  (  данные  ); 
  }   else   { 
         if   (  JS_DefineProperty  (  cx  ,   o  ,   "data"  ,   OBJECT_TO_JSVAL  (  NULL  ), 
             NULL  ,   NULL  ,   JSPROP_ENUMERATE  )   !=   0  )   { 
                 QUEUE_EXCEPTION  (  "Внутренняя ошибка!"  ); 
                  перейти   к ошибке  ; 
          } 
 } 

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

         QUEUE_EXCEPTION  (  «Класс PGresult не может быть создан пользователем»  ); 

          возврат   (  JS_FALSE  ); 
  } 

Оллман

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

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

while   (  x   ==   y  ) 
 { 
     что-то  (); 
      что-то другое  (); 
  } 

 Final_thing  (); 

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

(* Пример стиля отступов кода Allman в Паскале *) 
 процедура   dosomething  (  x  ,   y  :   Integer  )  ; 
  начать 
     , пока   x   =   y,   что 
     начать 
         -то  ()  ; 
          что-то другое  ()  ; 
      конец  ; 
  конец  ; 

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

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

// while (x == y) 
 { 
     что-то  (); 
      что-то другое  (); 
  } 

Как это:

// for (int i=0; i < x; i++) 
 // while (x == y) 
 if   (  x   ==   y  ) 
 { 
     Something  (); 
      что-то другое  (); 
  } 

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

    интервал   с  ; 
  #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  ) 
     { 
     что-то  (); 
      что-то другое  (); 
      } 

 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  (  "Внутренняя ошибка) !"  ); 
          перейти   к ошибке  ; 
          } 
     PQfreemem  (  данные  ); 
      } 
 else   if   (  !  JS_DefineProperty  (  cx  ,   o  ,   "data"  ,   OBJECT_TO_JSVAL  (  NULL  ),   NULL  ,   NULL  ,   JSPROP_ENUMERATE  )) 
     { 
     QUEUE_EXCEPTION  (  "Внутренняя ошибка!"  ); 
      перейти   к ошибке  ; 
      } 

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

ГНУ

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

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

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

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

static   char   * 
 concat   (  char   *  s1  ,   char   *  s2  ) 
 { 
   while   (  x   ==   y  ) 
     { 
       Something   (); 
        что-то другое   (); 
      } 
   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  ) 
 {     что-то  (); 
      что-то другое  (); 
      //... 
     if   (  x   <   0  ) 
     {     printf  (  "Negative"  ); 
          отрицательный  (  х  ); 
      } 
     else 
     {     printf  (  «Неотрицательный»  ); 
          неотрицательный  (  x  ); 
      } 
 } 
 Final_thing  (); 

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

Пик

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

материал (н):
 { х: 3 * п;
   y: do_stuff (х);
   у + х }
 

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

Рэтлифф

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

 // В C 
  for   (  i   =   0  ;   i   <   10  ;   i  ++  )   { 
      if   (  i   %   2   ==   0  )   { 
          do_something  (  i  ); 
           } 
      Еще   { 
          do_something_else  (  я  ); 
           } 
      } 

Стили языка, производные от 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  ); 
           сделать_третью_вещь  (  я  );}} 

 

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

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

Стиль Haskell

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

braceless   =   do 
   text   <-   getContents 
   let 
     firstWord   =   head   $   words   text 
     bigWord   =   сопоставить   toUpper   firstWord 
   putStrLn   bigWord 

 braceful   =   do 
   {   text   <-   getContents 
   ;    let 
       {   firstWord   =   head   $   words   text 
       ;    bigWord   =   сопоставить   верхнее   первое слово 
       } 
   ;    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 не использует фигурные скобки. Отступ определяет блоки в так называемом правиле «вне игры» .

для   i   в   диапазоне  (  10  ): 
     если   я   %   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) затем можно было бы использовать для размещения текстового курсора на следующей фигурной скобке, учитывая подходящий стиль кодирования. Вместо этого проверка границ блока с помощью % Ключ может использоваться для обеспечения соблюдения стандарта кодирования.

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

для   (  int   я   знак равно   0  ;   я   <   всего  ;   я  ++  )   { 
     foo  (); 
  }   //для (я) 

если   (  Икс   <   0  )   { 
    бар  (); 
  }   //если (х < 0) 

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

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

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

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

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

for   (  int   я   =   0  ;   я   <   10  ;   я  ++  ) 
 { 
     do_something  (); 
  }   //для (я) 

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

for   (  int   i   =   0  ;   i   <   10  ;   я  ++  ) 
     do_something_else  (); 
  { 
     сделай что-нибудь  ();    // вызывается один раз! 
  }   //для (я) 

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

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

Оригинал:

for   (  int   я   =   0  ;   я   <   10  ;   я  ++  )   { 
     do_something  (); 
  }   //для (я) 

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

for   (  int   я   =   0  ;   я   <   10  ;   я  ++  )   { 
     do_something_else  (); 
      сделай что-нибудь  (); 
  }   //для (я) 

См. также

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

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

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

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

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