似乎没有return()更快…

library(rbenchmark)
x <- 1
foo <- function(value) {
  return(value)
}
fuu <- function(value) {
  value
}
benchmark(foo(x),fuu(x),replications=1e7)
    test replications elapsed relative user.self sys.self user.child sys.child
1 foo(x)     10000000   51.36 1.185322     51.11     0.11          0         0
2 fuu(x)     10000000   43.33 1.000000     42.97     0.05          0         0

____EDIT __________________

我继续到其他基准(基准(fuu(x)，foo(x)，复制=1e7))，结果是相反的…我在服务器上试试。

我认为回报是一种诡计。作为一般规则，在函数中求值的最后一个表达式的值成为该函数的值——这种一般模式在许多地方都可以找到。所有这些都是3:

local({
1
2
3
})

eval(expression({
1
2
3
}))

(function() {
1
2
3
})()

return所做的并不是真正返回一个值(不管有没有它)，而是以一种不规则的方式“打破”函数。从这个意义上说，它是R中最接近的GOTO语句(也有break和next)。我很少使用return，而且从不在函数的末尾使用。

 if(a) {
   return(a)
 } else {
   return(b)
 }

．.． 这可以重写为(a) a else b，这是更好的可读性和更少的花括号。在这里根本不需要返回。我使用“return”的典型例子是这样的……

ugly <- function(species, x, y){
   if(length(species)>1) stop("First argument is too long.")
   if(species=="Mickey Mouse") return("You're kidding!")
   ### do some calculations 
   if(grepl("mouse", species)) {
      ## do some more calculations
      if(species=="Dormouse") return(paste0("You're sleeping until", x+y))
      ## do some more calculations
      return(paste0("You're a mouse and will be eating for ", x^y, " more minutes."))
      }
   ## some more ugly conditions
   # ...
   ### finally
   return("The end")
   }

一般来说，对大量回报的需求表明，这个问题要么是丑陋的，要么是结构糟糕的。

(编辑)

Return实际上不需要函数来工作:您可以使用它来拆分一组要求值的表达式。

getout <- TRUE 
# if getout==TRUE then the value of EXP, LOC, and FUN will be "OUTTA HERE"
# .... if getout==FALSE then it will be `3` for all these variables    

EXP <- eval(expression({
   1
   2
   if(getout) return("OUTTA HERE")
   3
   }))

LOC <- local({
   1
   2
   if(getout) return("OUTTA HERE")
   3
   })

FUN <- (function(){
   1
   2
   if(getout) return("OUTTA HERE")
   3
   })()

identical(EXP,LOC)
identical(EXP,FUN)

如果大家都同意

Return在函数体的末尾是不必要的 不使用return稍微快一点(根据@Alan的测试，4.3微秒对5.1微秒)

我们是否应该在函数末尾停止使用return ?我当然不会，我想解释一下原因。我希望听到其他人是否同意我的观点。如果这不是对OP的直接回答，我很抱歉，而更像是一个很长的主观评论。

我不使用return的主要问题是，正如Paul指出的，在函数体的其他地方可能需要它。如果你被迫在函数中间的某个地方使用return，为什么不使所有的return语句显式呢?我讨厌前后矛盾。而且我认为代码读起来更好;你可以扫描这个函数，很容易看到所有的出口点和值。

保罗举了这个例子:

foo = function() {
 if(a) {
   return(a)
 } else {
   return(b)
 }
}

不幸的是，有人可能会指出，它可以很容易地重写为:

foo = function() {
 if(a) {
   output <- a
 } else {
   output <- b
 }
output
}

后一个版本甚至符合一些编程编码标准，提倡每个函数有一个return语句。我认为一个更好的例子是:

bar <- function() {
   while (a) {
      do_stuff
      for (b) {
         do_stuff
         if (c) return(1)
         for (d) {
            do_stuff
            if (e) return(2)
         }
      }
   }
   return(3)
}

用一个return语句重写这要困难得多:它需要多个断点和一个复杂的布尔变量系统来传播它们。所有这些都说明单一返回规则不适用于r。因此，如果你需要在函数体的某些地方使用返回，为什么不保持一致，在所有地方都使用它呢?

我不认为速度的论点是有效的。0.8微秒的差别根本不算什么，当你开始研究真正有功能的函数时。我能看到的最后一件事是打字减少了，但嘿，我不懒。

冗余的争论在这里出现了很多。在我看来，这不足以成为省略return()的理由。 冗余并不一定是坏事。如果有策略地使用冗余，可以使代码更清晰、更可维护。

考虑这个例子:函数参数通常有默认值。因此，指定与默认值相同的值是多余的。但这显然是我所期待的行为。不需要打开函数manpage来提醒自己默认值是什么。而且不用担心该函数的未来版本会改变其默认值。

