How to write trycatch in R

Question

I want to write trycatch code to deal with error in downloading from the web.

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

These two statements run successfully. Below, I create a non-exist web address:

url <- c("xxxxx", "http://en.wikipedia.org/wiki/Xz")

url[1] does not exist. How does one write a trycatch loop (function) so that:

When the URL is wrong, the output will be: "web URL is wrong, can't get".
When the URL is wrong, the code does not stop, but continues to download until the end of the list of URLs?

score 730 · Accepted Answer · edited Dec 09 '20 at 20:51

Well then: welcome to the R world ;-)

Here you go

Setting up the code

urls <- c(
    "http://stat.ethz.ch/R-manual/R-devel/library/base/html/connections.html",
    "http://en.wikipedia.org/wiki/Xz",
    "xxxxx"
)
readUrl <- function(url) {
    out <- tryCatch(
        {
            # Just to highlight: if you want to use more than one 
            # R expression in the "try" part then you'll have to 
            # use curly brackets.
            # 'tryCatch()' will return the last evaluated expression 
            # in case the "try" part was completed successfully

            message("This is the 'try' part")

            readLines(con=url, warn=FALSE) 
            # The return value of `readLines()` is the actual value 
            # that will be returned in case there is no condition 
            # (e.g. warning or error). 
            # You don't need to state the return value via `return()` as code 
            # in the "try" part is not wrapped inside a function (unlike that
            # for the condition handlers for warnings and error below)
        },
        error=function(cond) {
            message(paste("URL does not seem to exist:", url))
            message("Here's the original error message:")
            message(cond)
            # Choose a return value in case of error
            return(NA)
        },
        warning=function(cond) {
            message(paste("URL caused a warning:", url))
            message("Here's the original warning message:")
            message(cond)
            # Choose a return value in case of warning
            return(NULL)
        },
        finally={
        # NOTE:
        # Here goes everything that should be executed at the end,
        # regardless of success or error.
        # If you want more than one expression to be executed, then you 
        # need to wrap them in curly brackets ({...}); otherwise you could
        # just have written 'finally=<expression>' 
            message(paste("Processed URL:", url))
            message("Some other message at the end")
        }
    )    
    return(out)
}

Applying the code

> y <- lapply(urls, readUrl)
Processed URL: http://stat.ethz.ch/R-manual/R-devel/library/base/html/connections.html
Some other message at the end
Processed URL: http://en.wikipedia.org/wiki/Xz
Some other message at the end
URL does not seem to exist: xxxxx
Here's the original error message:
cannot open the connection
Processed URL: xxxxx
Some other message at the end
Warning message:
In file(con, "r") : cannot open file 'xxxxx': No such file or directory

Investigating the output

> head(y[[1]])
[1] "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">"      
[2] "<html><head><title>R: Functions to Manipulate Connections</title>"      
[3] "<meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\">"
[4] "<link rel=\"stylesheet\" type=\"text/css\" href=\"R.css\">"             
[5] "</head><body>"                                                          
[6] ""    

> length(y)
[1] 3

> y[[3]]
[1] NA

Additional remarks

tryCatch

tryCatch returns the value associated to executing expr unless there's an error or a warning. In this case, specific return values (see return(NA) above) can be specified by supplying a respective handler function (see arguments error and warning in ?tryCatch). These can be functions that already exist, but you can also define them within tryCatch() (as I did above).

The implications of choosing specific return values of the handler functions

As we've specified that NA should be returned in case of error, the third element in y is NA. If we'd have chosen NULL to be the return value, the length of y would just have been 2 instead of 3 as lapply() will simply "ignore" return values that are NULL. Also note that if you don't specify an explicit return value via return(), the handler functions will return NULL (i.e. in case of an error or a warning condition).

"Undesired" warning message

As warn=FALSE doesn't seem to have any effect, an alternative way to suppress the warning (which in this case isn't really of interest) is to use

suppressWarnings(readLines(con=url))

instead of

readLines(con=url, warn=FALSE)

Multiple expressions

Note that you can also place multiple expressions in the "actual expressions part" (argument expr of tryCatch()) if you wrap them in curly brackets (just like I illustrated in the finally part).

