Подтвердить что ты не робот

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

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

Было несколько вопросов, относящихся к линиям обертывания (например, При написании кода вы обертываете текст или нет? и Стандарт форматирования ширины линии), но я не смог найти тот, который охватывает, где можно обернуть строку кода.

Скажем, у нас есть строка кода, которая продолжает двигаться и идет следующим образом:

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

Как это должно быть обернуто?

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

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

Я лично не предпочитаю этот параметр, потому что форматирование, по-видимому, визуально отделяет список аргументов от метода, который я пытаюсь вызвать, тем более, что есть присвоение равно знаку ( "=" ) прямо над аргументами аргумента новая строка.

Итак, какое-то время я пошел со следующим подходом:

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

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

Ответ в одном из предыдущих вопросов предложил следующий формат:

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

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

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

4b9b3361

ОТВЕТЫ

Ответ 1

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

Ответ 2

Вариант 3 предложил

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

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

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

Ответ 3

Я предпочитаю этот способ:

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

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

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

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

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

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

Ответ 4

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

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

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

Ответ 5

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

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

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

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

Ответ 6

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

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

Ответ 7

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

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

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

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

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

Это делает мою LISPy сердце улыбкой, но диск моих коллег орехи, поэтому я смягчился:

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

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

int SomeReturnValue = SomeMethodWithLotsOfArguments(
    Argument1, 
    Argument2,
);

Ответ 8

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

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

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

При работе в одиночку:

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

Ответ 9

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

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

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

Ответ 10

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

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

int someResturnValue - SomeMethod(somestruct);

Ответ 11

Первая

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

int variable_with_really_long_name = functionWhichDoMore(Argument1, ArgumentA2, 
                                                         ArgumentA3, Argument4, 
                                                         ArgumentA5, Argument6);

Второй

Когда становится все хуже, один столбец аргумента действительно помогает

int variable_with_really_long_name = somefunctionWhichDoMore(Argument_Expand1, 
                                                             Argument2, 
                                                             Argument_Expand3, 
                                                             Argument_Expand4, 
                                                             Argument_Expand5, 
                                                             Argument6);

Третий

Но, теперь, Как, если это ухудшится! Что теперь? Попробуйте этот

int variable_with_really_long_name = someFunctionWhichDoMore
                                     (
                                       Argument_Expand_More1, 
                                       Argument_Expand_More2, 
                                       Argument_Expand3, Argument4, 
                                       Argument_Expand_More5, Argument6
                                     );

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

Обоснование: аккуратно надеты, и мы знаем, что это вызов функции с большим количеством (6) аргументов. И мне нравится, что мой код выглядит аккуратно и !(so_ugly).

Критики приветствуются. Прокомментируйте.

Ответ 12

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

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

ИЛИ

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

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

Ответ 13

Я также использую параметр "согласованный отступ", который цитирует Эдвард Кемт. Если есть много аргументов, я стараюсь, по возможности, группировать их по родству.

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

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

Ответ 14

Я предпочитаю следующее

int variable_with_really_long_name = functionWhichDoMore(
        Argument1, ArgumentA2, ArgumentA3, Argument4, 
        ArgumentA5, Argument6);

int i = foo(Argument1, ArgumentA2, ArgumentA3, Argument4, 
        ArgumentA5, Argument6);

Оба согласуются друг с другом, достигая 80 символов, я иду на следующую строку и помещаю 2 отступов по 4 пробела. Моей аргументацией для этого является следующее:

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

  • Этот способ отступов сохраняет код с четным отступом, поскольку он всегда следует за тем же шаблоном отступов, 2 отступов для обертки строк, 1 отступ для кодовых блоков.

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

  • Этот способ переноса строк можно настроить в среде IDE, такой как Eclipse, обеспечивая возможность автоматического форматирования.

Однако есть одно важное замечание: могут быть исключительные случаи, когда происходит следующее:

int variable_with_really_long_name = functionWhichDoMore(arg1,
        arg2)

Я постараюсь избежать этого, если это произойдет, я сделаю следующее

int variable_with_really_long_name = functionWhichDoMore(arg1, arg2)

Да, я буду pas my 120 char max. соглашение о длине строки кода, мое соглашение на самом деле гибкое, максимум от 120 до 140 символов, обычно я обертываю после 120, однако в этом случае я перейду к макс. 140 символов. Недостатком этого является, конечно, то, что он не может быть настроен для автоматического форматирования в среде IDE, такой как eclipse.

пс. Я знаю, что некоторые люди думают, что 120 символов - это много для длины строки кода, но это целая дискуссия. Разумеется, вышеупомянутые соглашения также могут применяться для символов 80/100.