I always avoid multiple return statements. Even in small functions. Small functions can become larger, and tracking the multiple return paths makes it harder (to my small mind) to keep track of what is going on. A single return also makes debugging easier. I've seen people post that the only alternative to multiple return statements is a messy arrow of nested IF statements 10 levels deep. While I certain agree that such coding does occur, it isn't the only option. I wouldn't make the choice between a multiple return statements and a nest of IFs, I'd refactor it so you'd eliminate both. And that is how I code. The following code eliminates both issues and, in my mind, is very easy to read:

public string GetResult()
{
    string rv = null;
    bool okay = false;

    okay = PerformTest(1);

    if (okay)
    {
        okay = PerformTest(2);
    }

    if (okay)
    {
        okay = PerformTest(3);
    }

    if (okay)
    {
        okay = PerformTest(4);
    };

    if (okay)
    {
        okay = PerformTest(5);
    }

    if (okay)
    {
        rv = "All Tests Passed";
    }

    return rv;
}

我能想到的一个很好的理由是代码维护:您有一个单一的退出点。如果你想改变结果的格式，…，它的实现要简单得多。此外，为了调试，你可以在那里插入一个断点:)

话虽如此，我曾经不得不在一个库中工作，那里的编码标准强制要求“每个函数一个返回语句”，我发现这相当困难。我写了很多数值计算代码，经常有“特殊情况”，所以代码最终很难跟上……

I've seen it in coding standards for C++ that were a hang-over from C, as if you don't have RAII or other automatic memory management then you have to clean up for each return, which either means cut-and-paste of the clean-up or a goto (logically the same as 'finally' in managed languages), both of which are considered bad form. If your practices are to use smart pointers and collections in C++ or another automatic memory system, then there isn't a strong reason for it, and it become all about readability, and more of a judgement call.

Well, maybe I'm one of the few people here old enough to remember one of the big reasons why "only one return statement" was pushed so hard. It's so the compiler can emit more efficient code. For each function call, the compiler typically pushes some registers on the stack to preserve their values. This way, the function can use those registers for temporary storage. When the function returns, those saved registers have to be popped off the stack and back into the registers. That's one POP (or MOV -(SP),Rn) instruction per register. If you have a bunch of return statements, then either each one has to pop all the registers (which makes the compiled code bigger) or the compiler has to keep track of which registers might have been modified and only pop those (decreasing code size, but increasing compilation time).

今天仍然坚持使用一个return语句的一个原因是易于自动重构。如果您的IDE支持方法提取重构(选择一系列行并将它们转换为一个方法)，那么如果您想提取的行中有一个return语句，特别是如果您正在返回一个值，则很难做到这一点。

总是要求单一的返回类型是没有意义的。我认为这更像是一个标志，表明某些东西可能需要简化。有时有多个回报是必要的，但通常你可以通过至少尝试有一个退出点来简化事情。

这主要是Fortran的遗留问题，在Fortran中，可以将多个语句标签传递给一个函数，这样函数就可以返回其中任何一个。

所以这种代码是完全有效的

       CALL SOMESUB(ARG1, 101, 102, 103)
C Some code
 101   CONTINUE
C Some more code
 102   CONTINUE
C Yet more code
 103   CONTINUE
C You get the general idea

但是被调用的函数决定了你的代码路径。有效率呢?可能。可维护的?不。

这就是该规则的来源(顺便说一下，一个函数没有多个入口点，这在fortran和汇编程序中是可能的，但在C中不可能)。

然而，它的措辞看起来像是可以应用到其他语言(关于多个入口点的那个不能应用到其他语言，所以它不是一个真正的程序)。所以这条规则被保留了下来，即使它指的是一个完全不同的问题，而且不适用。

对于更结构化的语言，需要放弃这个规则，或者至少考虑更多。当然，一个充满返回值的函数很难理解，但在开始时返回不是问题。在一些c++编译器中，如果你只从一个地方返回一个值，那么一个返回点可能会生成更好的代码。

但是最初的规则被误解了，被误用了。也不再相关了。