Given that the first string in your `paste` functions ends with a space, why not omit the space and the `sep=""`? — seancarmody, Aug 30 '12 at 11:56
@seancarmody: true ;-) I'm just so used to putting together longer/more complicated strings were I have to control spaces via actually writing them out. — Rappster, Aug 30 '12 at 12:00
`paste0()` *is* in base. Internally, both `paste()` and `paste0()` call `do_paste` in [paste.c](http://svn.r-project.org/R/trunk/src/main/paste.c). The only difference is `paste0()` does not pass a `sep` argument. — jthetzel, Aug 30 '12 at 14:04
@jthetzel + @seancarmody: sorry, true for R-2.15.1. I was running an outdated version of R (2.14.1) and back then there wasn't such a function. Very nice, IMHO that should have been the default behavior of `paste` right from the beginning — Rappster, Aug 30 '12 at 14:28
is `out` will be `NULL` if a `warning` is issued in the `tryCatch` in your example? — RNA, Feb 11 '14 at 00:41
@RNA: actually, I think that's a little mistake in my code as there is no `out` defined in the scope of the `warning` function. Just by looking at it, I'm not sure what R will take as the value for `out` via lexical scoping. I'll check — Rappster, Feb 11 '14 at 17:04
@RNA: updated the answer. If you don't supply anything explicitly, the handler functions will return `NULL`. Returning `out` in the warning case didn't make any sense to me anyomre, so I changed it to `return(NULL)` just for illustrative purposes. Hope it's clear now. — Rappster, Feb 11 '14 at 17:13
@Rappster: yeah, thanks. and could you explain the last line `return (out)`too? Isn't this similar situation to the `return` in the warning function? — RNA, Feb 11 '14 at 18:28
I was wondering why my `error` bit was always being executed - curly braces fixed it! — Matthew Wise, Jul 02 '14 at 09:24
How can I display a message if the try part was completed successfully please ? — Julien Navarre, Apr 23 '15 at 12:02
@JulienNavarre: remember that the "try part" always returns the **last** object (currently `readLines(con=url, warn=FALSE)` which is the actual thing that could go wrong). So if you wanted to add a message, you would would need to stored the actual retun value in a variable: `out — Rappster, Apr 23 '15 at 12:28
How to preserve information on what went wrong? error = function(cond) { message(cond) } does not return the same amount of information that shows up without a trycatch. Anybody face this issue? How to print information of the line that caused the error. — user1198407, May 06 '15 at 23:08
Try `conditionMessage (cond)`. That's the actual error message as a character string. — Rappster, May 06 '15 at 23:12
Fantastic example and well documented. May I request all commenters on frivolous questions like `paste` / `paste0` to be deleted so that we do not crowd this section with irrelevant stuff? Thanks. — Lazarus Thurston, Jan 31 '20 at 12:08
Is there a (nice) way to use the same functionality for both "warning" and "error" case? Or do I have to replicate the code? — dpelisek, Oct 23 '20 at 07:30

Rahul · Answer 2 · 2018-12-22T04:02:02.723

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 an 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: https://rsangole.netlify.com/post/try-catch/

Hope this is helpful.

heretolearn · Answer 3 · 2017-08-28T11:19:39.250

79

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

edited Aug 28 '17 at 11:19

answered Aug 30 '12 at 09:34

heretolearn

5,191
3
26
47

5

Replace `error-handler-code` with `cat("web url is wrong, can't get")` – seancarmody Aug 30 '12 at 10:03
2

you left out message-catching – rawr Dec 15 '15 at 21:37

Paul · Answer 4 · 2019-04-02T22:43:29.063

47

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.

edited Apr 02 '19 at 22:43

answered Apr 13 '17 at 00:25

Paul

2,853
22
27

1

Should there be curly brackets around the `expr` part, since there are two lines instead of one? – Paul Aug 14 '18 at 21:22
Thanks! After double checking, I don't see any need for curly brackets – Paul Aug 15 '18 at 17:49
Thanks for double checking. When I run your code, I got `Error: unexpected ')' in " )"` and `Error: unexpected ')' in " )"`. Adding a pair of curly brackets solves the problem. – Paul Aug 15 '18 at 21:46
For most use cases, you are right, thank you! It has been fixed. – Paul Nov 10 '18 at 19:13

score 29 · Answer 5 · edited Sep 26 '16 at 10:47

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.

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

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

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.
Remember to create a sub-output (like my "out") and to return(out).

4

Why is number 3 necessary? – jan-glx Dec 21 '17 at 09:59

How to write trycatch in R

5 Answers5

Setting up the code

Applying the code

Investigating the output

Additional remarks

Linked

Related