Error handling (tryCatch) in R Programming - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this tryCatch example?

Consider the following R code using tryCatch. What will be printed when it runs?

R Programming

result <- tryCatch({
  stop("Error happened")
  10
}, error = function(e) {
  "Caught error"
})
print(result)

A [1] 10

B NULL

C Error in stop("Error happened"): Error happened

D [1] "Caught error"

💡 Hint

Remember that stop() causes an error and tryCatch handles it.

The stop() function triggers an error, so the error handler runs and returns "Caught error". The print shows this string.

❓ Predict Output

intermediate

What does this tryCatch return when no error occurs?

Look at this R code. What is the value of 'result' after running?

R Programming

result <- tryCatch({
  5 + 3
}, error = function(e) {
  0
})
print(result)

A Error in 5 + 3 : non-numeric argument to binary operator

B [1] 0

C [1] 8

D NULL

💡 Hint

No error is triggered in the expression 5 + 3.

Since 5 + 3 runs without error, tryCatch returns 8 directly.

❓ Predict Output

advanced

What error does this code raise?

What error message will this R code produce?

R Programming

tryCatch({
  log("a")
}, error = function(e) {
  stop("Custom error")
})

A Error: Custom error

B Warning message: In log("a") : NaNs produced

C NULL

D Error in log("a"): non-numeric argument to mathematical function

💡 Hint

The error handler re-throws a new error with stop().

The original error is caught, but the handler calls stop() with "Custom error", so that error is raised.

🧠 Conceptual

advanced

Which option correctly catches warnings with tryCatch?

You want to catch warnings in R using tryCatch. Which code snippet correctly catches a warning?

A tryCatch({ warning("Watch out!") }, warning = function(w) { print("Warning caught") })

B tryCatch({ warning("Watch out!") }, error = function(e) { print("Warning caught") })

C tryCatch({ warning("Watch out!") }, finally = function(f) { print("Warning caught") })

D tryCatch({ warning("Watch out!") }, message = function(m) { print("Warning caught") })

💡 Hint

Use the 'warning' argument to catch warnings.

The warning argument in tryCatch handles warnings. Others like error or message do not catch warnings.

🔧 Debug

expert

Why does this tryCatch not catch the error?

This R code does not catch the error as expected. What is the reason?

R Programming

tryCatch({
  stop("Fail")
}, warning = function(w) {
  print("Warning caught")
})

A stop() does not generate an error, so tryCatch does nothing.

B The error handler is missing; only warning handler is defined, so error is not caught.

C The warning handler catches errors too, so this should work.

D tryCatch requires a finally block to catch errors.

💡 Hint

stop() triggers an error, not a warning.

tryCatch only catches errors if an error handler is provided. Here only warning handler is given, so error is not caught and stops execution.

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