调用return()的性能损失可以忽略不计(根据其他人在这里发布的基准测试)，这取决于样式，而不是对与错。对于“错误”的东西，需要有一个明显的缺点，这里没有人满意地证明包含或省略return()具有一致的缺点。这似乎是非常具体的案例和用户。

这就是我的立场。

function(){
  #do stuff
  ...
  abcd
}

我对上面例子中的“孤儿”变量感到不舒服。abcd会成为我还没写完的声明的一部分吗?它是我的代码中拼接/编辑的残余，需要删除?我是否不小心从其他地方粘贴/移动了一些东西?

function(){
  #do stuff
  ...
  return(abdc)
}

相比之下，第二个示例使我清楚地看到它是一个预期的返回值，而不是一些意外或不完整的代码。对我来说，这种冗余绝对不是无用的。

当然，一旦函数完成并工作，我可以删除返回。但是删除它本身就是一个多余的额外步骤，在我看来，它比首先包含return()更无用。

综上所述，我没有使用return()作为未命名的单行函数。在函数代码中，它占了很大一部分，因此主要导致视觉上的混乱，使代码更不容易读懂。但是对于更大的正式定义和命名的函数，我使用它，并且可能会继续使用。

我的问题是:为什么不调用返回更快

它更快，因为return是R中的(原语)函数，这意味着在代码中使用它会导致函数调用的代价。与大多数其他编程语言相比，其中return是关键字，而不是函数调用:它不转换为任何运行时代码执行。

也就是说，在R中以这种方式调用原语函数非常快，并且调用return的开销非常小。这不是省略return的理由。

还是更好，因此更可取?

因为没有理由使用它。

因为它是冗余的，它没有增加有用的冗余。

需要明确的是:冗余有时是有用的。但大多数冗余都不是这样的。相反，它是那种在不增加信息的情况下增加视觉混乱的东西:它相当于一个填充词或图表垃圾)。

考虑下面的解释性注释的例子，它被普遍认为是糟糕的冗余，因为注释只是解释了代码已经表达的内容:

# Add one to the result
result = x + 1

在R中使用return也属于同一类别，因为R是一种函数式编程语言，在R中每个函数调用都有一个值。这是R的一个基本属性，一旦你从每个表达式(包括每个函数调用)都有一个值的角度看R代码，问题就变成了:“为什么我要使用return?”需要有一个积极的理由，因为默认是不使用它。

其中一个积极的原因是在一个guard子句中提早退出函数:

f = function (a, b) {
    if (! precondition(a)) return() # same as `return(NULL)`!
    calculation(b)
}

这是一个有效的、非冗余的return用法。然而，与其他语言相比，这样的保护子句在R中很少，而且由于每个表达式都有一个值，正则if不需要return:

sign = function (num) {
    if (num > 0) {
        1
    } else if (num < 0) {
        -1
    } else {
        0
    }
}

我们甚至可以这样重写f:

f = function (a, b) {
    if (precondition(a)) calculation(b)
}

这里if (cond) expr与if (cond) expr else NULL相同。

最后，我想先说三个常见的反对意见:

Some people argue that using return adds clarity, because it signals “this function returns a value”. But as explained above, every function returns something in R. Thinking of return as a marker of returning a value isn’t just redundant, it’s actively misleading. Relatedly, the Zen of Python has a marvellous guideline that should always be followed: Explicit is better than implicit. How does dropping redundant return not violate this? Because the return value of a function in a functional language is always explicit: it’s its last expression. This is again the same argument about explicitness vs redundancy. In fact, if you want explicitness, use it to highlight the exception to the rule: mark functions that don’t return a meaningful value, which are only called for their side-effects (such as cat). Except R has a better marker than return for this case: invisible. For instance, I would write save_results = function (results, file) { # … code that writes the results to a file … invisible() } But what about long functions? Won’t it be easy to lose track of what is being returned? Two answers: first, not really. The rule is clear: the last expression of a function is its value. There’s nothing to keep track of. But more importantly, the problem in long functions isn’t the lack of explicit return markers. It’s the length of the function. Long functions almost (?) always violate the single responsibility principle and even when they don’t they will benefit from being broken apart for readability.

似乎没有return()更快…

library(rbenchmark)
x <- 1
foo <- function(value) {
  return(value)
}
fuu <- function(value) {
  value
}
benchmark(foo(x),fuu(x),replications=1e7)
    test replications elapsed relative user.self sys.self user.child sys.child
1 foo(x)     10000000   51.36 1.185322     51.11     0.11          0         0
2 fuu(x)     10000000   43.33 1.000000     42.97     0.05          0         0

____EDIT __________________

我继续到其他基准(基准(fuu(x)，foo(x)，复制=1e7))，结果是相反的…我在服务器上试试。