27

您首选的包装代码行的方式是什么，尤其是在涉及长参数列表时？

有几个与换行有关的问题（例如，当编写代码时，你是否换行文本？和行宽格式标准），但我无法找到一个涵盖在哪里换行代码的问题。

假设我们有一行代码像这个例子一样继续运行：

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

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

所以，我的问题是，如果不涉及防止代码行太长的问题，你会如何建议包装代码行？具体来说，当涉及到长参数列表时，哪里是中断代码行的好地方？

4

14 回答 14

16 
int SomeReturnValue = SomeMethodWithLotsOfArguments
(   Argument1,
    Argument2,
    Argument3,
    Argument4
);
于 2008-11-12T10:47:51.410 回答
12

建议的选项 3

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

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

int SomeReturnValue = SomeMethodWithLotsOfArguments(
    Argument1,    Argument2,    Argument3,    Argument4,
    Argument005,  Argument006,  Argument7,    Argument8
);
于 2008-11-12T10:13:02.137 回答
7

我更喜欢这种方式：

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

线在最接近您当前最大线宽（无论是什么）的位置结束，下一行相对于等号缩进您通常的缩进级别（无论是什么）。

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

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

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

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

于 2008-11-12T12:37:54.077 回答
6

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

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

在 Visual Studio 中使用这种布局需要大量工作，但 Emacs 对我来说是自动的。

于 2008-11-12T13:06:13.363 回答
2

就个人而言，我不喜欢第二个选项，它与 Ascii 艺术太接近了，它在代码中带来了不便：更改函数的名称，您必须重新缩进所有参数。不知何故，它使文件膨胀。另外，如果您在代码中使用硬制表符，它也不会很好地工作。

大多数时候，我使用第一个选项，但我采用了 Eclipse 规则，即续行的两个缩进，因为它与普通缩进相比更好（特别是如果您拆分条件指令）。

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

参数与函数名分开的事实从来没有打扰过我，它们仍然很接近并且非常分组。在最坏的情况下，我可以在函数调用周围放置空行。

于 2008-11-12T10:48:18.087 回答
1

如果右手边没有被破坏，我总是在分配之前休息。这在像 Java 这样的语言中很有用，您必须明确声明所分配值的类型。

SomeVeryVerboseTypeName SomeReturnValue
   = SomeMethodWithLotsOfArguments(Argument1, Argument2, ...);
于 2008-11-12T11:19:47.867 回答
1

对我来说，这取决于参数列表有多长。我不太喜欢行尾布局，它几乎需要编辑器支持（例如 emacs）才能做好。

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

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

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

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

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

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

我想我只是想说我还没有找到我真正满意的解决方案，尽管这对真正过长的情况有一些吸引力，因为它与我们如何布置卷曲的方式相似：

int SomeReturnValue = SomeMethodWithLotsOfArguments(
    Argument1, 
    Argument2,
);
于 2008-11-12T11:32:12.150 回答
1

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

与他人合作时：

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

单独工作时：

我把方法串起来，行长对我来说不是问题。我有一个不错的宽屏显示器，水平滚动条的发明是有原因的。最重要的是，由于许多 IDE 都具有调用树、查找引用和重构工具等实用程序，因此导航源代码不仅仅是视觉滚动。

于 2008-11-12T12:29:00.333 回答
1

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

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

我可能会打破这条规则，并且每行都有相同数量的参数。

于 2008-11-12T12:50:51.147 回答
1

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

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

int someResturnValue - SomeMethod(somestruct);
于 2008-11-12T13:40:42.297 回答
1

第一的

如果 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）个参数的函数调用。而且我喜欢我的代码看起来整洁且!(so_ugly).

欢迎批评。请发表评论。

于 2014-07-25T11:25:53.333 回答
0

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

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

或者

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

取决于列表/参数长度。

于 2008-11-12T10:15:31.837 回答
0

我还使用 Edward Kmett 引用的“一致缩进选项”。如果有很多论点，我倾向于尽可能按相关性对它们进行分组。

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

我无法忍受“悬空环绕”格式，因为它很容易提供与（更重要的）缩进相冲突的视觉混乱。目前，悬空环绕被认为是许多语言的“默认”样式，但我不知道它是如何做到的。恕我直言，这太可怕了。

于 2008-11-12T11:24:29.263 回答
0

我更喜欢以下

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 个字符。代码行长度约定，我的约定实际上是灵活的，最多 120 到 140 个字符，通常我在 120 之后换行，但是在这种情况下，我会达到最大值。140 个字符。这样做的缺点当然是它不能在 IDE 中配置为自动格式化，例如 eclipse。

附言。我知道有些人认为 120 个字符对于代码行长度来说意义重大，但这是另一回事。上述约定当然也适用于 80 / 100 个字符。

于 2014-08-14T16:40:49.757 回答