Coding style 冗余代码构造

我经常看到的最惊人的冗余代码结构涉及到使用代码序列

if (condition)
    return true;
else
    return false;

而不是简单地写

return (condition);

---

我在各种语言中都见过这种初学者错误：从Pascal和C到PHP和Java。在代码评审中，您还会标记哪些其他此类构造？

在最后无用地返回：

   // stuff
   return;
}

---

在字符串上使用.tostring

if (condition == true)
{
  ...
}

而不是

if (condition)
{
  ...
}

void myfunction() {
  if(!condition)
    return;

  // Do some stuff

  if(!othercond)
    return;

  // Do more stuff
}

if (x > 0)
  y = x + CalcZ(x);
else
  y = x - CalcZ(x);

{
    char buff[1024];
    /* ... */
}

{
    struct foo x;
    x.a = ...;
    bar(&x);
}

编辑：

甚至更糟，扭转条件测试：

if (condition == false)
{
  ...
}

这很容易理解为

if (condition) then ...

我一直告诉开发人员这样做是应该的

if ((foo == true) == true)
{
   do stuff
}

但他还没有得到暗示

void myfunction() {
  if(condition) {
    // Do some stuff
    if(othercond) {
      // Do more stuff
    }
  }
}

而不是

if (condition)
{
  ...
}

void myfunction() {
  if(!condition)
    return;

  // Do some stuff

  if(!othercond)
    return;

  // Do more stuff
}

if (x > 0)
  y = x + CalcZ(x);
else
  y = x - CalcZ(x);

{
    char buff[1024];
    /* ... */
}

{
    struct foo x;
    x.a = ...;
    bar(&x);
}

---

我曾经有一个家伙反复这样做：

bool a;
bool b;
...
if (a == true)
    b = true;
else
    b = false;

---

将

exit

语句作为函数中的第一个语句，以禁用该函数的执行，而不是以下选项之一：

• 完全删除该功能
• 对函数体的注释
• 保留函数但删除所有代码

---

使用

exit

作为第一个语句很难识别，您可以轻松地阅读它。

用C以外的语言与赋值分开声明：

int foo;  
foo = GetFoo();

---

使用注释而不是源代码管理：
-注释掉或重命名函数，而不是删除它们，并相信源代码管理可以在需要时为您找回它们。

---

-添加诸如“RWF更改”之类的注释，而不仅仅是进行更改并让源代码管理承担责任

我在某处发现了这个东西，我发现它是布尔冗余的顶峰：

return (test == 1)? ((test == 0) ? 0 : 1) : ((test == 0) ? 0 : 1);

if (x > 0)
{
   // a lot of code to calculate z
   y = x + z;
}
else
{
   // a lot of code to calculate z
   y = x - z;
}

---

：-）

我经常遇到以下情况：

function foo() {
    if ( something ) {
        return;
    } else {
        do_something();
    }
}

但这无助于告诉他们，其他的在这里是无用的。必须是两者之一

function foo() {
    if ( something ) {
        return;
    }
    do_something();
}

或-取决于在执行某项操作（）之前执行的检查的长度：

---

在需要设置行为时使用数组。在插入之前，您需要检查所有内容以确保它不在数组中，这会使代码变得更长、更慢

冗余代码本身不是错误。但是如果你真的想保存每个角色

return (condition);

这也是多余的。你可以写：

return condition;

对null的恐惧（这也会导致严重问题）：

冗余if（不使用else）：

冗余检查（拆分从不返回null）：

更多关于检查（如果要循环，则第二个检查是多余的）

我最喜欢的ASP.NET：将

DataBind

s分散在整个代码中，以使页面呈现

复制粘贴冗余：

return (test == 1)? ((test == 0) ? 0 : 1) : ((test == 0) ? 0 : 1);

if (x > 0)
{
   // a lot of code to calculate z
   y = x + z;
}
else
{
   // a lot of code to calculate z
   y = x - z;
}

而不是

if (condition)
{
  ...
}

void myfunction() {
  if(!condition)
    return;

  // Do some stuff

  if(!othercond)
    return;

  // Do more stuff
}

if (x > 0)
  y = x + CalcZ(x);
else
  y = x - CalcZ(x);

{
    char buff[1024];
    /* ... */
}

