如何重试错误声明？

Question

如果错误,我怎么能简单地告诉R重试一次语句？我希望做的事情如下:

tryCatch(dbGetQuery(...),           # Query database
    error = function(e) {
        if (is.locking.error(e))    # If database is momentarily locked
            retry(times = 3)        # retry dbGetQuery(...) 3 more times
        else {
            # Handle other errors
        }
    }
)

Answer 1

我通常将try块放在一个循环中,当它不再失败或达到最大尝试次数时退出循环.

some_function_that_may_fail <- function() {
  if( runif(1) < .5 ) stop()
  return(1)
}

r <- NULL
attempt <- 1
while( is.null(r) && attempt <= 3 ) {
  attempt <- attempt + 1
  try(
    r <- some_function_that_may_fail()
  )
} 

Answer 2

我编写了一个快速函数,允许您轻松地重试操作可配置的次数,并在尝试之间进行可配置的等待:

library(futile.logger)
library(utils)

retry <- function(expr, isError=function(x) "try-error" %in% class(x), maxErrors=5, sleep=0) {
  attempts = 0
  retval = try(eval(expr))
  while (isError(retval)) {
    attempts = attempts + 1
    if (attempts >= maxErrors) {
      msg = sprintf("retry: too many retries [[%s]]", capture.output(str(retval)))
      flog.fatal(msg)
      stop(msg)
    } else {
      msg = sprintf("retry: error in attempt %i/%i [[%s]]", attempts, maxErrors, 
                    capture.output(str(retval)))
      flog.error(msg)
      warning(msg)
    }
    if (sleep > 0) Sys.sleep(sleep)
    retval = try(eval(expr))
  }
  return(retval)
}

因此,您可以写入val = retry(func_that_might_fail(param1, param2), maxErrors=10, sleep=2)重试使用这些参数重试该函数,在10次错误后放弃,并在尝试之间休眠2秒.

此外,您可以通过将不同的函数作为参数传递来重新定义错误的含义,isError默认情况下将捕获用信号通知的错误stop.如果被调用的函数在出错时执行其他操作(例如返回FALSE或),这将非常有用NULL.

到目前为止,这是我发现的替代方案,可以产生更清晰,更易读的代码.

希望这可以帮助.

Answer 3

没有预先分配值并使用for而不是使用的解决方案while:

some_function_that_may_fail <- function(i) {
  if( runif(1) < .5 ) stop()
  return(i)
}

for(i in 1:10){
  try({
    r <- some_function_that_may_fail(i)
    break #break/exit the for-loop
  }, silent = FALSE)
}

r将等于所需的尝试次数.如果您不希望将错误的输出设置silent为TRUE

Answer 4

这是一个生成自定义条件以响应的函数

locked <- function(message="occurred", ...) {
    cond <- simpleCondition(message, ...)
    class(cond) <- c("locked", class(cond))
    cond
}

和一个允许(无限次)重启的功能

f <- function() {
    cnt <- 0L
    repeat {
        again <- FALSE
        cnt <- cnt + 1L
        withRestarts({
            ## do work here, and if needed...
            signalCondition(locked())
        }, retry=function() {
            again <<- TRUE
        })
        if (!again) break
    }
    cnt
}

并且使用withCallingHandlers(以保持条件被发信号的上下文不同于tryCatch)来处理locked条件

withCallingHandlers({
    n_tries <- 0L
    f()
}, locked=function(e) {
    n_tries <<- n_tries + 1L
    if (n_retries < 3)
        invokeRestart("retry")
})

Answer 5

我已将代码放在一起并将其打包：重试

f <- function(x) {
    if (runif(1) < 0.9) {
        stop("random error")
    }
    x + 1
}

# keep retring when there is a random error
retry::retry(f(1), when = "random error")
#> [1] 2
# keep retring until a requirement is satisified.
retry::retry(f(1), until = function(val, cnd) val == 2)
#> [1] 2
# or using one sided formula
retry::retry(f(1), until = ~ . == 2, max_tries = 10)
#> [1] 2