Где перенести строку кода, особенно длинные списки аргументов? [закрытый]

int SomeReturnValue = SomeMethodWithLotsOfArguments
(   Argument1,
    Argument2,
    Argument3,
    Argument4
);

Опция 3 предложила

int SomeReturnValue = SomeMethodWithLotsOfArguments(
    Argument1,
    Argument2,
    Argument3,
    Argument4
);

, лучший путь, поскольку она дает хорошее чувство. Если длины аргументов - более или менее то же, то мы можем соединить их так, чтобы они выстроились в линию как таблица, например

int SomeReturnValue = SomeMethodWithLotsOfArguments(
    Argument1,    Argument2,    Argument3,    Argument4,
    Argument005,  Argument006,  Argument7,    Argument8
);

Я предпочитаю этот путь:

int SomeReturnValue = SomeMethodWithLotsOfArguments(Argument1, Argument2, 
                        Argument3, Argument4);

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

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

Один пример этого был бы то, если бы функция потребовала многих аргументов или argiments, где самих комплекс, тогда я мог бы, выбрал что-то вроде этого вместо этого:

int SomeReturnValue = SomeMethodWithLotsOfArguments(
                        Argument1 + Expression1 + Expression2, 
                        Argument2 - Expression3 * Expression4, 
                        Argument3, 
                        Argument4 * Expression5 + Expression6 - Expression7);

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

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

int SomeReturnValue 
   = SomeMethodWithLotsOfArguments(
         Argument1
       , Argument2
       , Argument3
       , Argument4
    );

Используя этот вид расположения большая работа в Visual Studio, но Emacs делает его автоматическим для меня.

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

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

int SomeReturnValue =
    SomeMethodWithLotsOfArguments(Argument1, Argument2, ...);

, Если метод и переменное соответствие на одной строке и аргументы на другом, я сделал это:

int SomeReturnValue = SomeMethodWithLotsOfArguments
    (Argument1, Argument2, ... );

, Который делает мою сердечную улыбку LISPy, но сводит моих коллег с ума, таким образом, я смягчился:

int SomeReturnValue = SomeMethodWithLotsOfArguments(
    Argument1, Argument2, ... );

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

int SomeReturnValue = SomeMethodWithLotsOfArguments(
    Argument1, 
    Argument2,
);

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

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

Когда-то я использую вторую опцию, например, если вводная круглая скобка уже является близостью моего предела длины строки...
Преимущество: можно добавить комментарий строки после каждого параметра.
Или мне действительно нравится Dheer, группируя аргументы, пока они не заполняют ширину строки.

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

предупреждение: Я использую IDE. Если Вы не пользователь IDE, просто пропустите это.

При работе с другими:

я склонен придерживаться любого соглашения, в настоящее время принимается командой. Еще лучше, если команда использует IDE с поддержкой формата кода. Всегда засовывайте w/соглашения формата команды/IDE. Не может сказать Вам, сколько раз я был записан "version-contro-diff-hell-due-to-reformats"

При работе один:

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

Нет никакого категорического ответа для меня на этом. Я делаю это на индивидуальной основе. Если имя функции длинно, я определенно не располагаю другие аргументы с отступом тому же столбцу как предыдущие аргументы. Если имя функции коротко, я обычно отступ после аргументов тому же столбцу, собираясь как много аргументов, я могу на одной строке (не один аргумент = одна строка). Но если бы существует некоторая приятная симметрия, как в

int a = foo(a + b,
            c + d);

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

Я всегда повреждаюсь перед присвоением, если это оставляет righthandside неповрежденным. Это - usful на языках как Java, где Вы имеете к explictly, объявляют тип значения, которое это присвоено.

SomeVeryVerboseTypeName SomeReturnValue
   = SomeMethodWithLotsOfArguments(Argument1, Argument2, ...);

Большинство сделало большие предложения о расположении с отступом и здорово для API-функций, которыми Вы не управляете. Если бы Вы действительно управляете API, я предложил бы, чтобы однажды Вы ahve больше чем 3 аргумента Вы создали некоторую форму структуры и передать структуру стандартной программе. Как только Вы добираетесь выше 3 аргументов, шанс передачи их в неправильном порядке идет путем, путь. Это также дает больше видимости типу и значению параметров.

someStruct.x = somevalue;
somestruct.y = someothervalue;

int someResturnValue - SomeMethod(somestruct);

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

int SomeReturnValue = SomeMethodWithLotsOfArguments(Argument1,
                                                       Argument2,
                                                       Argument3,
                                                       Argument4);

ИЛИ

int SomeReturnValue = SomeMethodWithLotsOfArguments(Argument1, Argument2,
                                                       Argument3, Argument4);

в зависимости от длины списка/параметра.

Я также использую ‘consistent, делающий отступ option’, как заключено в кавычки Edward Kmett. Если существует партия из аргументов, я ухаживаю группе строки за ними связанностью, если это возможно.

, Но для этого конкретного примера я, вероятно, оставил бы его на одной строке, это не это долго.

я не могу выдержать ‘dangling wrap’ формат, поскольку это может легко предоставить визуальному беспорядку, конфликтующему (намного более важное) расположение с отступом. Повисшие обертки считают стилем ‘default’ для многих языков в данный момент, но я не знаю, как это получило тот путь. Это, по моему скромному мнению, ужасно.