{
    struct foo x;
    x.a = ...;
    bar(&x);
}

或者更好（或者更模糊）

---

在堆上而不是堆栈上分配元素

{
    char buff = malloc(1024);
    /* ... */
    free(buff);
}

而不是

if (condition)
{
  ...
}

void myfunction() {
  if(!condition)
    return;

  // Do some stuff

  if(!othercond)
    return;

  // Do more stuff
}

if (x > 0)
  y = x + CalcZ(x);
else
  y = x - CalcZ(x);

{
    char buff[1024];
    /* ... */
}

{
    struct foo x;
    x.a = ...;
    bar(&x);
}

或

而不是

if (condition)
{
  ...
}

void myfunction() {
  if(!condition)
    return;

  // Do some stuff

  if(!othercond)
    return;

  // Do more stuff
}

if (x > 0)
  y = x + CalcZ(x);
else
  y = x - CalcZ(x);

{
    char buff[1024];
    /* ... */
}

{
    struct foo x;
    x.a = ...;
    bar(&x);
}

---

从噩梦般的代码审查

char s[100];

接

memset(s,0,100);

s[strlen(s)] = 0;

接

memset(s,0,100);

s[strlen(s)] = 0;

有很多讨厌的东西

if (strcmp(s, "1") == 0)

乱七八糟的代码。

冗余的.ToString（）调用：

const int foo = 5;
Console.WriteLine("Number of Items: " + foo.ToString());

不必要的字符串格式：

const int foo = 5;
Console.WriteLine("Number of Items: {0}", foo);

---

我看到的最常见的冗余代码结构是从不从程序中任何地方调用的代码

另一种是在没有意义的地方使用的设计模式。例如，到处写“newbobFactory（）.createBob（）”，而不是只写“newbob（）”

---

---

删除未使用和不必要的代码可以极大地提高系统的质量和团队的维护能力。对于从未考虑过从系统中删除不必要代码的团队来说，这些好处往往是惊人的。我曾经与一个团队坐在一起，在不改变系统功能的情况下删除了他们项目中超过一半的代码，从而执行了代码审查。我原以为他们会生气，但在那之后，他们经常要求我提供设计建议和反馈。

我想你比我快了几秒钟！是的，我一定快了一点。不过，我确实对你的观点投了赞成票，因为幽默：）如果你是“多重返回voilates structured code”类型的人，那么这个构造可能会被认为是有效的。你需要一个更好的例子。由于只有一个嵌套级别，“早期返回”样式也没有更好。在这个例子中，我更喜欢前者。但我知道你的意思，也同意这个想法。即使只有一个筑巢级别，“提前返回”仍然可以为你节省那个级别的筑巢。我不明白为什么一个级别没有更好，但2+级别更好。：）无论如何，编辑它是为了制作一个更令人震惊的示例。好吧，至少对我来说，一个级别的条件读取非常自然，没有任何混乱。然而，有时，当你设计一个要填写的代码时。在这种情况下，将该结构作为脚手架留在原地是有意义的。但是如果该函数被认为是“完整的”，那么编码人员应该对其进行优化以提高可维护性。我设置了社区wiki位-感谢您的建议。冗余代码构造？每一个不是用Python编写的程序。（我显然是想搞笑，不要启动火焰战争：）不要给他们相反的建议，这只会让他们感到困惑。实际上，如果（（（foo==true）==true==true）{…}为了调试，删除函数通常不是一个选项（如果在很多地方调用它），如果存在嵌套注释，则对正文进行注释是无效的，删除代码意味着您必须将其保存在某个位置。“real WTF”（tm）将退出语句保留在中。删除代码应该始终是一个选项，因为您有源代码管理。因此，真正的WTF没有源代码控制。嘿，当我继续阅读时，有人已经提到：）我遇到了这个案例，代码刚从一位同事那里脱离源代码控制。即使有两个人在看代码，我也不同意。原始代码的性能并不差，实际工作是在相同嵌套级别的代码中进行的——我发现这更具可读性。这实际上可以归结为一个团队式的惯例。我发现第一个案例也更容易阅读。也许视觉上的对称性会有所帮助，这要视情况而定。如果我们说的是提前退出，那么第二种形式是b