Пора завязывать использовать символы табуляции в коде

    единорог и табуляции


    Многие могут счесть спор, о том, что лучше пробелы или табуляции в коде за holy wars. Однако нет, я не хочу устраивать дискуссию на эту тему. Я однозначно утверждаю, что в обязательном порядке следует использовать пробелы. И разговор и «предпочтении того или иного» здесь не уместен. Как не уместно в наше время обсуждать, что удобнее, компьютер или печатная машинка. Поскольку печатные машинки закончили свое существование, ориентироваться в дальнейшем на их использование, по меньшей мере, нерационально. А если ещё учесть, сколь удобнее пользоваться компьютером для набора текста, то вопрос выбора просто отпадает.



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



    Эту заметку меня побудило написать то, что табуляции мне надоели. Вроде и мелочь. Но идут годы, а эта инфекция у программистов всё никак не проходит. Хотя сам я при написании кода не использую табуляции, тем не менее, регулярно вспоминаю недобрым словом их поклонников. Не волнуйтесь, от этого сон и аппетит у меня не нарушается, но некоторое время впустую я трачу. А если учесть, сколько еще людей сталкивается с аналогичными досадными моментами, то суммарный вред весьма ощутимый. И если от спама выгоду получают хотя бы спамеры, то от использования табов выгоды не получает никто. Энергия уходит в никуда. Этот как капающий кран. Одна капля, которую тратит программист, не существенна. Но в сумме уже столько утекло и продолжает утекать, ужас. Предлагаю дочитать эту статью и, наконец, прекратить эту утечку!



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



    1) Объем файлов с исходным кодом меньше.



    2) Замена всех пробелов может привести к потере истории правок. Нельзя будет сравнить старое и новое.



    3) Изменяя длину табуляции, я легко могу настроить отступы в программе под свое предпочтение.



    Займемся критикой чистого разума.



    1) Объем файлов с исходным кодом меньше



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



    2) Замена всех пробелов может привести к потере истории правок. Нельзя будет сравнить старое и новое.



    Формально тоже всё верно. Но, пожалуй, это слишком мрачная картина. Так ли уж часто вам приходится исследовать историю файла на большую глубину? Обычно никто не заглядывает в историю глубже одной-двух ревизий файла. Замена табуляции на пробелы делается глобально и один раз и не должна мешать дальнейшим сравнениям.



    Если надо часто и глубоко по времени сравнивать файлы, то это что-то в консерватории не то. И тут уже не до пробелов/табуляций. А если нормальному программисту в нормальном проекте все-таки раз в год придется историю одного файла до 10-ого колена изучать, то ему тот же WinMerge поможет. Он умеет замену табуляций на пробел за отличие не считать. Думаю и другие системы сравнения не хуже.



    В общем, тоже не аргумент. А если и аргумент, то уж очень слабенький.



    3) Изменяя длину табуляции, я легко могу настроить отступы в программе под свое предпочтение.



    Никогда не работает на практике.



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



    Сделаю небольшое отступление. На самом деле в утверждении зерно смысла есть. Вот только выдранное из контекста, оно бестолково. Подобное может работать только тогда, где код выравнивается ТОЛЬКО табуляцией. Пробелы для выравнивания НЕ ИСПОЛЬЗУЮТСЯ ВООБЩЕ. В этом случае да, меня размер табуляции, мы можем менять отображения кода. Например, одному нравится смотреть на такой код (один таб = 2 пробела):



      if(A==B)
        x = y;

    Другой использует другой размер и любуется на этот же код в своем любимом стиле (один таб = 4 пробела):



        if(A==B)
            x = y;

    Вот только никто так не делает. Походите по своему коду и вы увидете что-то более реалистичное (один таб = 2 пробела):



      A=Aaaaaaaaaaaa &&
        Bbbbbbbbb;

    Если теперь таб станет равен не двум пробелам, то вся красота оформления моментально нарушится.



        A=Aaaaaaaaaaaa &&
            Bbbbbbbbb;

    Или вот, я взял и смотрю чей-то файл. Кто-то старался, выравнивал:



    wcex.cbSize          = sizeof(WNDCLASSEX);
    wcex.style           = WS_OVERLAPPED  ;
    wcex.lpfnWndProc     = (WNDPROC)ClipBoardWndProc;
    wcex.cbClsExtra      = 0;
    wcex.cbWndExtra      = 0;
    wcex.hInstance       = theApp.m_hInstance;
    wcex.hIcon           = 0;
    wcex.hCursor         = ::LoadCursor(NULL, IDC_ARROW);
    wcex.hbrBackground   = (HBRUSH)(COLOR_WINDOW+1);

    Вот только у меня, в FAR с другим размером табуляции это вот так смотрится:



    wcex.cbSize          = sizeof(WNDCLASSEX);
    wcex.style                   = WS_OVERLAPPED  ;
    wcex.lpfnWndProc     = (WNDPROC)ClipBoardWndProc;
    wcex.cbClsExtra      = 0;
    wcex.cbWndExtra      = 0;
    wcex.hInstance       = theApp.m_hInstance;
    wcex.hIcon                   = 0;
    wcex.hCursor                 = ::LoadCursor(NULL, IDC_ARROW);
    wcex.hbrBackground   = (HBRUSH)(COLOR_WINDOW+1);

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



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



    В результате получаем, что использование табуляции из абстракнтых соображений не имеет смысла. Я утверждаю, что взяв свой или чужой код и изменив размер табуляции, в 99% случаев мы получим некрасивый, разъехавшийся код. А раз так, то и аргумент в защиту справедлив только на 1%, а то и меньше. Ни разу не видел, чтоб с другими табуляциями код смотрелся хорошо. А уж кода я смотрю много.



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



    1) Тяжело работать с проектами, где используются библиотеки, содержащие в тексте табуляции. Предположим, в одной библиотеке табуляция равна 3 символам, в другой 4 символам. А вы в проекте используете 2 символа. В результате какая-то часть кода у вас будет отображаться в редакторе со сбитым форматированием.



    Ну и где польза от переменного размера табуляции? Какой размер не выбери, где-то да криво будет. Если же везде будут пробелы, то и смотреться все красиво будет. Да, будут разные отступы, но форматирование то красивое везде останется!



    2) Легко пустить козла в огород. Скажем у вас табуляция равна 4 пробелам. Кто-то что-то чуть-чуть поправил, используя другой размер табуляции или явно вставив пробелы. У него все смотрелось нормально, а у вас строчка кода куда-то уедет.



    3) Надо постоянно настраивать различные редакторы под нужный вам размер табуляции. Даже если вам нужно просто посмотреть код не правя. Иначе все разъезжается. Особенно это не удобно, когда приходится что-то делать со своим кодом на сторонней машине. Или наоборот заглядывать в чужой код. Тут объяснить всю суетность сложно. Это надо прочувствовать. Программисты, пожалуй делятся на тех, кто знает и понимает про это неудобство, и кто нет. Но прошу, те, кто не понимает, поверьте — эти неудобства есть! И если вам, в общем-то, всё равно, то используйте пробелы! Сэкономите кому то немного сил и времени.



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



    Ну и на последок отвечу на: «мы так всегда писали, значит и дальше так стоит продолжать». Часто, причем, это подкрепляется каким-либо бородатым стандартом кодирования, используемым программистами. Слава богу, профессиональные разработчики не стоят на месте. И не боятся нарушить старинные устои. Примером тому может служить Google C++ Style Guide. Вот цитата оттуда по поводу пробелов и табуляций.



    Spaces vs. Tabs



    Use only spaces, and indent 2 spaces at a time.



    We use spaces for indentation. Do not use tabs in your code. You should set your editor to emit spaces when you hit the tab key.



    Слава богу! Хоть у кого-то разумный подход!



    Желаю и вам свежести в ваших стандартах кодирования!



    UPDATE:



    ПРИМЕЧАНИЕ ДЛЯ ТЕХ, КТО В ТАНКЕ



    Чтобы использовать для оформления пробелы, вовсе не обязательно 4 или более раз нажимать клавишу пробел. Во всех редакторах есть возможность настроить, сколько пробелов вставлять при нажатии таба.



    Никогда бы не подумал, что из-за этого меня заминусуют. «Вот ведь гад! Рекомендует пробелы нажимать до посинения, вместо милого таба!»

    PVS-Studio
    291,00
    Ищем ошибки в C, C++ и C# на Windows, Linux, macOS
    Поделиться публикацией

    Комментарии 217

      +61
      Вы говорите глупости потому-что не умеете пользоваться табуляцией.
      Ненавижу пробелы там, где логически должна быть табуляция (поддерживал несколько проектов с такими Style Guide — чут ьне обблевался).
      Больше людей предпочитают табы вместо пробелов.
      А то, что вы выдаете за истину — ошибочное утверждение от незнания.
        +14
        Объясняйте свою позицию, а не просто «блюю от пробелов», и «вы просто не умеете их(табы) готовить»
          +1
          Ок, сейчас напишу развернутый ответ.
              –6
              Спасибо за достойный ответ :)
              Хорошие аргументы за использование табов, не все конечно, например, при перемещении по началу строки проще использовать «Home», т.к. не важно сколько табов и пробелов перед началом строки.
              Сам же, использую пробелы не из-за идеологии, а скорее из-за традиции, т.к. все в комманде используют пробелы, заставить всех перейти на табы достаточно проблематично, а ввиду банальной лени не сильно и хочется.

              P.S. Как и в случае div vs table, истина где-то посередине!
                0
                Некропост, но: сейчас работаю в XCode — попытка перехода кнопкой Home в начало строки заканчивается неприличным словом. А всё потому, что везде в яблоке началом строки считается не там, где начинаются первые осмысленные символы после пустого пространства, а само начало строки, до которого нет ничего. Это очень проблематично использовать пробелы.
                Но теперь то я нашёл эту вредную статью, в которой упоминаются и Far и WinMerge. К Far'у не испытываю неприязни, а вот когда из-за ручного мержа моего напарника (на который убивается минимум час) теряются мои правки и баги приходится править по три раза — опять же это заканчивается плохими словами про себя.
                Вероятно в самых запущенных случаях WinMerge полезен, но не при каждом принятии изменений из репозитория. А технология мержа у моего напарника совсем повергает меня в уныние: имеется две папки, первая с только что принятыми изменениями, вторая с собственными правками. И методом туда-сюда все файлы приводятся к единому виду. Подскажите мне, где и в какой ситуации плюсы от такого подхода при каждом мерже будут перевешивать минусы?
                Тем более подход ручного мержа очень уязвим к человеческому фактору — не может человек каждый раз помнить, где надо поправить, а где принять изменения.
                +21
                Я бы еще добавил то, что меня в пробелах бесит больше всего — это когда «бегаешь» по пробелам, и курсор постоянно застревает в «молоке», а не в нужных например началах строки:
                image
                  +5
                  Попробуйте «бегать» по пробелам с нажатой клавишей Ctrl, мне помогло.
                    –2
                    В приличных редакторах home выставляет курсов на начало текста в строке… Но вам это познать кажется не светит :)
                      0
                      В редакторах, что я встречал иногда иногда даже с прстейшим английским текстом типа endif или endfor разобраться не могут. Хорошо, что мэйнтенеры Ubuntu переадресовали «мой» баг куда-то в глубину GNOME, где, видимо, нашёлся человек понявший мой soviet english… Но если они его поняли у нас нет никакого стратегического преимущества…
                    • НЛО прилетело и опубликовало эту надпись здесь
                –13
                То что таб нажимать быстрее и легче, чем несколько раз пробел не рассматривается?

                  +9
                  Ну автор подразумевает, что IDE должна автозаменять пробелы на табы.
                    +17
                    Табы на пробелы ;)
                      +2
                      и «туда» и «туда» многие умеют
                      +1
                      При этом все как то забывают упомянуть про удаление 4-х пробелов. Нет, нет. Я знаю про Shift+Tab, которая удаляет 4 пробела с начала строки, но если надо внутри строки, то это жесть… Честно, я пробовал перелезать на табы т.к. ZendStandart и даже перевёл весь проект на пробелы, что бы сжечь мосты. Но больше недели я не выдержил. Например:

                      @param $someVeryVeryManyVeryLongVariable Description
                      @param $var Desc

                      Если придётся удалить первую строку и потом захочется поправить вторую, то лучше смерть. Мало того, что придётся насиловать свой бэксспейс, так ведь ещё в голове придётся отсчитывать число кратное четырём!
                        0
                        компилятор сожрал пробелы. Там конечно Description находятся на одном уровня.
                          +4
                          в нормальных редакторах Shift+Tab удаляет из любого места до позиции, кратной текущему табсайзу.

                          то, что вы говорите про «удаляет 4 пробела с начала строки» — это smart backspace
                            +1
                            Можно без насилия — большинство IDE понимают Ctrl+Del, Ctrl+Backspace.
                              +5
                              ну и зачем мне жать еще и Ctrl? одной клавишей значительно удобнее уродовать чем несколькими
                                +1
                                орудовать :)
                              0
                              В данном случае надо использовать пробелы в любом случае, иначе при изменении размера таба всё поплывёт. Так что пример неудачный.
                                0
                                Внутри строки поможет блочное выделение — при нём таб/шифт-таб работают от его позиции, а не от начала строки. Как минимум, так сделано в Delphi и это хорошо.
                              +1
                              Нет, если внимательно читать статью, то можно увидеть, что IDE настраиваются на вставку пробелов при нажатии табуляции(так под дефолту в PhpStorm'е).
                                +8
                                You should set your editor to emit spaces when you hit the tab key.
                                  –1
                                  Ага, какие то дурацкие причины пользовать табы автор учел, а собственно главную о том, что нажать один раз tab значительно быстрее, чем два раза пробел…

                                  Да и вообще по моему таких проблем у людей которые пользуют современные ide уже давно не возникает (или бывает?)
                                    +3
                                    По-моему, во мноих средах настраивается поведение нажатия — вставлять пробелы или табуляцию (в частности, Visual Studio)
                                      +11
                                      В любой среде легко и просто настраивается, чтобы вместо TAB вставлялось нужное количество пробелов.
                                        +23
                                        но есть еще обратная операция — backspace и delete, и там уже нужно жмякать по 2-4 раза.
                                          +2
                                          Shift+Tab — обратная операция почти везде.
                                            +7
                                            backspace — удобнее, не надо пальцы выворачивать
                                              –1
                                              Shift+Alt+← — в NetBeans сдвигает блок кода на ширину табуляции влево (Shift+Alt+→ соответственно вправо). Нажимать backspace / del дольше. И вообще, спор на два топика мне кажется уже немного глупым, так как в IDE можно настроить стандарт форматирования кода и одним хот-кеем приводить код к своему стилю. А там уже все-равно, что было в коде раньше — табы или пробелы, переносились фигурные скобки на следующую строку или нет и т.п.
                                                0
                                                а если делаем в команде через систему контроля версий, и программист А любит табы, а программист Б любит пробелы?
                                                  +3
                                                  уволить того который не следует общему стилю
                                                +1
                                                Вроде почти везде бэкспэйс настраивается на удаление до табуляции в положении умного начала строки. Так что нужно только один бэкспэйс жать.
                                                  0
                                                  Конечно, удобнее. И в нормальных редакторах это тоже настраивается: Backspace делает именно unindent, удаляя нужное количество пробелов ;)

                                                  P.S.: сам я использую тот подход, который вы описали в топике-ответе: табы для отступов и пробелы для выравнивания.
                                                  +1
                                                  Я не знал, что это сочетание работает с пробелами. Но все таки варианты остаются, тот же del ;)
                                                  +1
                                                  в том же vim'е не нужно «жмякать» 2-4 раза, он сам прекрасно понимает где у тебя отступы.
                                                    +6
                                                    То есть он превосходно эмулирует вам табы? :) Честно, я не хочу участвовать в этом споре. Я выбрал для языка C# для себя табы. Даже перевел команду на них, объяснив и доказав что это удобнее, особенно при использовании Visual Studio. Так мне хочется, так мне удобнее.

                                                    От статьи я честно ожидал что-то действительно революционное. А здесь же опять вырваны какие-то моменты, с которыми столкнулся автор, и которые считает автор важными. Еще один пласт для холивара.
                                                      +4
                                                      не верно, он превосходно мне эмулирует 4 пробела. Ширина таба — величина не постоянная, четыре пробела всегда остаются четырмя пробелами. В каком бы редакторе я бы не открыл свой код — он будет выглядеть так, как выглядел в моем редакторе.
                                                        0
                                                        Нет, не будет.
                                                        Если у вас будет alignment в коде (выравнивание инициализации) при помощи пробелов, то открыв в каком-нибудь редакторе, у которого не моноширинный шрифт — вы так же увидите все разъехавшимся.
                                                          –3
                                                          вы часто любуетесь своим кодом в каком-нибудь Word'e?
                                                            +1
                                                            Я ни разу не сталкивался с человеком, который бы что-нибудь криво выровнял из-за того, что у него другая длина таба.
                                                            +1
                                                            А вам случалось хоть раз такое делать?
                                                              0
                                                              Сложно вспомнить.
                                                      0
                                                      умные редакторы умеют стирать по [tab_size] пробелов за раз, там где это нужно.
                                                        0
                                                        Komodo Edit корректно отрабатывает backspace при табуляции пробелами, удаляя ровно столько пробелов, сколько использовано для отступа.
                                                          0
                                                          А Ctrl+Backspace не помогает? Или потрётся и идущее перед пробелами слово?
                                                            0
                                                            потрется
                                                      –4
                                                      Знак табуляции — 1 байт, пробел — нужное кол-во пробелов × 1 байт
                                                        +2
                                                        Экономия места ну очень важна. Был у нас на работе такой экономщик, экономил байты на всем, создавал id размером в 2 байта, аргументируя «когда будет кончатся — увеличим» и его не смущало огромное количество внешних ключей на такие id.
                                                          –1
                                                          Я не говорил, что нужно экономить на id и прочем. Например в HTML, CSS и Javascript это напрямую влияет на скорость загрузки страниц.
                                                            +5
                                                            Для этого в продакшн нужно выпускать обфусцированные версии скриптов и не забывать включать сжатие на веб-сервере
                                                              +3
                                                              > Например в HTML, CSS и Javascript это напрямую влияет на скорость загрузки страниц.
                                                              На скорость больше влияет сжатие, а при использовании сжатия количество пробелов не сильно влияет на размер. Тем более, что скрипты желательно минимизировать(minify) на продакшне, а при минимизации все пробелы и табы удаляются, и переносы строк вместе с ними.
                                                                +1
                                                                с HTML и CSS можно провести аналогичную минимизацию, только для свободного места :)
                                                              +2
                                                              А еще можно для экономии места вообще не делать никакого форматирования текста и не писать комментариев.
                                                              +2
                                                              \t — анахронизъм
                                                                +17
                                                                Предположим, в одной библиотеке табуляция равна 3 символам, в другой 4 символам.

                                                                Что-то меня это немного смутило. Что здесь подразумевается? Таб — это символ \t, как он может иметь размер? Как это библиотека будет иметь свой размер табуляции?

                                                                Вообще, если уйти в историю, то как раз таки пробелы использовались из-за исторических проблем ;) Табы то это, наоборот, новье. Разве нет?
                                                                  –23
                                                                  Теоретически, табы это красиво. Практически, табы это геморрой. Только многие до сих пор это понять не могут.

                                                                  По поводу библиотек. Я имел в виду, что одной библиотеке заголовочные файлы и т.д. оформлены из расчета, что длинна табуляции составляет X пробелов. В другой — Y пробелов. В результате тошнит, когда смотришь на разъехавшиеся заголовочные файлы там, где расчетная длинна табуляции не совпала с установленной у меня в редакторе. Были бы пробелы. Было всё ровно.
                                                                    +4
                                                                    Честно говоря не понимаю вас в этом вопросе. Тоже самое можно сказать и про пробелы. Кто-то как-то красиво оформил код пробелами (как я понимаю, это, например, вариант инициализации по одной линии вами приведенный), но в разных IDE используется разный шрифт, и тогда опять же все разъедится. То есть проблемы то одинаковые. Разве нет? Все зависит, наверное, от рук мастера?
                                                                      +2
                                                                      Ну, насколько я знаю, в редакторах кода в IDE принято применять моноширинный шрифт…
                                                                      А при моноширинном шрифте пробел в подавляющем количестве случаев вкуснее таба :-)
                                                                      Но это только моё мнение… Ошибаться могу я…
                                                                        0
                                                                        Во всех используемых мной IDE используется моноширинный шрифт, хотя никто не мешает изгадить пользователю свой IDE Comic Sans'ом)
                                                                          +2
                                                                          Да, но никто не мешает вам открыть код в notepad, wordpad, editplus, notepad++ или еще хз где, ведь так? :)
                                                                          Я же говорю, тут важна рука мастера.
                                                                            +1
                                                                            Просто сама проблема надуманна. Меня вот бесят «египетские скобки», но в эклипсе все мои противоречия устраняются по CTRL+SHIFT+F. Каждый пишет код как ему удобно его читать, а нормальные IDE позволяют удобно читать его всем)
                                                                              +5
                                                                              Я полностью вас поддерживаю. Проблема надуманная, как в случае с табами, так и с пробелами. Автору попался какой-то мудак, который как-то грамотно выравнивал там что-то табами. В другой момент может перейти дорогу другой мудак, который уже как-то по хитрому будет что-то выравнивать пробелами под comic sans.
                                                                            0
                                                                            Вы будете смеяться, но в каком-то из редакторов (кажется, notepad++) раньше комментарии по умолчанию отображались именно комиком, да еще с размером меньше, чем у остального кода. :) Слава богу, потом догадались убрать.
                                                                            0
                                                                            Если шрифт моноширинный (а как можно работать с кодом, используя пропорциональные шрифты, я не представляю), то я не вижу причин чему-либо разъехаться.
                                                                              +3
                                                                              В вашем предложении стоит «если». Я поясню:
                                                                              «Если табы использовать правильно, то я не вижу проблем.»
                                                                              «Если пробелы использовать правильно, то я не вижу проблем.»
                                                                              Думаю, что на этом можно закончить дискуссию?
                                                                                –1
                                                                                Вы видели людей которые реально работают? не правят чтото по быстрому первым попавшемся редактором потому что поправить надо срочно а под рукой ничего нет, а именно реально работают. Я нет. А вот людей с разной длиной табуляции полно.
                                                                                  +1
                                                                                  А вот людей с разной длиной табуляции полно.

                                                                                  Пускай, а чем они нам мешают? Примером с alignment? Пускай не делают так.
                                                                                0
                                                                                Отлично работаю с кодом, используя немоноширинные шрифты уже больше года. Не понимаю почему я этого не сделал раньше.
                                                                                  0
                                                                                  Ну-ка, ну-ка, посоветуй фонтов, сто лет мечтаю попробовать! :)

                                                                                  Хочу спробовать тоже, ага. :)
                                                                                    0
                                                                                    У меня MS-овский стандартный calibri стоит. Все хочу поискать что-нибудь более кодо-ориентированное, да руки не доходят.
                                                                                      0
                                                                                      У меня его нет. :-/

                                                                                      Сижу на consolas и что-то с засечками для комментариев — сразу выделяются.
                                                                                        0
                                                                                        А скрин можно?)
                                                                                +4
                                                                                >Теоретически, табы это красиво. Практически, табы это геморрой. Только многие до сих пор это понять не могут.

                                                                                Табы — это красиво и теоретически, и практически. Вот только многие до сих пор не могут понять разницу между отступом и выравниванием ;)
                                                                                Меняйте ширину таба как хотите: хоть в 2 символа поставьте, хоть в 8 — форматирование никуда не поедет:



                                                                                Геморрой не в табах, а в неумении ими пользоваться.
                                                                                  0
                                                                                  А пробелы для выравнивания вы как набираете? Tab'ом или пробелом?
                                                                                    +1
                                                                                    Пробелом :( Но я согласен добровольно делать это руками, т.к. код читается намного чаще, чем пишется.

                                                                                    QScintilla, насколько мне известно, пока не научилась «умно» определять, отступ это или нет, и вести себя соответствующим образом.
                                                                                    Хм, в принципе это можно реализовать ручками, на уровне редактора. Спасибо за толчок в нужном направлении, я подумаю над этим :)
                                                                                      0
                                                                                      Реализовать вырывание по табу можно, но на уровне редактора… Что делать с исходниками, которые случайно открыли с другим стилем форматирования?

                                                                                      Извините.
                                                                                        0
                                                                                        Какими бы ни были настройки редактора — всегда найдётся такой файл, в котором будет другой стиль форматирования :)
                                                                                        Подумаю на досуге, как сделать это правильно…
                                                                                    +1
                                                                                    Все правильно! Табы они для отступов (те что в начале строки).
                                                                                +1
                                                                                В копилку доводов

                                                                                1) «нажать один раз таб проще чем каждый раз отсчитывать нужное количество пробелов»
                                                                                — многие среды разработки умеют автоматически заменять таб на пробел

                                                                                2) «в случае с табомизменение пары символов не приводит к тому что надо менять форматирование
                                                                                  +18
                                                                                  Важно не использование табуляции или пробелов, а постоянство. В своих новых проектах используйте то, что вам больше нравится. Во всех остальных придерживайтесь уже сложившегося стиля написания кода. А утверждение, что табуляция лучше пробелов — обычный холивор.
                                                                                    –17
                                                                                    Вы не прочитали статью. :( Ну причем здесь постоянство?
                                                                                    +7
                                                                                    эх, мне бы ваши проблемы.
                                                                                      +13
                                                                                      На сколько я знаю, символ табуляции для выравнивания и придуман
                                                                                      из википедии:
                                                                                      Горизонтальная табуляция (HT, TAB) — символ таблицы ASCII с кодом 09h, используется для выравнивания текста по горизонтали.

                                                                                      дак зачем для этого использовать пробелы? Мне не понятно.
                                                                                        –31
                                                                                        Вы когда ни будь код оформляли? :)
                                                                                          +2
                                                                                          Ежедневно. Таб удобнее. Только не надо говорить, что все разъезжается: menu -> source -> format.
                                                                                            0
                                                                                            О… Aptana иногда такое волшебство с кодом делает при автоматическом форматировании.
                                                                                          +1
                                                                                          Вообще, он сделан не для такого выранивания. Идея таба же в том, чтобы из двух колонок текста можно было выровнять вторую вне зависимости от содержимого первой(до момента переполнения). С пробелами при каждом изменении первой призодится редактировать и отступ, с табами — нет.
                                                                                          Но сейчас даже это уже малоактуально, потому как во-первых, строки стандартизированнной длины используются реже, все часто перескакивает на следуюзий табпоз, во--вторых, везде ГУИ, в-третьих, в консоли есть `column`.

                                                                                          А в коде колонки — сравнительно редкое дело, и там, где они есть — они как правило пишутся раз и надолго. (Вообще, может я что-то позабыл, но реальные колонки вроде используют только в наборах констант, либо инициализациях крупными пачками, для этих случаев — верно.)
                                                                                          +15
                                                                                          На дворе канун 2012 года, экономический кризис, мир стоит на пороге экологического коллапса. Населению не хватает питьевой воды и пищи. Постоянно возникают новые эпидемии и до сих пор не научились лечить вирусные заболевания. Но самое страшное не в этом. Самое ужасное заключается в том, что некоторые программисты неправильно используют табы и спэйсы.
                                                                                            –8
                                                                                            Что ещё страшней, другие вместо того, чтобы пойти решать эти проблемы, сидят и читают на хабре про всякие глупости. :)
                                                                                            +3
                                                                                            Вот только никто так не делает. Походите по своему коду и вы уведете что-то более реалистичное (один таб = 2 пробела):

                                                                                              A=Aaaaaaaaaaaa &&
                                                                                                Bbbbbbbbb;

                                                                                            Если теперь таб станет равен не двум пробелам, то вся красота оформления моментально нарушится.

                                                                                                A=Aaaaaaaaaaaa &&
                                                                                                    Bbbbbbbbb;


                                                                                            Феерическая чушь. Это делается не ради какой-то мнимой красоты, а чтобы было четко видно вложенность конструкций и повышалась читабельность кода. И если мне для комфортного чтения кода необходимо 4 пробела, то я ни за какие коврижки не стану жать 4 раза пробел, когда можно один раз нажать на таб.
                                                                                              –39
                                                                                              ППЦ! А Я ТО ДУМАЮ, ПОЧЕМУ МЕНЯ МИНУСУЮТ!!!
                                                                                              А тут оказывается сборище ламеров.
                                                                                              Не знаете о чем речь, хоть бы не позорились! Кошмар!
                                                                                              Пойду текст поправлю в статье. Напишу, что 4 раза жать пробел не обязательно!

                                                                                                +10
                                                                                                Прощайте.
                                                                                                  +7
                                                                                                  Не увиливайте от ответа на вопрос, сколько раз надо нажимать backspace :)
                                                                                                    0
                                                                                                    в vim — один раз
                                                                                                      +1
                                                                                                      А в Kate, Notepad, nano или чем-то другом, что оказалось под рукой и надо быстренько поправить код? ;)
                                                                                                        –2
                                                                                                        ни разу с таким не сталкивался. Раз. Везде где используется код, есть ssh+vim. Два. Что мешает поставить vim?
                                                                                                          +2
                                                                                                          Я не умею пользоваться Вим ;)
                                                                                                            0
                                                                                                            Скажите мне, пожалуйста, сколько раз вы нажмете таб и сколько раз пробел для форматирования подобного мизерного куска кода: farm6.static.flickr.com/5224/5661319418_52effa8a3e_b.jpg?

                                                                                                            Я так понимаю те, кто использует табы всегда беспощадно жмет пробел по 30 раз для алиджмента, так? Мне достаточно пары нажатий на таб как для алиджмента, так и для индентации и код всегда и везде будет выглядеть красиво, так как все это — пробелы.
                                                                                                              0
                                                                                                              Когда вы первой строкой вводите wcex.cbSize 10 пробелов перед '=' отбиваются автоматом или ручками?
                                                                                                                0
                                                                                                                3-мя нажатиями на таб. А между `wcexBackground` и `=` — нужен всего 1 таб. Получается такое же лаконичное выравнивание + я нажимаю клавишу в 3 раза меньше, чем если бы долбил по пробелу.
                                                                                                          • НЛО прилетело и опубликовало эту надпись здесь
                                                                                                            +3
                                                                                                            Вот, кстати, с Kate никаких проблем. Умеет, если научить один раз.

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

                                                                                                            На всякий случай уточню — тоже терпеть не могу. Наша команда сейчас во всех разработках использует два пробела. IDE разные: vim, emacs, IDEA, IBM Rational Developer, Qt Creator, Kate… Короче, кто во что горазд. Пока никто не жаловался :)
                                                                                                          +1
                                                                                                          Столько же сколько и tab если мы говорил о нормальном редакторе (VIM например).
                                                                                                          +28
                                                                                                          ППЦ! А Я ТО ДУМАЮ, ПОЧЕМУ МЕНЯ МИНУСУЮТ!!!

                                                                                                          Минусуют потому что пишете глупости не разобравшись
                                                                                                            –35
                                                                                                            Ага. 10 лет всё никак разобартсья немогу. :)
                                                                                                              +27
                                                                                                              Очевидно, да)
                                                                                                                +2
                                                                                                                Ну ок, разобравшись. Жду топика «Пора завязывать вставать с правой ноги»
                                                                                                                  +6
                                                                                                                  Длительность — не показатель. Если не хотеть разбираться, то можно и за 20 лет не разобраться.

                                                                                                                  P.S.: в каком классе учат про "«не» с глаголами пишется раздельно"? Вот и скажите, сколько уже лет прошло — а вы до сих пор не разобрались с этим ;)
                                                                                                                +3
                                                                                                                Хм. Все-таки, мы с вами каждый прав не более, чем на половину. Вон TheShock отлично объяснил разницу между indentation и alignment.
                                                                                                                +4
                                                                                                                Тем, кто использует табы внутри кода, нужно отрывать руки. А ля отступов они — самое то
                                                                                                                –4
                                                                                                                Хороший руль левым не назовут! Хороший пробел табом не назовут!
                                                                                                                  +2
                                                                                                                  В качестве продолжения беседы: А исходники в фаре смотреть — это нормально что ли? Да и стандарт форматирования который так сильно зависит от пробелов/табов не кажется очень удобным. Мало того, некоторые даже пропорциональные шрифты в своей дев.среде используют — там пробелы просто противопоказаны.
                                                                                                                    +3
                                                                                                                    за пропорциональные шрифты в редакторах кода нужно сразу четвертовать!
                                                                                                                      0
                                                                                                                      Они-то кому мешают???
                                                                                                                        +4
                                                                                                                        А разве нет?


                                                                                                                    0
                                                                                                                    Вот только никто так не делает. Походите по своему коду и вы уведете что-то более реалистичное (один таб = 2 пробела):

                                                                                                                    A=Aaaaaaaaaaaa &&
                                                                                                                    Bbbbbbbbb;

                                                                                                                    Если теперь таб станет равен не двум пробелам, то вся красота оформления моментально нарушится.

                                                                                                                    A=Aaaaaaaaaaaa &&
                                                                                                                    Bbbbbbbbb;


                                                                                                                    Про вариант с 4 пробелами:
                                                                                                                    A = Aaaaaaaaaaaa &&
                                                                                                                    Bbbbbbbbb;

                                                                                                                    Но, по-моему, читабельность, в данном случае, рассматривается еще и на уровне операций:
                                                                                                                    A = Aaaaaaaaaaaa
                                                                                                                    && Bbbbbbbbb
                                                                                                                    && Ccccccccc;
                                                                                                                      0
                                                                                                                      D'oh! Отступы съелись.
                                                                                                                        +2
                                                                                                                        Используйте конструкцию <source></source> для оформления кода на Хабрахабре и кнопку «предпросмотр» для предварительной оценки результатов оформления перед публикацией.
                                                                                                                          0
                                                                                                                          И руки перед едой мойте!
                                                                                                                            0
                                                                                                                            И руки перед едой мойте!
                                                                                                                      0
                                                                                                                      И кстати, какой смысл в таком форматировании?

                                                                                                                      A=Aaaaaaaaaaaa &&
                                                                                                                          Bbbbbbbbb;
                                                                                                                      


                                                                                                                      Почему в одну строку не написать?

                                                                                                                      A=Aaaaaaaaaaaa && Bbbbbbbbb;
                                                                                                                      


                                                                                                                        0
                                                                                                                        По той же самой причине по которой делается все форматирование. Чтобы повысить читаемость кода.



                                                                                                                        читается проще чем

                                                                                                                        OpenUSART ( USART_TX_INT_OFF & USART_RX_INT_ON & USART_ASYNCH_MODE & USART_EIGHT_BIT & USART_CONT_RX & USART_BRGH_LOW, 64);
                                                                                                                          +1
                                                                                                                          В таком случае, если использовать табы, то:
                                                                                                                          1. Tab'им до уровня OpenUSART
                                                                                                                          2. Пробел'им от OpenUSART до нужного места под солнцем
                                                                                                                            0
                                                                                                                            Проследите ветку комментариев. Я не говорил что такое форматирование надо делать только табами или только пробелами. Я привел пример для crea7or когда возникает необходимость в многострочном оформлении одной комманды.
                                                                                                                            +2
                                                                                                                            OpenUSART (
                                                                                                                                USART_TX_INT_OFF  &
                                                                                                                                USART_RX_INT_ON   &
                                                                                                                                USART_ASYNCH_MODE &
                                                                                                                                USART_EIGHT_BIT   &
                                                                                                                                USART_CONT_RX     &
                                                                                                                                USART_BRGH_LOW
                                                                                                                                , 64
                                                                                                                            );
                                                                                                                            0
                                                                                                                            это как бы пример же.
                                                                                                                            длинные if'ы с кучей условий не всегда влезают в 80 символов.
                                                                                                                              0
                                                                                                                              А где такой лимит в 80 символов?
                                                                                                                                0
                                                                                                                                во многих стандартах кодирования :)
                                                                                                                                например у гугла
                                                                                                                                  0
                                                                                                                                  Вот бы знать зачем… Неужели для работы через терминал?
                                                                                                                                    0
                                                                                                                                    Вообще да. Стандартный терминал имеет разрешение 80x25 символов.
                                                                                                                                      0
                                                                                                                                      В гугле объясняют свои предпосылки.
                                                                                                                                      С этим правилом, как я понял, ситуация такая, что хотят сохранить однородность кода, ибо уже много написанного, который следует этому правилу.
                                                                                                                                      А вообще вместо 80 можно подставить своё, суть не поменяется, кроме того что лимит должен быть обязательно, ибо не у всех 22"-30" мониторы.
                                                                                                                                        0
                                                                                                                                        Дело не только терминале и точно не в мониторе. Просто, длинные строчки плохо читаются.
                                                                                                                                        +1
                                                                                                                                        Очевидно же: image
                                                                                                                                +1
                                                                                                                                Мне кажется, мы все здесь не о том говорим. Для каждого языка есть свои рекомендации по форматированию кода. Например, для python'а есть замечательный PEP8, в котором английским по белому написано:
                                                                                                                                Use 4 spaces per indentation level. …

                                                                                                                                …The most popular way of indenting Python is with spaces only.
                                                                                                                                  0
                                                                                                                                  У питона весь код на отступах строиться, по этому для него это нормально.
                                                                                                                                    –1
                                                                                                                                    тут дело не только в отступах, тут дело в стандарте — он один-единственный, и на него все равняются.
                                                                                                                                    Для других языков все печальнее — нет единого стандарта.
                                                                                                                                  0
                                                                                                                                  пересел на двойной пробел после того, как стал использовать HAML
                                                                                                                                    +6
                                                                                                                                    Табы или пробелы — это творческий вопрос. Тонны кода, написанные с разными отступами, не исправить. Смирение, спокойствие и понимание — вот дзен программиста. В конце концов, не табом единым код хорош или плох.
                                                                                                                                      –2
                                                                                                                                      почему не исправить?
                                                                                                                                      замена регексом по всему проекту — " {4}" на \t, делов то…
                                                                                                                                        +1
                                                                                                                                        Все так, если вы правите свои исходники. Автору же не нравится читать код чужих библиотек, — и тут могут быть варианты.
                                                                                                                                          +2
                                                                                                                                          Нельзя, сломается выравнивание, нужны «умные табы»
                                                                                                                                            +1
                                                                                                                                            а в чем подвох? если код корректно отформатирован под 4 пробела, то все работает отлично, сто раз так делал…
                                                                                                                                              0
                                                                                                                                              Подвох вот в этом. Если слепо заменить 4 пробела на таб, то потом при изменении ширины таба поедет выравнивание.
                                                                                                                                        +6
                                                                                                                                        Linux kernel coding style
                                                                                                                                        www.kernel.org/doc/Documentation/CodingStyle
                                                                                                                                        Tabs are 8 characters
                                                                                                                                        Outside of comments, documentation and except in Kconfig, spaces are never
                                                                                                                                        used for indentation
                                                                                                                                          –10
                                                                                                                                          Вот про бородатость этого я и говорил. ;)
                                                                                                                                            +3
                                                                                                                                            Google C++ Style Guide:

                                                                                                                                            Use only spaces, and indent 2 spaces at a time.
                                                                                                                                            We use spaces for indentation. Do not use tabs in your code. You should set your editor to emit spaces when you hit the tab key.
                                                                                                                                            +10
                                                                                                                                            Все едят рис, но я вам говорю, это неправильно, макароны гораздо лучше!
                                                                                                                                              –6
                                                                                                                                              Кажется я начинаю понимать, откуда такое моё несогласие с миром. Я в основном работал и работаю с унаследованным кодом. И мне совершенно не интересны теоретические и идеологические обоснования почему табы лучше. Я практик. Когда я беру код и вижу, что он разъехался, так по мне пробелы в 100 раз лучше. Никто никогда не заворачивается, что такое indentation, alignment. Просто 5-10 лет назад натабили и пошли дальше.
                                                                                                                                                +4
                                                                                                                                                Знаете мне сильно хочется посмотреть на такой код где использование табов вместо пробелов настолько ухудшает читаемость. Ну и да, обычно когда используются табы подразумевается что их длина равна 4 пробелам. Есть конечно сумрачные гении которые ставят отличное от 4 пробелов, но это бывает редко.
                                                                                                                                                  –3
                                                                                                                                                  Эхх. Молодежжж… :)) 2, 3, 4, 8… чего только не насмотришься.
                                                                                                                                                    0
                                                                                                                                                    я даже 6 видел, в древнем коде на С
                                                                                                                                                      0
                                                                                                                                                      2,4,8 — наиболее часто используемые. В 3 не видел не разу, и честно говоря не думаю что использования таба размерностью 4 вместо 3 сильно ухудшает читаемость кода. Ну и как бы вопрос остается открытым. Покажите код который плохо читается из-за того что там табы а не пробелы.
                                                                                                                                                        0
                                                                                                                                                        Пример, может и не самый показательный, просто то что первое под руку попалось. Смысл в том, что оформление кода прыгает в зависимости от размера пробела. И если tab у меня в редакторе не равен 4 пробелам, как задумывал автор, то у меня он будет смотреться плохо.


                                                                                                                                                          0
                                                                                                                                                          бывают и другие среды для разработки и другие языки программирования. Где выравнивание, как в центральном примере не так уж и важно. Сама IDE подскажет где какая скобка, и где начинаются и заканчиваются перечисления параметров. Более того этот код еще и замечательно рефакторится для того, чтобы упростить список параметров (можно вынести локальные переменные).
                                                                                                                                                            0
                                                                                                                                                            вот знаете пример точно не сильно удачный. Обычно если надо чтобы переменные не плавали, их всех в единый блок выделяют тогда они плавать будут меньше. Да и то сильно это явно не мешает.
                                                                                                                                                              0
                                                                                                                                                              Тем, кто использует табы внутри кода, надо отрывать руки. А так, ничего плохого в табах нет.

                                                                                                                                                              Они плохи только в языках с significant whitespace типа Питона
                                                                                                                                                                0
                                                                                                                                                                Ооо, венгерская нотация… *открываем ещё один holy war*
                                                                                                                                                          +1
                                                                                                                                                          И вы призываете думать прогрессивно, отказаться от своих привычек и ставить пробелы потому, что так вам будет легче читать код, написанный 10 лет назад? Ну где же логика?

                                                                                                                                                          Почему не призывать писать новый код правильно, с indentation и alignment? Почему вы призываете всех вернуться на 10 лет назад?
                                                                                                                                                            +1
                                                                                                                                                            Андрей, если ты практик, то достаточно было показать что проблема решаема и предложить свой вариант решения. Вступать в мировоззренческие споры и устраивать Священные Войны совершенно не обязательно.
                                                                                                                                                              –4
                                                                                                                                                              Видимо будет еще одна статья… Вот только с ADD 2011 приеду… :)

                                                                                                                                                              Да, кто хочет продолжить дискуссию, может найти меня там. Обсудим всё за пивом.
                                                                                                                                                                0
                                                                                                                                                                See ya!
                                                                                                                                                                  +1
                                                                                                                                                                  Лучше не надо, вы не поняли смысл моей статьи-ответа.
                                                                                                                                                              0
                                                                                                                                                              Ну блин я не могу без ТАБа (
                                                                                                                                                                0
                                                                                                                                                                Я TAB нажимать не отговариваю. :) Нажимайте. Толкьо пусть он вставляет пробелы. Или сколько Вам там нравится. )
                                                                                                                                                                +3
                                                                                                                                                                Всё давно уже решено, можно использовать табуляцию для логического отступа и пробелы исключительно для посимвольного выравнивания.
                                                                                                                                                                www.codinghorror.com/blog/2009/04/death-to-the-space-infidels.html
                                                                                                                                                                • НЛО прилетело и опубликовало эту надпись здесь
                                                                                                                                                                    0
                                                                                                                                                                    1. «никто не заглядывает в историю глубже одной-двух ревизий файла» — мне давно уже не было так весело! Спасибо.
                                                                                                                                                                    2. Правильно использовать не пробелы и не табуляции!!! Правильно поступать так, как требует coding style Вашего предприятия. ТОЧКА.
                                                                                                                                                                      0
                                                                                                                                                                      12 лет использую табуляцию. Я и не знал, что это геморой.
                                                                                                                                                                        0
                                                                                                                                                                        для вас нет, но как только этот код откроет другой человек с другим размером табов — код поедет.
                                                                                                                                                                        вы точно прочитали статью? там же всё толково объяснено.
                                                                                                                                                                          +1
                                                                                                                                                                          Если не использовать alignment, то ничего страшного не случится.
                                                                                                                                                                            0
                                                                                                                                                                            Давайте лучше в космос полетим.
                                                                                                                                                                          –1
                                                                                                                                                                          >Во всех редакторах есть возможность настроить, сколько пробелов вставлять при нажатии таба.

                                                                                                                                                                          Ложь.
                                                                                                                                                                            +3
                                                                                                                                                                            А это не редакторы. :)
                                                                                                                                                                              +2
                                                                                                                                                                              К сожалению, не всегда есть выбор…
                                                                                                                                                                            +4
                                                                                                                                                                            Ребята, давайте я вас всех помирю :-). Andrey2008 разрабатывает анализатор кода PVS-Studio и вынужден просматривать большое количество сторонних исходников. И поэтому табы его затра… затрагивают его душу. Но и TheShock привел разумные аргументы. Просто это про две разных ситуации. Да и не знает большинство людей про отличие в отступах и выравниваниях.
                                                                                                                                                                              +5
                                                                                                                                                                              Большинство людей не знает про различия отступов и выравнивания → надо пропагандировать использование пробелов?
                                                                                                                                                                              Большинство людей не знает про различия отступов и выравнивания → надо пропагандировать различия отступов и выравнивания!

                                                                                                                                                                              Я вот даже не задумывался, но после одного примера от TheShock все понял и теперь буду использовать пробелы там, где нужно. Спасибо ему.
                                                                                                                                                                                +4
                                                                                                                                                                                Я надеялся, что хоть этот пост обойдётся без упоминания PVS-Studio :)
                                                                                                                                                                                  +3
                                                                                                                                                                                  Ага, щаз. Коммент (для верности) ещё и продублирован (с точностью до символа) в соседнем топике %)
                                                                                                                                                                                –1
                                                                                                                                                                                Проблема исчезнет, когда все разработчики IDE и текстовых редакторов сделают пробелы по умолчанию вместо табов. Большинство не заморачивается по этому поводу
                                                                                                                                                                                  –2
                                                                                                                                                                                  Еще один аргумент в пользу пробелов. Не мой. В icq знакомый прислал. Чтоб не дублировать — ссылка.
                                                                                                                                                                                    0
                                                                                                                                                                                    Если кто будет собирать статистику — я за пробелы, а от табов блюю. Да и в руби–рельсо–сообществе так принято, кстати. Давно не видел ничего на руби с табами.
                                                                                                                                                                                      0
                                                                                                                                                                                      Кто-то об этом думает вообще? Ну, кроме автора, конечно.
                                                                                                                                                                                        0
                                                                                                                                                                                        Я думаю, например.

                                                                                                                                                                                        Я и об одном-то пробеле думаю, а тут их от двух до четырёх (а не то и восьми)!
                                                                                                                                                                                          0
                                                                                                                                                                                          Конечно. Каждую субботу, выходя вечером во дворик, раскуривая сигару и устраиваясь в кресле, я думаю о том, использовать ли мне табы или пробелы…
                                                                                                                                                                                          0
                                                                                                                                                                                          в vim
                                                                                                                                                                                          :set et
                                                                                                                                                                                          :retab

                                                                                                                                                                                          и табуляции нету…
                                                                                                                                                                                          а форматированием пускай занимается autoindent, и пара "<" ">"

                                                                                                                                                                                          а будет статья за чистоту trailing spaces? а то я за!
                                                                                                                                                                                          match WhitespaceEOL /\s\+$/
                                                                                                                                                                                            0
                                                                                                                                                                                            Теоретический вопрос — vim сможет по одному клику (после всяких плагинов наверное — меня что в виме бесит, что из коробки он на иде не тянет) перевернуть исходник где отступ проблемами 4 в исходник где 2 пробелами.
                                                                                                                                                                                              0
                                                                                                                                                                                              vim и клики как-то не совсем подходящие слова, но и это можно без плагинов. например,
                                                                                                                                                                                              :set noet|retab!|set ts=2|set et|retab!
                                                                                                                                                                                              и дальше можно мапить хоть в хоткей, а хоть и в клик на тулбаре/меню.
                                                                                                                                                                                                0
                                                                                                                                                                                                Чисто формально вижу в вашем выражении недочёт — нигде не указан размер исходного tab пробелами — 4. Тем более только внутри парсинга синтаксических конструкций, а не литералов внутри…

                                                                                                                                                                                                Сорри нет времени выводить конструкции… Заранее прошу извинить за неправоту…
                                                                                                                                                                                            0
                                                                                                                                                                                            Пользователи Notepad++, подскажите какие эвенты биндить, чтобы удалять определенное кол-во пробелов, и чтобы блоки двигать левее-правее.

                                                                                                                                                                                            Питонисты с моими этими табуляторами смотрят на меня как на говно, а единственное, что неудобно — отсутствие хоткеев. :-/
                                                                                                                                                                                              +1
                                                                                                                                                                                              >Предположим, в одной библиотеке табуляция равна 3 символам, в другой 4 символам.
                                                                                                                                                                                              > А вы в проекте используете 2 символа.


                                                                                                                                                                                              UPDATE:

                                                                                                                                                                                              ПРИМЕЧАНИЕ ДЛЯ ТЕХ, КТО В ТАНКЕ

                                                                                                                                                                                              Чтобы использовать для оформления пробелы, вовсе не обязательно 4 или более раз нажимать клавишу пробел. Во всех редакторах есть возможность настроить, сколько пробелов вставлять при нажатии таба.


                                                                                                                                                                                              Для танкистов же: количество пробелов в табе позволяет задавать подавляющее большинство редакторов.
                                                                                                                                                                                                +3
                                                                                                                                                                                                Прочитал аргументы. Не убедительно.
                                                                                                                                                                                                  –2
                                                                                                                                                                                                  Абсолютно согласен с автором. Использую табы только для простого текста (не машиноширный шрифт), в коде — только пробелы!
                                                                                                                                                                                                    +5
                                                                                                                                                                                                    А ещё меня умиляют сторонники alignment — да, код выглядит красивее, при больших затратах времени на напиние кода. Но после мало-мальского рефакторинга с переименованием переменных всё ломается к чертям и надо тратить время на то чтобы вернуть красоту.
                                                                                                                                                                                                    Мой выбор отступы табами и никакого выравнивания строк.
                                                                                                                                                                                                      –1
                                                                                                                                                                                                      Код читается много чаще, чем пишется. Поэтому это стоит того.
                                                                                                                                                                                                      0
                                                                                                                                                                                                      Чтобы использовать табы, необходима одинаковая настройка их размета во всех местах, где показывается код. Таких мест у меня, например, достаточно много: emacs, vim, less, grep/awk/sed, к тому же, сейчас очень популярны сервисы типа гитхаба, где код смотрят в браузере, да и различные пастебины никто не отменял. Меня парит следить, чтобы табы везде были одинаковыми, я их не использую. А пробел — он вбезде пробел, везде имеет одинаковый размер. В емаксе, где я пишу код 99% времени, я просто настроил, чтобы вместо табуляции забивалось 2 пробела, а код выравнивается емаксом сам. В общем, я ни разу и нигде не видел кода с табуляцией и одновременно неразъехавшимся выравниванием, а с пробелами этой проблемы не существует.
                                                                                                                                                                                                        0
                                                                                                                                                                                                        Зачем одинаковая? Тоже статью не читали?
                                                                                                                                                                                                    • НЛО прилетело и опубликовало эту надпись здесь
                                                                                                                                                                                                        –3
                                                                                                                                                                                                        Я очень серьезен. И, да, я фаром пользуюсь иногда для просмотра файлов.

                                                                                                                                                                                                        А вот вопрос компетенции, я бы не стал на Вашем месте затрагивать.
                                                                                                                                                                                                        • НЛО прилетело и опубликовало эту надпись здесь
                                                                                                                                                                                                            –2
                                                                                                                                                                                                            Зачем же лук. Для начала попробуйте написать статью. А потом мы обсудим её. А пока, могу предложить свои. :)
                                                                                                                                                                                                          0
                                                                                                                                                                                                          В фаре часто приходится просматривать исходные файлы. Часто именно в фаре и заметны все проблемы с форматированием из-за использования табуляций.
                                                                                                                                                                                                          +1
                                                                                                                                                                                                          Скорее всего повторюсь (все комменты не осилил).
                                                                                                                                                                                                          Сам использую пробелы, но по сути они у меня используются как табы, т.е. tab = 4 smart пробела (т.е. до 4, 8, 12 и т.д. символа от начала строки), del = smart удаление пробелов до кратного 4ём символа от начала строки.
                                                                                                                                                                                                          Не могу чётко сформулировать причину использования пробелов, но так сложилось исторически. Возможно, когда-то мне часто попадался код с разными «символами отступов» и разной длиной «отсутпов» в одном файле и это раздражало.

                                                                                                                                                                                                          Основная часть работы делается в vim'е, но иногда приходится работать и в eclipse, так в нём почему-то tab'ы работают немного по-своему — при выравнивании нескольких строк eclipse иногда ставит пробелы, а иногда табы, по del'у удаляет по одному пробелу… В общем, в eclipse пробелы использовать мне неудобно.

                                                                                                                                                                                                          Но сказать-то я хотел по теме.
                                                                                                                                                                                                          Всё описание и критика аргументов у автора основывается только на частом лазании в чужом коде при условии, что в один код сунули нос несколько разработчиков, что каждый разработчик, творя этот код :), использует в обязательном порядке разную длину табов, плюс обязательно некоторые используют пробелы. Так проблема-то тут не столько в табах/пробелах, сколько в тех кодерах, которые не соблюли изначальный стиль написания и полезли «в чужой монастырь со своим уставом», так что в неудобстве пользования надо винить именно их.
                                                                                                                                                                                                          А вообще правильным подходом, имхо, будет:
                                                                                                                                                                                                          — если код тебе перешёл насовсем, то при наличии большого желания и времени, просто сразу перевести форматирование в свой стиль, а не плеваться каждый раз
                                                                                                                                                                                                          — если просто пришлось правки вносить в чужой код, но им заниматься будут и другие, либо нет времени/желания на переформатирования, то кодить в том же стиле, что уже используется в скрипте

                                                                                                                                                                                                          На самом деле многие почему-то не задумываются о соблюдении общего стиля, либо специально пишут так, чтобы был виден их «вклад».
                                                                                                                                                                                                            +1
                                                                                                                                                                                                            И да, забыл написать.
                                                                                                                                                                                                            Использую пробелы в наших проектах и знаю, что у коллег примерно так же настроены редакторы, так что проблем с таким форматированием у них нет.
                                                                                                                                                                                                            При этом я нисколько не презираю табы. Когда попадается скрипт с табами, то в vim'е замена табов пробелами отменяется простым ':se noet' и вношу правки без малейших неудобств.

                                                                                                                                                                                                            Но всё же добавлю в преимущества табов. Как и написано в топике каждый предпочитает свою длину отступов, и это касается так же и тех, кто использует пробелы. Если с табами ещё можно добиться несильно разъехавшегося форматирования настроив свою длину отступа (мы говорим именно об indentation), то с пробелами это сделать уже не получится, особенно если в одном скрипте кто-то использовал три пробела вместо таба, а кто-то пять/восемь (попадались и такие). И когда в этот скрипт надо внести небольшие изменения и на переформатирование нет ни времени ни желания, вот тогда от пробелов-отсутпов приходится поплеваться…
                                                                                                                                                                                                            +1
                                                                                                                                                                                                            use Astyle!
                                                                                                                                                                                                              0
                                                                                                                                                                                                              Astyle очень удобная утилита. А по поводу того, чем код «украшен», а какая рзница вообще? На вкус и цвет все фламастеры разные.
                                                                                                                                                                                                                +1
                                                                                                                                                                                                                Проблема просто высосана из пальца.
                                                                                                                                                                                                                И похоже исключительно для того, чтобы что-то этакое написать на Хабре.
                                                                                                                                                                                                                  0
                                                                                                                                                                                                                  Проблема на самом деле почти серьезная, если приходится работать с большим количеством кода с источников, которым вы свои стандарты навязать не можете, а ваша IDE сама корректно сформатировать код под ваши требования не может.
                                                                                                                                                                                                                  +2
                                                                                                                                                                                                                  Проверьте, пожалуйста, текст топика на предмет наличия орфографических и пунктуационных ошибок. Вот некоторые, что бросились в глаза при спешном прочтении:

                                                                                                                                                                                                                  «Походите по своему коду и вы уведете что-то более реалистичное» (правильно: «увидите»)

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

                                                                                                                                                                                                                  «Часто причем это подкрепляется каким-либо» («причем» должно быть выделено запятыми).

                                                                                                                                                                                                                  Спасибо. И извините, если я сам где-то не верно исправил)
                                                                                                                                                                                                                  • НЛО прилетело и опубликовало эту надпись здесь
                                                                                                                                                                                                                      0
                                                                                                                                                                                                                      Формально тоже всё верно. Но, пожалуй, это слишком мрачная картина. Так ли уж часто вам приходится исследовать историю файла на большую глубину? Обычно никто не заглядывает в историю глубже одной-двух ревизий файла. Замена табуляции на пробелы делается глобально и один раз и не должна мешать дальнейшим сравнениям.


                                                                                                                                                                                                                      Работаю в поддержке старого проекта. Пару раз приходилось заглядывать в код, написанный два года назад. После проведенного реформатирования табов на пробелы поиски нужного места отнимают львиную долю времени, скажу я вам. А если нужно получить полный diff… попробуйте сами, а потом уже проводите подобные рефакторинги.
                                                                                                                                                                                                                        0
                                                                                                                                                                                                                        А в остальном согласен, табы сам уже давно не использую (естественно это не про клавишу Tab).
                                                                                                                                                                                                                        0
                                                                                                                                                                                                                        Вообще то недостаток пробелов — единственный, не считая конечно же смехотворного аргумента, что исходные файлы с пробелами занимают больше места.))

                                                                                                                                                                                                                        Он заключается в том, что невозможно настроить отображение текста для конкретного разработчика.

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

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

                                                                                                                                                                                                                        int someFunction(const int         _in1,
                                                                                                                                                                                                                                         const int         _in2,
                                                                                                                                                                                                                                         const CObject&    _in3,
                                                                                                                                                                                                                                         const CObjectDer& _in4,
                                                                                                                                                                                                                                         CObject&          _out1,
                                                                                                                                                                                                                                         CObjectDer&       _out2,
                                                                                                                                                                                                                                         CObject&          _out3);
                                                                                                                                                                                                                        

                                                                                                                                                                                                                        ширина табуляции — 4 пробела, при этом используются пробелы вместо символов Tab

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

                                                                                                                                                                                                                        Представляете, как выглядел бы приведенный выше код, если бы он был оформлен табуляциями (+пробелами, без них всё равно никуда) с отличными от первоначальных настроек табуляции?

                                                                                                                                                                                                                        int someFunction(const int< <  _in1,
                                                                                                                                                                                                                        < < < <  const int< <  _in2,
                                                                                                                                                                                                                        < < < <  const CObject&< _in3,
                                                                                                                                                                                                                        < < < <  const CObjectDer& _in4,
                                                                                                                                                                                                                        < < < <  CObject&< <   _out1,
                                                                                                                                                                                                                        < < < <  CObjectDer& _out2,
                                                                                                                                                                                                                        < < < <  CObject&< <   _out3);
                                                                                                                                                                                                                        

                                                                                                                                                                                                                        (1 табуляция — 2 пробела против 4-ех)

                                                                                                                                                                                                                        Аргументы поехали и уже не представлены в виде красивого столбика.

                                                                                                                                                                                                                        а если табуляцию увеличить?
                                                                                                                                                                                                                        Например 8 пробелов на таб?

                                                                                                                                                                                                                        int someFunction(const int<       <        _in1,
                                                                                                                                                                                                                        <       <       <       <        const int<       <        _in2,
                                                                                                                                                                                                                        <       <       <       <        const CObject&<       _in3,
                                                                                                                                                                                                                        <       <       <       <        const CObjectDer& _in4,
                                                                                                                                                                                                                        <       <       <       <        CObject&<       <         _out1,
                                                                                                                                                                                                                        <       <       <       <        CObjectDer& _out2,
                                                                                                                                                                                                                        <       <       <       <        CObject&<       <         _out3);
                                                                                                                                                                                                                        


                                                                                                                                                                                                                        Аргументы уезжают за правую сторону редактора.
                                                                                                                                                                                                                        Мало этого — еще и нихрена непонятно.
                                                                                                                                                                                                                        Зачем такая радость?

                                                                                                                                                                                                                        Итого:
                                                                                                                                                                                                                        Единственный вменяемый способ оформления своих исходников для просмотра разными редакторами — это использование исключительно пробелов вместо табов.

                                                                                                                                                                                                                        P.S.
                                                                                                                                                                                                                        Для тех кто в танке:
                                                                                                                                                                                                                        Необязательно жмакать 2/4/6/8 раз клавишу пробела для оформления отступа, достаточно настроить свой редактор на выставление пробелов при нажатии на клавишу Tab.

                                                                                                                                                                                                                        Например в VS он настраивается так:
                                                                                                                                                                                                                        TOOLS->Options...->Text Editor->C++->Tabs->Insert Spaces

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