Error handling (tryCatch) in R Programming - Mini Project: Build & Apply

Error handling with tryCatch in R

📖 Scenario: Imagine you are writing a small R program that divides numbers. Sometimes, the divisor might be zero, which causes an error. You want to handle this error gracefully so your program doesn't stop unexpectedly.

🎯 Goal: You will create a program that divides two numbers and uses tryCatch to handle division by zero errors by showing a friendly message instead of stopping.

📋 What You'll Learn

Create two numeric variables named numerator and denominator with exact values

Create a variable named result to store the division result

Use tryCatch to catch division errors

Print the result or an error message

💡 Why This Matters

🌍 Real World

Handling errors like division by zero is important in data analysis and scientific computing to avoid program crashes.

💼 Career

Error handling is a key skill for data scientists and programmers to write robust and user-friendly code.

1

Create numerator and denominator variables

Create a numeric variable called numerator and set it to 10. Create another numeric variable called denominator and set it to 0.

R Programming

# Create numerator and denominator variables
# Your code here

Hint

Use the assignment operator <- to create variables.

2

Create a result variable with default value

Create a variable called result and set it to NA to hold the division result before calculation.

R Programming

numerator <- 10
denominator <- 0
# Create a variable called result and set it to NA
# Your code here

Hint

Use NA to represent a missing value in R.

3

Use tryCatch to perform division safely

Use tryCatch to divide numerator by denominator and assign the result to result. If an error occurs, assign the string "Error: Division by zero" to result.

R Programming

numerator <- 10
denominator <- 0
result <- NA
# Use tryCatch to divide numerator by denominator safely
# Your code here

Hint

Inside tryCatch, put the division expression in the first argument, and define an error function that returns the error message string.

4

Print the result

Write a print statement to display the value of result.

R Programming

numerator <- 10
denominator <- 0
result <- NA
result <- tryCatch({
  numerator / denominator
}, error = function(e) {
  "Error: Division by zero"
})
# Print the result
# Your code here

Hint

Use print(result) to show the output.

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