Однострочные заявления и передовой опыт

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

textBox1.Text = "Something!"; textBox2.Text = "Another thing!"; textBox3.Text = "Yet another thing!";

в отличие от

textBox1.Text = "Something!";
textBox2.Text = "Another thing!";
textBox3.Text = "Yet another thing!";

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

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

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

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

Ох и опечатки! Снижение читабельности вашего кода таким образом может сделать кошмаром поиск того, какое из 50 объявлений переменных вы задали неправильно. Большинство компиляторов выдают ошибки в номерах строк и столбцов, но найти ошибку в строке НАМНОГО легче, чем найти столбец.

Одно утверждение в строке также облегчает просмотр изменений в параллельном дифференциале.

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

В вашей трассировке стека будет указано «EBlah в строке N» ... и теперь вы не знаете, какое из этих пяти утверждений породило исключение.

(То же самое происходит с чрезмерно длинным утверждением любого вида.)

One-Statement-per-line - это широко используемый стиль кодирования. В результате большинство разработчиков, которые смотрят на ваш код в будущем, вероятно, вздрогнут, когда увидят несколько операторов в строке. Когда вы привыкли видеть что-то одним способом, это может сбивать с толку, когда вы видите это по-другому.

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

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

Я морщусь при мысли об этом (хотя это было сделано по уважительной причине).

К сожалению, такой код трудно читать и, следовательно, трудно поддерживать.

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

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

textBox1.Text = "Something!";
textBox2.Text = "Another thing!";
textBox3.Text = "Yet another thing!";

Это действительно необычный стиль кодирования.

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

Слишком далеко вправо может создать столько же проблем, сколько и несколько строк.

Мне приходилось иметь дело с некоторыми операторами SQL с десятками полей. Обычно я ставлю по одному на строку, но в нескольких случаях я объединял 3 или 4 в строку. Это кажется хорошей идеей во время разработки, когда вам приходится прокручивать вверх и вниз несколько раз.

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

Кроме того, вы думаете, что у любого, кому когда-либо придется поддерживать мой код, есть проблемы с этим подходом?

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

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

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

Посмотрите на ваш пример: вы сразу знаете, что код - это Textсвойство различных textBoxобъектов, и они содержат строку в качестве значений. Довольно просто.

Я бы лично не использовал такой стиль. Подвести итоги

Pros

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

Cons

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