Error handling (tryCatch) in R Programming - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of tryCatch in R?

tryCatch is used to handle errors and warnings in R code gracefully. It lets you run code and catch errors or warnings to prevent the program from stopping unexpectedly.

beginner

What are the main components of a tryCatch block?

The main parts are:

• try: The code you want to run.
• error: A function to run if an error happens.
• warning: A function to run if a warning happens.
• finally: Code that runs no matter what.

intermediate

How do you catch an error and return a custom message using tryCatch?

result <- tryCatch({
  stop("Oops, an error!")
}, error = function(e) {
  "Custom error caught"
})
print(result)  # Prints: Custom error caught

beginner

What happens if no error occurs inside tryCatch?

If no error happens, the code inside tryCatch runs normally and returns its result. The error handler is ignored.

intermediate

Why use finally in tryCatch?

finally runs code after the main code and error/warning handlers, no matter what. It's useful for cleanup tasks like closing files or releasing resources.

What does tryCatch do in R?

A Creates plots

B Runs code faster

C Handles errors and warnings without stopping the program

D Reads data files

tryCatch is designed to catch errors and warnings so the program can continue running smoothly.

Which argument in tryCatch handles errors?

A warning

B error

C finally

D try

The error argument specifies what to do if an error occurs.

What will tryCatch return if no error occurs?

A A warning message

B NULL

C An error message

D The result of the code inside <code>tryCatch</code>

If no error happens, tryCatch returns the normal result of the code it runs.

What is the purpose of the finally block in tryCatch?

A To run code regardless of errors or warnings

B To run code only if an error occurs

C To stop the program

D To catch warnings

finally runs code no matter what happens, useful for cleanup.

How do you define an error handler in tryCatch?

A error = function(e) { ... }

B try = function(e) { ... }

C catch = function(e) { ... }

D handle = function(e) { ... }

The error handler is defined as error = function(e) { ... } inside tryCatch.

Explain how tryCatch helps manage errors in R programs.

Think about what happens when your code breaks and how to handle it smoothly.

Describe the roles of error, warning, and finally in a tryCatch block.

Consider what each part does when something goes wrong or after code runs.

Practice

1. What is the main purpose of using tryCatch in R?

easy

A. To print messages to the console

B. To speed up the execution of loops

C. To handle errors and warnings without stopping the program

D. To create new variables automatically

Solution

1. Step 1: Understand the role of tryCatch

   tryCatch is designed to catch errors and warnings during code execution.

2. Step 2: Identify the effect on program flow

   It prevents the program from stopping abruptly by handling these issues gracefully.

3. Final Answer:

   To handle errors and warnings without stopping the program -> Option C

4. Quick Check:

   Error handling = To handle errors and warnings without stopping the program [OK]

Hint: tryCatch catches errors so program keeps running [OK]

Common Mistakes:

• Thinking tryCatch speeds up code
• Confusing tryCatch with printing functions
• Assuming tryCatch creates variables

2. Which of the following is the correct syntax to catch an error using tryCatch in R?

easy

A. tryCatch(expr, except = function(e) { print('Error caught') })

B. tryCatch(expr, catch = function(e) { print('Error caught') })

C. tryCatch(expr, onError = function(e) { print('Error caught') })

D. tryCatch(expr, error = function(e) { print('Error caught') })

Solution

1. Step 1: Recall tryCatch argument names

   The correct argument to catch errors is error, not catch, onError, or except.

2. Step 2: Match syntax with correct argument

   tryCatch(expr, error = function(e) { print('Error caught') }) uses error = function(e) { ... } which is the proper syntax.

3. Final Answer:

   tryCatch(expr, error = function(e) { print('Error caught') }) -> Option D

4. Quick Check:

   Correct error argument = tryCatch(expr, error = function(e) { print('Error caught') }) [OK]

Hint: Use error= for catching errors in tryCatch [OK]

Common Mistakes:

• Using catch or except instead of error
• Misspelling the argument name
• Not wrapping the handler in a function

3. What will be the output of the following R code?

result <- tryCatch({
  log(-1)
}, warning = function(w) {
  'Warning caught'
}, error = function(e) {
  'Error caught'
})
print(result)

medium

A. Warning caught

B. Error caught

C. NaN

D. log(-1)

Solution

1. Step 1: Understand log(-1) behavior

   Calling log(-1) produces a warning (NaNs produced) but does not cause an error.

2. Step 2: Check which handler runs

   The warning handler returns 'Warning caught', so result will be 'Warning caught'.

3. Final Answer:

   Warning caught -> Option A

4. Quick Check:

   log(-1) triggers warning = Warning caught [OK]

Hint: log(-1) warns, so warning handler runs [OK]

Common Mistakes:

• Thinking log(-1) causes error
• Expecting NaN as output instead of handler return
• Confusing warning and error handlers

4. Identify the error in this tryCatch usage:

tryCatch({
  sqrt('a')
}, error = function(e) {
  print('Error handled')
})

medium

A. Missing closing parenthesis for tryCatch

B. Incorrect error handler function syntax

C. Using print inside error handler is not allowed

D. No error will occur in this code

Solution

1. Step 1: Check syntax completeness

   The tryCatch call is missing the closing parenthesis at the end.

2. Step 2: Verify other parts

   The error handler function syntax and use of print are correct; sqrt('a') causes an error.

3. Final Answer:

   Missing closing parenthesis for tryCatch -> Option A

4. Quick Check:

   Syntax error = Missing closing parenthesis [OK]

Hint: Count parentheses carefully in tryCatch calls [OK]

Common Mistakes:

• Assuming print is invalid in handler
• Thinking no error occurs with sqrt('a')
• Ignoring missing parentheses

5. You want to run a function that might give a warning or error, but always print "Done" at the end. Which tryCatch structure achieves this?

hard

A. tryCatch(expr, error = function(e) { print('Done') }, warning = function(w) { print('Done') })

B. tryCatch(expr, error = function(e) {}, warning = function(w) {}, finally = { print('Done') })

C. tryCatch(expr, error = function(e) {}, warning = function(w) {}, finally = print('Done'))

D. tryCatch(expr, error = function(e) {}, warning = function(w) {}, finally = function() { print('Done') })

Solution

1. Step 1: Understand finally argument type

   The finally argument expects an expression wrapped in braces, not a function or direct call.

2. Step 2: Compare options

   tryCatch(expr, error = function(e) {}, warning = function(w) {}, finally = { print('Done') }) correctly uses finally = { print('Done') } which runs after tryCatch regardless of error or warning.

3. Final Answer:

   tryCatch(expr, error = function(e) {}, warning = function(w) {}, finally = { print('Done') }) -> Option B

4. Quick Check:

   finally needs braces with expression = tryCatch(expr, error = function(e) {}, warning = function(w) {}, finally = { print('Done') }) [OK]

Hint: Use finally = { expr } to run code always after tryCatch [OK]

Common Mistakes:

• Using finally as a function instead of expression
• Passing print() directly without braces
• Omitting finally block when needed