我更喜欢一个return语句。一个尚未指出的原因是，一些重构工具在单点退出时工作得更好，例如Eclipse JDT提取/内联方法。

我通常的策略是在函数的末尾只有一个return语句，除非通过添加更多的return语句来大大降低代码的复杂性。事实上，我是Eiffel的粉丝，它通过没有return语句强制执行唯一的返回规则(只有一个自动创建的'result'变量来放入结果)。

当然，在某些情况下，有多个返回值的代码比没有返回值的代码更清晰。有人可能会说，如果一个函数太复杂，没有多个return语句就无法理解，那么就需要更多的返工，但有时对这种事情采取务实的态度是好的。

作为嵌套if的替代方法，有一种使用do/while(false)在任何地方爆发的方法:

    function()
    {
        HRESULT error = S_OK;

        do
        {
            if(!SUCCEEDED(Operation1()))
            {
                error = OPERATION1FAILED;
                break;
            }

            if(!SUCCEEDED(Operation2()))
            {
                error = OPERATION2FAILED;
                break;
            }

            if(!SUCCEEDED(Operation3()))
            {
                error = OPERATION3FAILED;
                break;
            }
            if(!SUCCEEDED(Operation4()))
            {
                error = OPERATION4FAILED;
                break;
            }
        } while (false);

        return error;
    }

这为您提供了一个出口点，允许您进行其他嵌套操作，但仍然不是真正的深层结构。如果你不喜欢成功，你可以做任何失败的事情。这类事情还允许您在任意两个其他检查之间添加其他代码，而无需重新缩进任何内容。

如果你真的疯了，整个If块也可以宏化。: D

    #define BREAKIFFAILED(x,y) if (!SUCCEEDED((x))) { error = (Y); break; }

    do
    {
        BREAKIFFAILED(Operation1(), OPERATION1FAILED)
        BREAKIFFAILED(Operation2(), OPERATION2FAILED)
        BREAKIFFAILED(Operation3(), OPERATION3FAILED)
        BREAKIFFAILED(Operation4(), OPERATION4FAILED)
    } while (false);

正如Kent Beck在《实现模式》中讨论保护子句时指出的那样，使一个例程具有单一的入口和出口点……

是为了防止可能的混淆 当你在许多地方跳来跳去 同一例程中的位置。这让 当应用到FORTRAN或 汇编语言程序 有大量的全球数据，甚至 理解哪些语句是 执行是一项艰苦的工作……使用小方法和大部分本地数据，它是不必要的保守。”

我发现用保护子句编写的函数要比一长串嵌套的if then else语句容易理解得多。

如果可以只写下一个观点，那就是我的观点:

我完全不同意“单返回语句理论”，认为它在代码可读性、逻辑和描述方面都是推测性的，甚至是破坏性的。

使用一次-一次返回的习惯对于纯过程式编程来说都很糟糕，更不用说更高级的抽象(函数式、组合式等)了。此外，我希望所有以这种风格编写的代码都经过一些特殊的重写解析器，使其具有多个返回语句!

一个函数(如果它真的是一个函数/查询，根据“查询-命令分离”注意-见埃菲尔编程语言。例如)必须定义与控制流场景一样多的返回点。它在数学上更加清晰和一致;它是编写函数(即查询)的方法。

但对于你的特工收到的突变信息——程序调用，我不会那么激进。

使用单一的退出点有好处，就像不可避免的“箭头”编程也有坏处一样。

如果在输入验证或资源分配期间使用多个出口点，我尝试将所有“错误出口”非常明显地放在函数的顶部。

“SSDSLPedia”的Spartan Programming文章和“Portland Pattern Repository’s Wiki”的单一函数出口点文章都对此有一些深刻的争论。当然，还有这篇文章要考虑。

例如，如果您真的需要一个单一的退出点(在任何不支持异常的语言中)，以便在一个地方释放资源，我发现仔细应用goto是很好的;请看这个相当做作的例子(压缩以节省屏幕空间):

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

根据项目或编码指南的不同，大多数样板代码可以被宏替换。作为旁注，这样分解可以使函数g0、g1、g2非常容易单独测试。

显然，在面向对象和支持异常的语言中，我不会使用这样的if语句(或者根本不会使用，如果我可以用足够少的努力就能摆脱它的话)，代码将更加简单。和non-arrowy。大多数非最终回报可能是例外。

简而言之,

少回报比多回报好 多于一次的返回比巨大的箭头更好，并且保护条款通常是可以的。 在可能的情况下，例外可能/应该取代大多数“保护条款”。