Question

你喜欢包装代码行的首选方法是什么，特别是涉及长参数列表时？

有几个与包装线有关的问题（例如When writing code do you wrap text or not?和Line width formatting standard），但我找不到一个涵盖包含一行代码的地方。

假设我们有一行代码可以像这个例子一样继续前进：

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

应如何包裹？

以下是我能想到的几种方式，以及它们的一些缺点：

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

我个人不喜欢这个选项，因为格式化似乎在视觉上将参数列表与我试图调用的方法分开，特别是因为在上面的orphanged参数正上方有一个赋值等号（“=”）。新行。

所以，有一段时间我采用了以下方法：

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

这里，参数都捆绑在一起，都在方法的第一个参数的一边。但是，一个问题是，由于选项卡缩进的空格数，参数列表不会总是在第二行中排列。（为格式化输入额外的空格会非常耗时。）

上述问题之一中的answer建议采用以下格式：

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

我实际上喜欢这种格式，因为它的视觉吸引力，但它也可以在视觉上将参数与列表所属的方法分开。另外，我更喜欢单个方法调用而不占用太多行。

所以，我的问题是，没有遇到阻止行代码在一开始就变得太长的问题，你会如何推荐包装代码行？具体来说，在长参数列表中，哪里是打破一行代码的好地方？

Answer 1

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

Answer 2

选项3建议

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

是一种更好的方式，因为它给人一种良好的感觉。如果参数的长度或多或少相同，那么我们可以将它们放在一起，以便它们排成一个表格，例如

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

Answer 3

我更喜欢这种方式：

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

线条最接近当前最大线宽（无论是什么），下一条线相对于等号缩进通常的缩进级别（无论是什么）。

不确定原因，但我认为在大多数情况下它是最易读的选项。但是，我选择不对这些事情迂腐，我总是喜欢给定代码段最可读的东西，即使这可能会破坏一些缩进或格式化规则（当然也在限制范围内）。

这方面的一个例子是，如果函数需要许多参数或者它们本身很复杂的参数，那么我可能会选择这样的东西：

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

当然，如果参数表达式很长或很复杂，最好在函数调用之前进行计算，并使用临时值来存储结果。

Answer 4

我尽量保持线条简短。在这种情况下，我会在赋值之前和每个参数之后断开。我还将逗号放在行的开头，以便于添加新参数：

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

在Visual Studio中使用这种布局是很多工作，但Emacs让我自动化。

Answer 5

就我个人而言，我不喜欢第二种选择，太接近Ascii艺术，它在代码中有不便之处：更改函数的名称，你必须重新缩进所有参数。不知怎的，它膨胀了文件。如果在代码中使用硬标签，它也无法正常工作。

大多数时候，我使用第一个选项，但是我采用了两个缩进的Eclipse规则用于连续行，因为它比正常缩进更突出（特别是如果你拆分条件指令）。

有时我使用第二个选项，例如。如果左括号已接近我的行长限制...
优点：您可以在每个参数后添加一行注释或者我喜欢Dheer，将参数分组，直到它们填充线宽。

参数与函数名称分离的事实从未打扰过我，它们仍然接近并且完全分组。在最坏的情况下，我可以在函数调用周围添加空行。

Answer 6

如果离开右下方不间断的话，我总是在作业前休息。这在像Java这样的语言中非常有用，你必须明确地声明所分配的值的类型。

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

Answer 7

对我来说，这取决于参数列表的长度。我不太喜欢行尾布局，并且几乎需要编辑器支持（例如emacs）来做得好。

如果方法调用足够短以使其在一行上，我会这样做：

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

如果方法和变量适用于一行，而参数适用于另一行，我已经这样做了：

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

这让我的LISPy心中微笑，但是让同事们疯了，所以我心软了：

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

我想我只是想说我没有找到一个我真的很满意的解决方案，尽管这对于真正过长的案例有一些吸引力，因为它与我们如何布置curlies相似：

int SomeReturnValue = SomeMethodWithLotsOfArguments(
    Argument1, 
    Argument2,
);

Answer 8

警告：我使用IDE。如果您不是IDE用户，请跳过此步骤。

与他人合作时：

我倾向于坚持团队目前采用的任何惯例。如果团队使用支持代码格式的IDE，那就更好了。始终坚持团队/ IDE格式约定。不能告诉你有多少次我被“版本控制 - 差异 - 地狱 - 重新格式化”烧毁了

独自工作时：

我打开方法，行长度对我来说不是问题。我有一个漂亮的宽屏显示器和水平滚动条是出于某种原因发明的。最重要的是，导航源代码不仅仅是可视化滚动，因为许多IDE都具有调用树，查找引用和重构工具等实用程序。

Answer 9

对此我没有明确的答案。我是根据具体情况来做的。如果函数名称很长，我肯定不会将与前一个参数相同的列的其他参数缩进。如果函数名称很短，我通常会在同一列的参数后面缩进，在一行中收集尽可能多的参数（不是一个参数=一行）。但如果有一些令人愉悦的对称性，比如

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

我可能会违反该规则，并且每行都有相同数量的参数。

Answer 10

大多数人都提出了有关缩进的好建议，这对于您无法控制的API函数非常有用。如果您确实控制了API，我建议一旦您有超过3个参数，您应该创建某种形式的结构并将结构传递给例程。一旦你获得了超过3个参数，那么以错误的顺序传递它们的可能性就会越来越大。它还提供了对参数类型和含义的更多可见性。

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

int someResturnValue - SomeMethod(somestruct);

Answer 11

第一

如果args足够短并且（几乎）具有相似的长度，我认为在视觉上足够好

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
                                     );

顺便说一下，如果你想要一致的外观，请使用上面所有条件中的第三个。

Justify：整齐地穿上，我们知道它是一个带有很多（6）args的函数调用。我喜欢我的代码看起来很整洁!(so_ugly)。

欢迎评论家。请评论。

Answer 12

在具有长参数列表的函数中，为了便于阅读，我在每一个或两个参数之后进行换行（总是在每一行上保持相同数量的参数）：

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

OR

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

取决于列表/参数长度。

Answer 13

我还使用Edward Kmett引用的'一致缩进选项'。如果存在 lot 参数，我倾向于在可能的情况下按相关性对它们进行行分组。

但是对于这个特殊的例子，我可能会把它放在一行上，。

我无法忍受'悬空包装'格式，因为它很容易提供与（更重要的）缩进冲突的视觉混淆。悬挂包裹被认为是目前许多语言的“默认”风格，但我不知道它是如何形成的。这是恕我直言，可怕。

Answer 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用于代码块缩进。
将每个参数放在一个单独的行上可能会导致非常大的方法，因此我更喜欢在一行或多行上依次创建参数。
这种换行方式可以在Eclipse等IDE中配置，提供自动格式化功能。

然而，有一个重要的注意事项，可能会出现以下情况：

int variable_with_really_long_name = functionWhichDoMore(arg1,
        arg2)

我会尽量避免这种情况，如果发生这种情况我会做以下事情

int variable_with_really_long_name = functionWhichDoMore(arg1, arg2)

是的，我会把我的120 char最大化。代码行长度约定，我的惯例实际上是灵活的，最多120到140个字符，通常我在120之后换行，但是在这种情况下我会去最大。 140个字符。这样做的缺点当然是它无法配置为在诸如eclipse之类的IDE中进行自动格式化。

PS。我知道有些人认为120个字符对代码行长度来说很重要，但这是另一个讨论。上述惯例当然也适用于80/100字符。

在哪里包装一行代码，特别是长参数列表？

14 个答案:

第一

第二

第三