Error handling (tryCatch) in R Programming - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to catch errors using tryCatch.

R Programming

result <- tryCatch({
  log('a')
}, error = function(e) {
  [1]
})

Drag options to blanks, or click blank then click option'

Awarning('Error caught!')

Blog(1)

Cprint('Error caught!')

Dstop('Error caught!')

Attempts:

3 left

💡 Hint

Common Mistakes

Using stop() inside the error handler will re-throw the error.

Not defining a function for the error argument.

Using warning() instead of print() does not stop the error.

The error argument in tryCatch defines a function to run when an error occurs. Using print('Error caught!') will display the message when the error happens.

2fill in blank

medium

Complete the code to return a default value when an error occurs.

R Programming

safe_log <- function(x) {
  tryCatch(log(x), error = function(e) [1])
}

safe_log('a')

Drag options to blanks, or click blank then click option'

AInf

BNULL

C0

DNA

Attempts:

3 left

💡 Hint

Common Mistakes

Returning NULL can cause issues if the caller expects a numeric value.

Returning 0 or Inf may mislead the user about the result.

Returning NA is a common way to indicate a missing or invalid result when an error occurs.

3fill in blank

hard

Fix the error in the tryCatch usage to properly handle warnings.

R Programming

result <- tryCatch({
  sqrt(-1)
}, warning = function(w) {
  [1]
})

Drag options to blanks, or click blank then click option'

Aprint('Warning caught!')

Bstop('Warning caught!')

Creturn(NA)

Dmessage('Warning caught!')

Attempts:

3 left

💡 Hint

Common Mistakes

Using stop() inside warning handler re-throws the warning as an error.

Using message() may not be visible depending on console settings.

The warning handler function should print a message or handle the warning gracefully. Using print('Warning caught!') shows the warning was caught.

4fill in blank

hard

Fill both blanks to catch errors and return a message.

R Programming

result <- tryCatch({
  log('a')
}, error = function(e) {
  [1]
}, finally = {
  [2]
})

Drag options to blanks, or click blank then click option'

Areturn('Error handled')

Bprint('Cleaning up')

Cstop('Error handled')

Dmessage('Cleaning up')

Attempts:

3 left

💡 Hint

Common Mistakes

Using stop() in error handler re-throws the error.

Using message() in finally may not always show output.

The error handler returns a message string. The finally block runs cleanup code, here printing a message.

5fill in blank

hard

Fill all three blanks to catch errors, warnings, and run final code.

R Programming

result <- tryCatch({
  log(-10)
}, error = function(e) {
  [1]
}, warning = function(w) {
  [2]
}, finally = {
  [3]
})

Drag options to blanks, or click blank then click option'

Areturn(NA)

Bprint('Warning caught')

Cprint('Cleaning up')

Dstop('Error caught')

Attempts:

3 left

💡 Hint

Common Mistakes

Using stop() in error handler causes the program to stop.

Not printing messages in warning or finally blocks hides useful info.

The error handler returns NA to handle errors gracefully. The warning handler prints a message. The finally block prints a cleanup message.

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