How to use the tryCatch() function?

tryCatch has a slightly complex syntax structure. However, once we understand the 4 parts which constitute a complete tryCatch call as shown below, it becomes easy to remember:

expr: [Required] R code(s) to be evaluated

error : [Optional] What should run if an error occured while evaluating the codes in expr

warning : [Optional] What should run if a warning occured while evaluating the codes in expr

finally : [Optional] What should run just before quitting the tryCatch call, irrespective of if expr ran successfully, with an error, or with a warning

tryCatch(
    expr = {
        # Your code...
        # goes here...
        # ...
    },
    error = function(e){ 
        # (Optional)
        # Do this if an error is caught...
    },
    warning = function(w){
        # (Optional)
        # Do this if a warning is caught...
    },
    finally = {
        # (Optional)
        # Do this at the end before quitting the tryCatch structure...
    }
)

Thus, a toy example, to calculate the log of a value might look like:

log_calculator <- function(x){
    tryCatch(
        expr = {
            message(log(x))
            message("Successfully executed the log(x) call.")
        },
        error = function(e){
            message('Caught an error!')
            print(e)
        },
        warning = function(w){
            message('Caught an warning!')
            print(w)
        },
        finally = {
            message('All done, quitting.')
        }
    )    
}

Now, running three cases:

A valid case

log_calculator(10)
# 2.30258509299405
# Successfully executed the log(x) call.
# All done, quitting.

A "warning" case

log_calculator(-10)
# Caught an warning!
# <simpleWarning in log(x): NaNs produced>
# All done, quitting.

An "error" case

log_calculator("log_me")
# Caught an error!
# <simpleError in log(x): non-numeric argument to mathematical function>
# All done, quitting.

I've written about some useful use-cases which I use regularly. Find more details here: Using tryCatch for robust R scripts

Hope this is helpful.

R uses functions for implementing try-catch block:

The syntax somewhat looks like this:

result = tryCatch({
    expr
}, warning = function(warning_condition) {
    warning-handler-code
}, error = function(error_condition) {
    error-handler-code
}, finally={
    cleanup-code
})

In tryCatch() there are two ‘conditions’ that can be handled: ‘warnings’ and ‘errors’. The important thing to understand when writing each block of code is the state of execution and the scope. @source

Here goes a straightforward example:

# Do something, or tell me why it failed
my_update_function <- function(x){
    tryCatch(
        # This is what I want to do...
        {
        y = x * 2
        return(y)
        },
        # ... but if an error occurs, tell me what happened: 
        error=function(error_message) {
            message("This is my custom message.")
            message("And below is the error message from R:")
            message(error_message)
            return(NA)
        }
    )
}

If you also want to capture a "warning", just add warning= similar to the error= part.

Since I just lost two days of my life trying to solve for tryCatch for an irr function, I thought I should share my wisdom (and what is missing). FYI - irr is an actual function from FinCal in this case where got errors in a few cases on a large data set.

1. Set up tryCatch as part of a function. For example:

   irr2 <- function (x) {
     out <- tryCatch(irr(x), error = function(e) NULL)
     return(out)
   }
   

2. For the error (or warning) to work, you actually need to create a function. I originally for error part just wrote error = return(NULL) and ALL values came back null.

3. Remember to create a sub-output (like my "out") and to return(out).

The purrr package gives alternate functions that can be friendlier to set up than tryCatch. From the ?safely documentation, they are described as:

• safely: wrapped function instead returns a list with components result and error. If an error occurred, error is an error object and result has a default value (otherwise). Else error is NULL.

• quietly: wrapped function instead returns a list with components result, output, messages and warnings.

• possibly: wrapped function uses a default value (otherwise) whenever an error occurs.

Note that these functions, unlike tryCatch(), are expected to wrap a function, not an expression, and they return a modified function. For OP's problem as stated, we would probably use possibly and wrap readLines directly to modify it.

url <- c(
    "http://stat.ethz.ch/R-manual/R-devel/library/base/html/connections.html",
    "http://en.wikipedia.org/wiki/Xz", 
    "xxx")

library(purrr)
lapply(url, possibly(readLines, otherwise = "web URL is wrong, can't get"))
## with possibly, the error prints as a warning
## and the final value is the `otherwise` string

But also note that we could create a modified version of readLines, such as try_readLines <- possibly(readLines, otherwise = "web URL is wrong, can't get") that could be used in multiple places in our code.

I illustrate with possibly above, but we could easily imagine cases where we would want to use safely() (after which we could extract the result component from each list item, possibly skipping or otherwise handling items with a non-empty error component, perhaps even handling them differently based on the error), or quietly which also captures warnings and messages separately.