一个函数应该只有一个return语句吗？

我认为后者相当清楚.据我所知,多个退出点的批评现在是一个相当古老的观点.

我目前正在开发一个代码库,其中有两个人在盲目地订阅"单点退出"理论,我可以告诉你,根据经验,这是一个可怕的可怕做法.它使代码非常难以维护,我会告诉你原因.

有了"单点退出"理论,您不可避免地会遇到如下代码:

function()
{
    HRESULT error = S_OK;

    if(SUCCEEDED(Operation1()))
    {
        if(SUCCEEDED(Operation2()))
        {
            if(SUCCEEDED(Operation3()))
            {
                if(SUCCEEDED(Operation4()))
                {
                }
                else
                {
                    error = OPERATION4FAILED;
                }
            }
            else
            {
                error = OPERATION3FAILED;
            }
        }
        else
        {
            error = OPERATION2FAILED;
        }
    }
    else
    {
        error = OPERATION1FAILED;
    }

    return error;
}

这不仅使代码很难遵循,而且现在稍后说你需要返回并在1到2之间添加一个操作.你必须缩进整个怪异功能,祝你好运你的if/else条件和大括号是否正确匹配.

此方法使代码维护极其困难且容易出错.

结构化编程说你应该每个函数只有一个return语句.这是为了限制复杂性.许多人如Martin Fowler认为用多个return语句编写函数更简单.他在他写的经典重构书中提出了这个论点.如果你遵循他的其他建议并编写小函数,这很有效.我同意这种观点,只有严格的结构化编程纯粹主义者遵守每个函数的单个返回语句.

正如肯特贝克在实施模式中讨论保护条款时所说的那样,使例程有一个单一的入口和出口点......

"这是为了防止在同一例程中进出许多位置时出现混淆.当应用于FORTRAN或汇编语言程序时,它很有意义,这些程序用大量全局数据编写,甚至理解执行哪些语句也很难.用小方法和大多数本地数据,这是不必要的保守."

我发现一个用guard子句编写的函数比一个长嵌套的if then else语句更容易理解.

在没有副作用的函数中,没有充分理由获得多个返回值,您应该以函数式编写它们.在具有副作用的方法中,事物更顺序(时间索引),因此您使用return语句作为命令停止执行,以命令式方式编写.

换句话说,如果可能的话,赞成这种风格

return a > 0 ?
  positively(a):
  negatively(a);

在此

if (a > 0)
  return positively(a);
else
  return negatively(a);

如果您发现自己编写了几层嵌套条件,那么可能有一种方法可以使用谓词列表进行重构.如果您发现ifs和elses在语法上相距甚远,您可能希望将其分解为更小的函数.跨越多个屏幕文本的条件块很难阅读.

没有适用于每种语言的硬性规则.像一个返回语句之类的东西不会使你的代码变好.但好的代码往往会让你以这种方式编写你的函数.

我已经在C++的编码标准中看到了它,这是C语言的遗留问题,好像你没有RAII或其他自动内存管理那么你必须清理每次返回,这或者意味着剪切和粘贴清理或goto(逻辑上与托管语言中的'finally'相同),这两种都被认为是不良形式.如果你的做法是在C++或其他自动内存系统中使用智能指针和集合,那么就没有强有力的理由,它就变成了可读性和更多的判断调用.

我倾向于认为函数中间的返回语句很糟糕.你可以使用return在函数的顶部构建一些guard子句,当然告诉编译器在函数结束时返回什么没有问题,但是函数中间的返回很容易错过并且可以使功能更难解释.

是否有充分的理由说明为什么在函数中只有一个return语句是更好的做法？

是的,有:

单一出口点是断言后期条件的绝佳场所.

能够在函数末尾的一个返回上放置调试器断点通常很有用.

回报越少意味着复杂性越低.线性代码通常更容易理解.

如果试图将函数简化为单个返回会导致复杂性,那么这就是重构更小,更通用,更容易理解的函数的动机.

如果您使用的是没有析构函数的语言,或者如果您不使用RAII,那么单次返回会减少您必须清理的地点数量.

某些语言需要单个退出点(例如,Pascal和Eiffel).

这个问题通常被认为是多个回报或深度嵌套的if语句之间的错误二分法.几乎总有第三种解决方案非常线性(没有深度嵌套),只有一个出口点.

更新:显然,MISRA指南也促进单一退出.

要明确的是,我并不是说多次退货总是错的.但是考虑到其他方面相同的解决方案,有很多理由可以选择具有单一回报的解决方案.

