Идея взята с постов telegram-канала Cross Join
Представьте себе, что какой-то программист придет на работу в одних трусах. Или вообще голышом. Работа встала, все обсуждают происходящее, смеются или кривят лицо, никто не работает. Приходит руководитель и пытается что-то сделать.
Плохое решение: ввести дресс-код на всю организацию. Костюм, галстук, белый верх, черный низ, начищенная обувь, никакого пирсинга, вот это всё.
Бред, правда? Ну да, слишком радикально. Пусть в целом люди ходят как хотят, и чувствуют себя хорошо. Исключительные ситуации нужно решать частным порядком (уволить хулигана?), ну в крайнем случае ввести правило, что кроме белья должно быть что-то еще.
И правда, бред. Ну а зачем тогда мы сами себе вводим бешеный фашизм в коде?
Слишком жесткие правила
Посмотрите правила code style. Стандарт PSR-12, например.
Вот несколько пунктов:
- В конце каждого файла должен быть перевод строки. А если не будет, то кто умрёт?
- Нельзя делать несколько statements на одной строке. Если я напишу
$x = 1; $y = 1; $z = 1;
, то читабельность ухудшится на 0.00001% и можно закрывать техотдел? - Declare statements MUST contain no spaces and MUST be exactly declare(strict_types=1). Ох, как всё серьёзно. Ни одного пробела, причем слово MUST капсом, чтобы все понимали степень ответственности. Если вставить где-нибудь пробел, то на код ревью никто код же прочесть не сможет!
Но блин, если один чудак однажды написал под воздействием каких-то веществ
declare( strict_types =1 )
то это еще не значит, что надо ВСЕХ бить плёткой ругать линтером за каждый пробел. Нужно просто вправить мозг ОДНОМУ чудаку. Готов поспорить, что именно он тогда пришел на работу без трусов.
Понятно, что в стандарте есть и нужные правила, но по моим наблюдениям почти в любой команде есть какие-то законы, которые придуманы фиг пойми для чего, никто уже не помнит, или не задумывался глубоко, насколько это всё важно или не важно.
Правила надо вводить, когда явно видно, что ухудшается читабельность. Это индивидуально для языка, проекта, команды.
Понятно, что есть способы автоматически отформатировать код по правилам. Вопрос в другом: какие правила нужны, а какие нет.
Почему это важно
Дома, когда ты пилишь свой pet-проект, ты используешь язык тот, какой хочешь, форматируешь код, как хочешь, структурируешь код, как хочешь. Точно не будешь надевать галстук.
И перформишь при этом как бог! Совершенно спокойно можно все выходные провести за кодингом и особо не устать.
Короче. От программирования мы получаем фан, от внешних навязанных ограничений мы получаем раздражение. От навязанных необоснованных ограничений мы получаем выгорание.
Раньше мне казалось, что начальство перегибает палку ради дисциплины в вакууме, и меня от этого бомбило. Я это запомнил, и, став тимлидом, в своих командах стал применять демократию. Не навязывал от себя практически никаких правил. Тем не менее странные правила всё равно появлялись.
К примеру, в Go есть goimports, который форматирует код по стандарту, вшитому в стандартный тулинг. Казалось бы, о чем тут теперь спорить. Но все равно внезапно обнаруживаешь себя, переименовывающим getJson в getJSON и getById в getByID, иначе правило линтера N100500 скажет айайай. При этом читабельность если и меняется, то незначительно, и даже не ясно, в какую сторону.
Куча такого. Ладно код стайл, бог с ним. Давайте не будем на нем акцентировать внимание, это не настолько серьёзная проблема. Но ведь есть тысячи других радикальных штук. Договорились, что контроллеры тонкие, не содержат никакой логики — и всё, даже убогий код в контроллере из пары строк где-то в богом забытой части системы порождает споры на код ревью — является ли это логикой или нет.
Дофаминовый цикл "сделал задачу — получил удовлетворение" нарушен. Сделал задачу — получи звиздюлей от линтера и коллег на код ревью.
Дофамин еще полбеды. Возведение принципов программирования (тех же DRY или SOLID) в радикальный абсолют может привести к таким абстракциям, что код превращается в нечитабельное месиво. Увидел пару switch case — сразу городи иерархию классов. Так ведь в книжке написано.
Мы ругаем бешеный принтер, ограничивающий свободу, но сами часто действуем по принципу "запретить и не пущать".
Вообще, иногда хочется пересмотреть вообще всё. Например, однажды мы думали, как назвать по-английски переменную для ЦФО (центр финансовой ответственности). Словарь говорит, что это будет financial responsibility center. Если назвать переменную "FRC", то новичку будет непонятно, что это за хрень. В документации по продукту термин везде по русски, ЦФО. Если назвать financialResponsibilityCenter, то можно догадаться, о чем речь, но слишком длинно как-то.
Понятно, что никто не рискнет так делать, но идеально было бы так и назвать переменную русскими буквами — ЦФО. Если проект сугубо для русскоязычных людей и русскоязычных программистов, то почему нет? Просто потому что не принято, вот и всё. Рациональных причин мало, и с ними можно поспорить, как минимум в каком-то конкретном случае.
Вывод
Я считаю, что:
Придумывая универсальное правило, нужно убедиться, что оно точно капец необходимо.
Применяя универсальное правило, нужно смотреть на контекст, и уметь делать исключения. Потому что совсем универсальных правил не существует.
UPD. Для джуниор-программеров правила должны быть более жесткими, потому что важность читабельности кода для них может быть не столь очевидна.
Очень надеюсь на дискуссию в комментариях. UPD Я уже пожалел, что про код стайл вставил в пример. Люди настолько на это сагрились, что основная мысль полностью потерялась. Я против говнокода и небрежного оформления. Но я также против правил, без которых можно обойтись.
Rive
Правила нужны не для того, чтобы штамповать код быстро — они нужны, чтобы мозг не взрывался при попытке добавить к этому коду что-нибудь спустя год. Возможно, уже другим людям.
varanio Автор
да, но, скажем от одного пробела мозг не взорвется.
Понятно, что какие-то правила нужны. Но куча же правил с недоказанной нужностью
DrPass
От одного пробела мозг не взорвётся. Но всякие там правила вроде «не больше одного оператора в строке» вполне себе нужны, особенно если в команде есть джуны. Да и вообще, весьма хорошая практика иметь единый стиль оформления кода во всей компании, это просто удобно. Программистам же на самом деле это ничуть не мешает. Эти правила никак не усложняют написание кода, но впоследствии заметно упрощают его чтение и сопровождение.
varanio Автор
Насчет джунов — это важная мысль. Дополню статью.
klirichek
Ну почему же сразу джуны?
Как только дело доходит до отладки и надо поставить брекпоинт — а его, внезапно, все могут ставить на строчку, и "не только лишь все" на отдельные операторы — так и приходит озарение.
Порой и сложное выражение в условии с той же целью хорошо разбить на несколько строк.
varanio Автор
Ваш пример с брейкпоинтом. В строке $x=1; $y=1; $z=1; нечего отлаживать. А если вдруг в каком-то сложном случае это будет нужно, ну поставил там перевод строки, да и всё.
klirichek
Речь как раз о том, чтобы НЕ ЗАНИМАТЬСЯ отдельно вставкой переводов строки. Пусть они сразу там стоят. А для этого лучше, если это правило будет в код-стайле.
Вы же пишете статью "в общем", не указывая язык программирования. Поэтому кроме python/php/javascript это может быть и С/С++, где вставка перевода строки подразумевает последующий билд и перезапуск. И если на локальной машине в любимой IDE это просто, как "два пальца", то на удалённом хосте у клиента, где есть только собранный бинарь и отладочные символы, это уже легко превращается в приключение. Поэтому — лучше заранее. Компилятор пробелы всё равно не считает, отладочные символы с информацией о дополнительных строчках всё равно нужны лишь для отладки — но если это недосмотрели, то раунд ребилда/редеплоя не очень обрадует.
varanio Автор
Если в строчке возможно понадобится дебаг, и еще и ребилд при этом нужен, то это будет важным правилом, и я только за.
Но в каких-то проектах оно может быть лишним
klirichek
Конечно!
В Вашем примере могу предположить, что это php.
Но, например, в C++ (да может быть и в том же php) в случае, если x,y,z — это не 'new shiny' переменные, а какие-нибудь ссылки на другие сущности, которые через грязные хаки в этот момент кто-то меняет из других потоков — всегда приятно, когда оно оказывается разбитым по строчкам. Если уж код сам по себе настолько плох, но хоть тут есть подстеленная охапка соломки — оно уже поддерживает охоту жить ).
marshinov
Настройте форматирование в ide и заведите привычку нажимать на хоткей перел коммитом. Пять минут времени и никаких пробелов
varanio Автор
Для нужных правил это ок. А для ненужных — непонятно зачем они вообще существуют
Almatyn
Они существуют, чтобы код был одинаковым у всех, кто работает по данному стандарту. А не потому что так писать код правильнее. Единообразие — знакомо такое слово?
Например, вам кажется, что правило переносить или ли не переносить фигурную скобку — не нужное правило. И вы исключили это правило. И пошла свистопляска. Вы перенесли фигурную скобку. Коммитнули. А ваш коллега, не переносит, увидел ваш перенос — поправил, удалил перенос. Коммитнул. И так по кругу. Т.е. многие правила может особо и не нужны, но если их не будет нарушится единообразие. Правила должны быть полными, чтобы любой код после форматирования этими правилами был одинаковым.
Фактически это не правила, а договоренности. Если договоренности не охватывают каких-то аспектов, то грош им цена.
BugM
Хорошо нам на Джаве.
Достаточно вписать в конец правил — Все остальное должно соответствовать автоформату Идеи. И все. Все случаи покрыты. Не надо городить кучу правил на все мелочи и корнер кейсы.
Сознательно вредительсво не рассматриваем.
Almatyn
Мне сейчас в мире Джаваскрипт очень комфортно. Вообще не надо ничего городить. Просто беру рекомендованные: 'plugin:vue/vue3-strongly-recommended', 'eslint:recommended', '@vue/typescript/recommended' и меня все устраивает, даже исключений не приходится делать. И очень зашел prettier. Я вообще перестал форматировать что-либо сам. А IDE само все делает, у меня например в момент сохранения.
Bonart
Правила форматирования прекрасны, когда поддержаны инструментом, который не бьет программиста по рукам, а одной кнопкой приводит форматирование к правильному
varanio Автор
Единообразие имеет ценность не само по себе а для какой-то цели, и только в определенных рамках.
Правила переноса фигурных скобок — да, важны.
А писать declare(strict_types=1) или declare(strict_types = 1) — вот воообще наплевать.
Согласны или нет?
Almatyn
В абстрактом мире это конечно не важно. И если вы один работаете. А если вы в команде и используете version control system, то это правило важно, как и все другие.
vap1977
Так если VCS используется, то виноват не тот, кто к правилу раслабленно относится, а тот, кто коммитит содержательные изменения вместе со стилевыми. Ну просто несопоставимо. И если претензии к тому, кто пробелы не так ставит, лично я сочту придиркой (ну, если это не совсем уж кровь из глаз с отягчающими обстоятельствами), то коммит со стилевыми правками вперемешку с содержательными — это уже реально очень крутой продолб.
Я где-то выше уже писал, что если не нравится чей-то не соответствующий общепроектному стиль — то возьми и поправь, и закоммить отдельным коммитом, причем по возможности убедившись, что ни в чьих ветках не будет проблем слияния.
Firz
Проблема, полагаю, как раз в автоматическом форматировании. У одного IDE удаляет пробелы, у второго добавляет, а теперь представьте что одному нужно что-то изменить в коде другого.
kmeaw
Нет, потому что единообразие позволяет легче использовать инструменты для решения тех задач, для которых они не были предназначены непосредственно.
, и мне не придётся усложнять свои регулярки, чтобы работало и с пробелами, и без.Например, grep и sed ничего не знают про грамматику вашего языка программирования.
Но я могу легко написать
С тем же успехом я могу настроить vim, чтобы он переходил к концу функции командой /^}$/, найти все функции регуляркой /^func/ и так далее.
Конечно, для решения всех этих задач есть «правильный» способ — взять кусок компилятора, который строит AST, скормить ему код (при этом не забыть аугментировать AST данными необходиыми для обратного преобразования), написать rewriter, а потом обратно сконвертировать в текст. А сочинить команду с grep/sed/perl/awk можно за пару минут.
Bonart
Это не совсем хороший момент: можно намешать в один коммит и значимые правки, и форматирование. Так что лучше еще и до первой своей правки в файле форматнуть и закоммитить
marshinov
Так и вправду лучше. Я скорее имел в виду, что проблема "страшного ужасного форматирования, лишних пробелов и табов" кажется надуманной в мире, где IDE в подсказказ разве что еще со стек оверфлоу код не предлагают тебе скопипастить (это, я думаю, не за горами уже:)
firedragon
В нормальных компаниях код просто не пройдет коммит если линт ругается.
Ну и хук стоит для авто формата
Druu
Как раз недавно была ситуация — надо было заменить реализацию ф-и на заглушку (ну т.е. вместо того, что там было, возвращать некоторую константу, это было актуально, естественно, исключительно для дев-ветки). При этом было линт правило — никаких неиспользуемых аргументов в ф-и! Понятное дело, что замена на заглушку приводила к неиспользуемым аргументам. А удаление аргументов, в свою очередь, приводило к ошибкам типов при вызове этой ф-и (на вызове аргументы-то были). Исправление тех ф-й — опять-таки каскадно приводило к неиспользуемым аргументам и ошибкам типов, в итоге, чтобы удовлетворить линт, коммит на 1 строчку легким движением руки превращается в коммит на несколько сотен строк. Иначе — коммит НЕ ПРОХОДИТ, ведь "в нормальных компаниях код просто не пройдет коммит если линт ругается".
Большая польза от этого всего, действительно, превратить минутную работу в часовое ковыряние в коде.
С другой стороны — время оплатит заказчик, а потому любой подход, который раздувает трудозатраты, полезен.
Если есть возможность проект, который делается год, делать три года — то какой смысл от нее отказываться? Это же просто не выгодно! Так что больше линт-рулзов — хороших и разных! А когда заказчик спросит — чо так долго? можно ему популярно объяснить, что вот смотрите сколько у нас линт-правил, пока все выполнишь… ух!
fkthat
Я работаю на C# и там любое правило можно на время или вообще навсегда отключить аттрибутом SuppressMessage именно в том месте где это надо. Как в других языках не знаю.
mayorovp
С одной стороны это неплохо, с другой стороны если заранее настраиваться на то, что по коду повсеместно будут расставляться SuppressMessage — не вполне понятно зачем вообще код проверять...
fkthat
SuppressMessage надо ставить либо на время (как в примере с unused parameter), либо если действительно есть какие-то причины для того, чтобы нарушить правило линтера. И к нему всегда следует писать обоснование (свойство Justification). Что интересно, что у самого линтера C# есть в свою очередь правило, которое запрещает вставлять SuppressMessage с пустым Justification. А еще удобство в VS — в окне Errors можно включить фильтр который сразу же покажет все "подавленные (suppressed)" предупреждения.
Druu
Можно, конечно. Но возникает вопрос — зачем вводить правила, и тем более ставить проверку их исполнения во время коммита, чтобы потом их отключать?
fkthat
Причин может быть много и вполне обоснованных, а не таких как "да надоел мне уже этот ворнинг". Например, берем проект ASP.NET Core, включаем FxCop, и, как правило, сразу же получаем ворнинги на то, что методы в Startup (ConfigureServices и Configure) нестатические (а статическими их сделать нельзя, т.к. сам фреймворк ожидает методов экземплярных). Или, например, строковые литералы, которые линтер будет требовать убрать из кода в ресурсы, хотя вы свое приложение не собираетесь никогда локализовывать. Или параметр метода, который из-за изменений в реализации стал неактуален, но какой-либо сторонний код совсем другого проекта все равно ожидает его наличия.
Druu
Я говорю не о причинах для обхода правила а о причинах его наличия. Зачем оно нужно в принципе, если его в итоге надо обходить? Я понимаю, что многие люди просто любят гордо преодолевать собственноручное созданные проблемы, но кроме этого?
fkthat
Затем, что в одном случае есть причины, чтобы его обходить, а в другом случае его лучше соблюдать.
Druu
Ну т.е. коммиты с ошибками линта блокируются не затем, чтобы в коммит не проходил код с ошибками линта, а затем, чтобы в коммит не проходил код с незаблоченными ошибками линта.
Но это же бессмыслица, т.к. делает ситуацию только хуже.
алсо, если правило надо то соблюдать, то не соблюдать — то разве не лучше тогда его просто отключить? И пусть каждый сам решает в каждом месте — надо это правило соблюдать или нет. Без дополнительных церемоний. Нет?
fkthat
Ну я же приводил тут примеры со статическими методами и неиспользуемыми параметрами, когда общее правило, которое следует соблюдать, не только может, но и должно быть нарушено в отдельном случае .
fkthat
А ты сам как думаешь? Если в походе в лесу можно пользоваться для еды только одной ложкой, а то и вообще одними руками, то разве не лучше тогда просто делать это и в ресторане.
S-e-n
Они не могут без правил, например, в каждом файле они начинают реально ЗАДУМЫВАТЬСЯ, как правильно расставить пробелы в «declare(strict_types=1)», и так с каждой мелочью. И для них это реально пытка, когда нет правил на абсолютно всё.
fkthat
Один из плюсов следования единному coding style это как раз чтобы не задумываться о каждой мелочи при форматировании или именовании.
S-e-n
Ещё чтобы не задумываться о каждой мелочи, можно о ней просто не задумываться. У меня получается.
fkthat
Про code review, я так понимаю, ты тоже не задумываешься, потому что у вас его нет?
S-e-n
А у вас code review — для подсчёта пробелов? А то я всегда на содержание смотрю в первую очередь. С вашей точки зрения, я делаю что-то не так?
fkthat
Прямо жду не дождусь удовольствия повникать в содержание кода, где треть локальных переменных в camelCase, треть в PascalCase, а еще треть вообще КАПСОМ набрана. Потому что авторы этого были слишком талантливы, чтобы "задумываться о каждой мелочи".
А чтобы на ревью не вникать в пробелы и прочее как раз и нужно использовать линтеры с общими для всех правилами.
Druu
Неисполнение правил, которые мы обсуждаем, обычно упрощает code review. Например, то самое правило, которое было упомянуто в этой ветке (недопуск неиспользуемых переменных) ведет к ненужному раздуванию дифа.
Ну и да, на самом деле, даже если вообще никак за кодстайлом не следить, то ревью это сколько-нибудь существенно не усложняет. Так что "правила нужны ради упрощения ревью" — это не более чем распространенный миф. Кто-то сказал глупость — остальные бездумно за ним повторяют. обычное явление, впрочем.
Думаю, что лучше отключить.
Это аналогия как раз в мою пользу. Я сам решаю прекрасно — чем и где мне есть, никакой линтер за этим не следит. И если я буду есть руками в ресторане — мне даже никто не сделает никакого замечания.
Так в том и смысл, что не в отдельном. Наоборот — обычно как раз и надо эти правила нарушать (с неиспользуемыми переменными — точно, что за правило на счет статических методов — не уверен, уточните).
fkthat
Ок. Дело твое. Точно так же ты можешь всегда сам решать — работать за деньги в команде, или работать забесплатно сам для себя :)
fkthat
Шарповому линтеру по умолчанию не нравится, если ты делаешь экземплярный метод там где мог бы быть статический. Из-за немного более медленного вызова. К слову сказать, я не совсем с этим правилом согласен, но никогда не имел проблем из-за его соблюдения (кроме случаев подобных вышеупомянутому, хотя, на самом деле, и в том случае это просто результат не очень удачного уже имеющегося API).
Druu
100% же в линтере есть правило которое говорит, что статический метод нельзя вызывать через экземпляр, с-но когда у вас статический метод становится обычным (или наоборот), то надо менять все call-site. Ну а при обратном изменении (если статический метод становится обычным) менять вызовы придется в любом случае. Типичный пример вредного правила, которое ведет к раздуванию диффа.
Так постоянно встречается. Стоит чуть поменять метод (вызвать в нем this) — и привет рефакторингу с заменой всех вызовов.
собственно, вот она проблема линтера — он смотрит только на синтаксис. Линтер не понимает смысла кода (а потому не может отличить "синтаксически статический" метод, в котором просто в силу случайности нету this, от "семантически статического", который должен быть статическим по задумке), не имеет никаких предположений о том, как будет изменяться и т.п.
Линтер банально не обладает (и не может обладать) информацией, которая необходима для принятия решений о том, каким должен быть код. Поэтому и решать он ничего не может. Ну или может, но ошибается регулярно.
Если я не сделал метод статическим, значит, он по смыслу не должен быть статическим. Вне зависимости от мнения линтера по этому поводу. Мне лучше знать, чем линтеру :)
Неисполнение дебильных линт-рулзов только помогает работать в команде)
Меньше споров и внутреннего недовольства, выше производительность — а значит ниже стресс :)
fkthat
Это да, поэтому мне самому это правило кажется немного спорным. Но, если честно, то не могу вспомнить случая, чтобы пришлось переделывать статику на нестатику или наоборот — это какое-то слишком уж сильное изменение семантики самого метода требуется. Считай то же самое, что перенос метода в другой класс, потому что статический метод это, фактически, не метод объекта класса Foo, а метод обьекта typeof(Foo). А, опять-таки, задумываться всякий раз делать ли мне метод статическим или экземплярным (когда можно и так и так) я не хочу — мне проще последовать совету линтера.
Еще меньше споров, недовольства, и стресса будет если не работать вообще :))
Druu
Ну так метод семантически либо сразу статический, либо нет (это понятно, когда ты его создаешь). Но при этом он может не иметь this и быть по смыслу нестатическим (что регулярно происходит) — тогда линтер ругается, и мы делаем его статическим (хотя понимаем, что статическим он быть не должен). После чего this предсказуемо появляется — и надо переделывать обратно :)
Но линтер не знает, должен быть метод статическим или нет — вот в чем штука.
Т.е. ваш подход — не думать и делать неправильно, оправдываясь тем, что "это посоветовал линтер".
Вы зачем-то работу (которая приносит пользу кастомерам, за что эти кастомеры платят деньги) равняете со следованием дебильным линт рулзам (которое никому ничего не приносит кроме потраченных нервов и уменьшения часового рейта).
fkthat
Не буду сразу утверждать, что такое невозможно, но как-то сложно сразу такое придумать. Буду рад примеру.
тогда линтер ругается, и мы метим конкретно этот метод атрибутом SuppressMessage с комментарием (Justification = "..."), почему мы этот метод все-таки сделали нестатическим.
Мой подход — думать над тем, над чем действительно надо мозгом думать, и сваливать по возможности все остальное на автоматизированные инструменты (в данном случае линтер).
Какие нервы, какой рейт — у меня IDE сама все форматирует и отклонения от правил по шорткату исправляет, а сами правила с самого начала все лежат в Git (файл .editorconfig), поэтому общие для всех и не нуждаются в настройках.
Druu
Эм, ну практически любой метод без this)
В смысле, на 1 реальный статический метод таких десяток приходится. правда тут конечно еще у вас особенности шарпа — в шарпе нельзя в топлевеле ф-и объявлять (ну, недавно вроде разрешили), а в js статические методы обычно просто выносятся из класса.
Так а зачем это делать, если можно просто нестатические методы делать нестатическими, без SuppressMessage?
Нет, еще раз. Ваш подход — делать неправильно.
Я тоже люблю использовать автоматизированные инструменты — но только в том случае, когда они работают правильно. А если они дают ошибочный результат, да еще и усложняют работу (в результате чего с автоматизацией трудозатраты выше, чем без них) — то нафига такая автоматизация нужна?
Далеко не все линт-рулзы исправляются. И, с-но, тем которые "больно" соблюдать как раз обычно не исправляются :)
Ну и да — как ваш шорткат исправляет замену обычного метода на статик? Вместе с фиксом всех call-site и диффом на сотню строк?
fkthat
Ну а все-таки, какой-нибудь жизненный пример? Мне все равно сложно представить метод, который никак не связан с this, но при этом связан с конкретным экземпляром класса.
А зачем вообще статические методы?
В чем неправильно-то? Использовать статические методы?
"Ctl + ." -> "Make static"
Да, если в пределах солюшена.
По строке на каждый вызов плюс строка объявления самого метода. При обычном переименовании метода будет то же самое.
Druu
Так он сейчас не связан с this. А завтра оп — и будет. Ну банальный пример — у вас есть компонент, который выводит список чего-то, есть метод который генерит разметку для элемента списка. Если в списке нет контролов — и this не будет, т.к. все нужные данные есть в item, который передается в метод аргументом. Но вот завтра бах — и элемент списка надо уметь выделять, поэтому нужен this.setState.
В жс, по сути — ни зачем, т.к. с тем же успехом можно просто объявить ф-и в отдельном модуле, разве что для декораторов это иногда полезно, т.к. статические члены, емнип, доступны в декораторе. В c# — ну, чтобы объявлять ф-и, которые "как бы не в классе", топлевел-объявлений-то там нет.
Нет, неправильно принимать решение о том, какой метод делать статическим, основываясь на советах линтера — который, условно говоря, в 50% не прав.
Ну т.е. автоматом это не фиксится, надо руками делать.
Так и зачем это нужно, если можно просто вырубить данное правило и не страдать?
Смотрите, я вам говорю: "у нас проблема", вы в ответ: "ну, вот у нас есть такие решения, вроде и не сложные, а еще можно сделать так и так". Окей, но смысл в том, что проблемы вообще могло бы не быть, и тогда ее не пришлось бы решать — достаточно просто вырубить правило и все.
ЗЫ: еще один кейс, кстати — если вам ваш статический метод захотелось перегрузить в подклассе. При этом тут ваще жопа — ведь исходный метод может быть вообще в другой сборке, к которой у вас нету доступа. И статический он там только из-за линтера, да). Отдельный вопрос — покажет ли линтер ошибку, если данный метод является частью реализации интерфейса? В случае тсовского линтера я прям уверен, что все равно покажет)
justboris
Ну конкретно в этой ситуации добавление исключения в линтер это нормально
С другой стороны, если таких исключений слишком много, то проще выключить это правило насовсем, благо современные линтеры это позволяют.
kloppspb
За скромное вознаграждение научу так писать заглушки, чтобы ни линтер, ни компилятор, ни интерпретатор на это не ругались.
Бесплатно могу рассказать руководству в каком направлении отправлять программистов, которые не умеют это делать…
Antervis
это вы всем отделом не могли придумать или загуглить как игнорировать аргументы в обход линтера? Что за язык/линтер то хоть? Даже интересно гуглится ли решение за 5 минут
xentoo
В Unix системах нет разницы между чтением файла из файловой системы, с девайса или потока. Эта строка в файлах нужна, чтобы узнать, что достигнут конец «данных» при чтении из входного потока — обычно это EOF. Когда ты открываешь стрим на APPEND, то он находит EOF, стирает и пишет с того места, в конце опять поставит EOF. Да, сейчас за тебя тебя много что делает современные тулы, но как быть со старыми?
vap1977
Ну так сейчас уже не CPM-овские времена с расстановкой 0x1A в неиспользуемом месте последнего сектора файла. Так что нет там никакого стирания EOF, просто к концу дописывают. Правда, если последняя строка не заканчивается переводом строки — то может сконкатенировать последнюю старую строку с первой новой.
edogs
Другие люди будут привычны к другим правилам и их мозг всё равно будет взрываться. Тот же пример с CFO и FRC в статье.
Такие мелочи просто приводить к единому стандарту в момент отправки кода.И даже сам через 2 года уже может будешь писать по другим стандартам (не потому что даже развиваешься, а потому что стандарты изменяются) и тоже старый код всё равно будет взрывать мозг.
Поэтому согласны с автором статьи. Фанатизма должно быть по минимуму. Проблемы форматирования решаются бьютифайером, включая даже стандарты именования переменных (getJson vs getJSON). Оговаривать же надо только то, что не только не решается, но и приводит к проблемам (FRC vs CFO). Остальное — пусть каждый… как он хочет.
Нам, например, намного проще настроить у себя ИДЕшку на стандарт
и прикрутить бьютифайер к моменту отправки кода, чем каждый раз насиловать себя тратя лишние строки
и так далее по тексту.
Писать надо так, как удобно. А вот коммититиь надо уже по стандарту.
mib
void main() {
}
я бы такой стиль запретил.
Нет симметричности, не понятно где что начинается и заканчивается.
Но в жаво-скрипте это не сработает: там куча конструкций, которые не получится использовать с фигурной скобкой в новой строке.
И получается, что часть кода с новой строкой, а часть без новой. Тогда уж лучше пусть у всего кода открытая фигурная скобка будет в конце строки.
Я смирился.
Antervis
жаль только большинство бьютифаеров еще фиг настроишь нормально… Например постоянная проблема — они умеют скобку либо всегда переносить, либо всегда оставлять. Переносить только если аргументы многострочные — до этого бьютифаеры не додумались (
polearnik
звучит как повод оставить issue на гитхабе вашего бьютифайера. Где можно проголосовать за эту фичу?
varanio Автор
Правила переноса фигурных скобок важны.
А вот важно ли, писать declare(strict_types=1) или declare(strict_types = 1)?
varanio Автор
я уверен, что вы сходу даже не заметили разницу
Bobos
Важно! Так же важно, как и уважать читателей своего кода или поста на хабре.
Вроде накопипастил коммент 10 раз, мир не рухнул.
Страшно представить, как выглядит ваш код
varanio Автор
божественный аргумент
Bobos
Аргумент — это утверждение, приводимое в подтверждение другого утверждения.
Я не приводил аргументов — всего лишь сделал утверждение.
Это базовые поняти логики.
Программирование основано на логике.
Дальше развивать тему не считаю нужным.
SergejSh
Суть поста 'Заставь дурака богу молиться...' Конечная цель нашей работы работающее приложение удовлетворяющее требованиям заказчика. Если правила упрощают эту задачу ОК. Есть правила усложняющие задачу (например англоязычное наименование всех без исключения сущностей).