Error handling (tryCatch) in R Programming - Step-by-Step Execution

Concept Flow - Error handling (tryCatch)

Start

↓

Try block runs

↓

Error?

No→Try block finishes normally

Yes↓

Catch error handler runs

↓

Finally block runs (optional)

↓

End

The program tries to run code in the try block. If an error happens, it jumps to the catch block. Finally block runs at the end no matter what.

Execution Sample

R Programming

result <- tryCatch({
  log(-1)
}, error = function(e) {
  "Error caught"
})

This code tries to compute log(-1), which causes an error, then catches it and returns "Error caught".

Execution Table

Step	Action	Evaluation	Result
1	Enter tryCatch, run try block	log(-1)	Error (domain error)
2	Error detected in try block	Error triggered	Jump to error handler
3	Run error handler function	function(e) returns "Error caught"	"Error caught"
4	tryCatch returns error handler result	return value	"Error caught"

💡 Error in log(-1) triggers error handler, which returns "Error caught" stopping error propagation.

Variable Tracker

Variable	Start	After try block	After error handler	Final
result	undefined	error triggered	"Error caught"	"Error caught"

Key Moments - 3 Insights

Why doesn't the program stop when log(-1) causes an error?

Because tryCatch catches the error at step 2 and runs the error handler instead of stopping the program.

What does the error handler function return?

It returns the string "Error caught" as shown in step 3 and 4 of the execution table.

What if there was no error handler provided?

The error would stop the program and show an error message instead of returning a value.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of 'result' after the error handler runs?

A "Error caught"

B NaN

C log(-1)

D NULL

💡 Hint

Check the 'After error handler' and 'Final' columns in variable_tracker and step 3 in execution_table.

At which step does the program jump to the error handler?

A Step 1

B Step 3

C Step 2

D Step 4

💡 Hint

Look at the 'Error detected in try block' row in execution_table.

If the try block code was log(10) instead of log(-1), what would happen?

A tryCatch returns NaN

B tryCatch returns log(10) value without error

C Error handler runs and returns "Error caught"

D Program stops with error

💡 Hint

Think about what happens when no error occurs in the try block (step 1 and 2).

Concept Snapshot

tryCatch({ try_code }, error = function(e) { handler })
- Runs try_code
- If error occurs, runs handler function
- Returns handler result or try_code result
- Prevents program crash on errors
- Useful for safe error handling

Full Transcript

This example shows how tryCatch in R handles errors. The code tries to compute log(-1), which causes an error. Instead of stopping, tryCatch catches the error and runs the error handler function, which returns the string "Error caught". This result is assigned to the variable result. The flow is: start tryCatch, run try block, detect error, jump to error handler, run handler, return handler result, end. Variables change from undefined to error triggered to "Error caught". This prevents the program from crashing and allows graceful error handling.

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