拥有单一出口点确实在调试提供了一个优势,因为它可以让你在一个函数的末尾设置一个断点,单看什么样的价值实际上是要被退回.

一般来说,我尝试从函数中只有一个退出点.然而,有时候这样做实际上最终会创建一个比必要的更复杂的函数体,在这种情况下,最好有多个出口点.它必须是基于由此产生的复杂性的"判断调用",但目标应该是尽可能少的出口点而不牺牲复杂性和可理解性.

我倾向于单一退出,除非它确实使事情复杂化.我发现在某些情况下,多个存在点可以掩盖其他更重要的设计问题:

public void DoStuff(Foo foo)
{
    if (foo == null) return;
}

void foo (int i, int j) {
  A a;
  if (i > 0) {
     B b;
     return ;   // Call dtor for 'b' followed by 'a'
  }
  if (i == j) {
     C c;
     B b;
     return ;   // Call dtor for 'b', 'c' and then 'a'
  }
  return 'a'    // Call dtor for 'a'
}

A foo () {
  A a1;
  // do something
  return a1;
}

void bar () {
  A a2 ( foo() );
}

function isCorrect($param1, $param2, $param3) {
    $toret = false;
    if ($param1 != $param2) {
        if ($param1 == ($param3 * 2)) {
            if ($param2 == ($param3 / 3)) {
                $toret = true;
            } else {
                $error = 'Error 3';
            }
        } else {
            $error = 'Error 2';
        }
    } else {
        $error = 'Error 1';
    }
    return $toret;
}

function isCorrect($param1, $param2, $param3) {
    if ($param1 == $param2)       { $error = 'Error 1'; return false; }
    if ($param1 != ($param3 * 2)) { $error = 'Error 2'; return false; }
    if ($param2 != ($param3 / 3)) { $error = 'Error 3'; return false; }
    return true;
}

function isEqual($param1, $param2) {
    return $param1 == $param2;
}

function isDouble($param1, $param2) {
    return $param1 == ($param2 * 2);
}

function isThird($param1, $param2) {
    return $param1 == ($param2 / 3);
}

function isCorrect($param1, $param2, $param3) {
    return !isEqual($param1, $param2)
        && isDouble($param1, $param3)
        && isThird($param2, $param3);
}

int f(int y) {
    int value = -1;
    void *data = NULL;

    if (y < 0)
        goto clean;

    if ((data = malloc(123)) == NULL)
        goto clean;

    /* More code */

    value = 1;
clean:
   free(data);
   return value;
}

int g(int y) {
  value = 0;

  if ((value = g0(y, value)) == -1)
    return -1;

  if ((value = g1(y, value)) == -1)
    return -1;

  return g2(y, value);
}

public void hello()
{
   if (....)
   {
      ....
   }
}

void string fooBar(string s, int? i) {

  if(string.IsNullOrEmpty(s) || i == null) return null;

  var res = someFunction(s, i);

  foreach(var r in res) {
      if(!r.Passed) return null;
  }

  // Rest of code...

  return ret;
}

if (string.IsNullOrEmpty(s) || i == null) return null;
if (someFunction(s, i).Any(r => !r.Passed)) return null;

void string fooBar(string s, int? i) {

  if (string.IsNullOrEmpty(s) || i == null) return null;
  if (someFunction(s, i).Any(r => !r.Passed)) return null;

  // Rest of code...

  return ret;
}

resulttype res;
if if if...
return res;

sub Int_to_String( Int i ){
  given( i ){
    when 0 { return "zero" }
    when 1 { return "one" }
    when 2 { return "two" }
    when 3 { return "three" }
    when 4 { return "four" }
    ...
    default { return undef }
  }
}

@Int_to_String = qw{
  zero
  one
  two
  three
  four
  ...
}
sub Int_to_String( Int i ){
  return undef if i < 0;
  return undef unless i < @Int_to_String.length;
  return @Int_to_String[i]
}

void ProcessMyFile (char *szFileName)
{
   FILE *fp = NULL;
   char *pbyBuffer = NULL:

   do {

      fp = fopen (szFileName, "r");

      if (NULL == fp) {

         break;
      }

      pbyBuffer = malloc (__SOME__SIZE___);

      if (NULL == pbyBuffer) {

         break;
      }

      /*** Do some processing with file ***/

   } while (0);

   if (pbyBuffer) {

      free (pbyBuffer);
   }

   if (fp) {

      fclose (fp);
   }
}