Это плохая идея перечислить каждый аргумент функции / метода в новой строке и почему?

Я работаю с кем-то, кто при каждом вызове функции помещает аргументы в новую строку, например

aFunction(
    byte1,
    short1,
    int1, 
    int2,
    int3,
    int4,
    int5
) ;

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

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

Очевидно, что лучший способ повысить читабельность - это ограничить количество аргументов.

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

Например:

do_complex_op(
      0, //Starting state, always 0, ask Joe why
      X, //X-coord of thingy
      y, //Y-coord of thingy
      73, //in this case, we don't want to use Z but want constant 
      dlogMessageTitle, //message for dialogue title
      dlogMessageText, //message for dialogue contents, don't care about this.
      SomethingIP, //IP of something-or-other server, can be NULL, won't crash.
      someObject.childObject.getValue(key1).HVAL, //very long path to HVAL
      someObject.childObject.getValue(key1).LVAL, //very long path to LVAL
      this.parentWindow.owner.mainTextBox.text.value.trim, //get the trimmed text, untrimmed text causes weird output
      pvrMainSettingForLongBlahs.getObjectByPath(somePath),
      pvrMainSettingForLongBlahs.K_TCA_UPPER_LIMIT,
      pvrMainSettingForLongBlahs.K_ENDPOINT_COMPLIANCE_LEVEL,
 );

С языками, которые допускают именованные параметры, это более распространено, если вы используете имена параметров (пример на PL / SQL):

PKG_SOME_TEST_CODE.FN_DO_SOMETHING( in_text => 'test text',
                                    in_id => v_id,
                                    in_ref_id => v_ref_id,
                                    out_array_for_storage => v_bArray); 

Но я согласен с вами, что если вызов функции прост и не слишком много параметров, это может раздражать, например:

setColour (
    r,
    g,
    b
 );

Мне гораздо легче читать как

 setColour(r,g,b);

Для @ammoQ:

rc=a(b,c(d,e(f)))

rc=a(
     b,
     c(
       d,
       e(
         f
        )
      )
    )

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

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

Ну, вот немного приманки. Меня никогда не обвиняли в популярных вещах. Понятно, что если вещи помещаются в одну строку, то хорошо, поместите их в одну строку.

Но меня больше всего беспокоит не то, является ли код «уродливым» или «красивым». Моя главная забота - насколько легко понять и вносить изменения без ошибок.

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

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

Итак (мальчик, я за это заплачу) я напишу это так:

nameOfFunction(firstArgument
    , secondArgument // optional comment
       ...
    , lastArgument   // optional comment
    );

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

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

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

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

Это облегчает:

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

Я бы сказал, что вызовы функций должны быть все в одной строке, если они значительно не превышают стандартную ширину кода (часто 80 символов, часто причина аргументов :-).

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

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

Это противоречит стандартам кодирования компании?

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

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

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

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

Это также легче читать, чем:

int f(int, int, int,
      char, double, int
      X const&, Y)
{}

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

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

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

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

Что для моего прочтения ... это именно то, что вы просите в этом вопросе: нелепый, неискренний аргумент, оправдывающий ваши личные предпочтения.

Честно говоря, это зависит от человека. Я бы сказал, что для сложных функций, как показано в FrustratedWithForms, сначала пример, затем да; иначе большое НЕТ. Опять же, именно поэтому я предпочитаю применять функциональность IDE кода произвольно.

«Мне интересно знать, действительно ли это плохая практика ...»

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

"... и если да, то как я могу убедить их не делать этого?"

Свяжите их и продолжайте щекотать, пока они не согласятся остановить это дерьмо.

Почему вы тратите циклы на такие тривиальные проблемы? Просто запустите вашу верную IDE, откройте файл и переформатируйте. Вуаля! Это будет в любой форме, которую вы хотите.

Теперь давайте перейдем к действительно важному вопросу - vi или emacs, LOL.

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

foo(arg1, arg2, arg3, arg4, arg5)

противы

foo(
    arg1=arg1,
    arg2=arg2,
    arg3=arg3,
    arg4=arg4,
    arg5=arg5,
    arg6=arg6,
    arg7=arg7
)