Error handling and logging in Deno

Introduction

Error handling helps your program deal with problems without crashing. Logging records what happens so you can understand and fix issues.

When your program might fail due to bad input or missing files.

When you want to keep track of important events or errors in your app.

When debugging to find out what went wrong and where.

When running long tasks and you want to monitor progress or problems.

When you want to create reports about your program's health.

Syntax

Deno

try {
  // code that might fail
} catch (error) {
  console.error("Error message", error);
}

// Logging example
console.log("Informational message");
console.warn("Warning message");
console.error("Error message");

Use try...catch to catch errors and prevent crashes.

Use console.log, console.warn, and console.error to write messages to the console.

Examples

Try to parse JSON and log the name. If parsing fails, catch the error and log it.

Deno

try {
  const data = JSON.parse('{"name":"Deno"}');
  console.log(data.name);
} catch (error) {
  console.error("Failed to parse JSON", error);
}

Shows different levels of logging: info, warning, and error.

Deno

console.log("Starting the app...");
console.warn("This is a warning message.");
console.error("This is an error message.");

Sample Program

This program tries to read a config file and parse it. If the file is missing or JSON is bad, it logs an error message.

Deno

try {
  const text = Deno.readTextFileSync("./config.json");
  const config = JSON.parse(text);
  console.log("Config loaded:", config);
} catch (error) {
  console.error("Error loading config:", error.message);
}

Important Notes

Always catch errors when working with files or external data.

Use clear and helpful messages in logs to make debugging easier.

Logging can slow down your program if overused, so log only what is necessary.

Summary

Error handling keeps your program running smoothly by managing problems.

Logging helps you see what your program is doing and find issues.

Use try...catch and console methods for simple error handling and logging in Deno.

Practice

1. What is the main purpose of using try...catch in Deno?

easy

A. To handle errors and keep the program running smoothly

B. To speed up the program execution

C. To create new files automatically

D. To log messages to the console

Solution

1. Step 1: Understand the role of try...catch

   The try...catch block is used to catch errors that happen during program execution.

2. Step 2: Identify the effect on program flow

   By catching errors, the program can handle them gracefully and continue running instead of crashing.

3. Final Answer:

   To handle errors and keep the program running smoothly -> Option A

4. Quick Check:

   Error handling = To handle errors and keep the program running smoothly [OK]

Hint: Try...catch blocks catch errors to prevent crashes [OK]

Common Mistakes:

• Thinking try...catch speeds up code
• Confusing error handling with logging
• Believing try...catch creates files

2. Which of the following is the correct syntax to log an error message in Deno?

easy

A. console.log.error('An error occurred')

B. console.error('An error occurred')

C. console.err('An error occurred')

D. console.errorMessage('An error occurred')

Solution

1. Step 1: Recall the console methods in Deno

   Deno uses standard JavaScript console methods like console.error() to log error messages.

2. Step 2: Check each option's syntax

   Only console.error('An error occurred') is valid syntax for logging errors.

3. Final Answer:

   console.error('An error occurred') -> Option B

4. Quick Check:

   console.error() logs errors = console.error('An error occurred') [OK]

Hint: Use console.error() to log errors clearly [OK]

Common Mistakes:

• Using non-existent console methods
• Mixing console.log and error methods incorrectly
• Misspelling console.error

3. What will be the output of this Deno code?

try {
  throw new Error('Oops!')
} catch (e) {
  console.log('Caught:', e.message)
}

medium

A. Caught: Oops!

B. Error: Oops!

C. Caught: undefined

D. No output

Solution

1. Step 1: Understand the throw and catch behavior

   The code throws an error with message 'Oops!'. The catch block catches it and accesses e.message.

2. Step 2: Analyze the console.log output

   The catch block logs 'Caught:' followed by the error message, so output is 'Caught: Oops!'.

3. Final Answer:

   Caught: Oops! -> Option A

4. Quick Check:

   Catch logs error message = Caught: Oops! [OK]

Hint: Catch block logs error.message after throw [OK]

Common Mistakes:

• Expecting full error object printed
• Confusing error message with undefined
• Thinking no output occurs

4. Identify the error in this Deno code snippet:

try {
  const data = JSON.parse('{ bad json }')
} catch {
  console.log('Parsing failed', e.message)
}

medium

A. console.log should be console.error

B. JSON.parse syntax is correct

C. Missing error parameter in catch block

D. try block should not have code

Solution

1. Step 1: Check catch block syntax

   In Deno (and modern JavaScript), catch block can omit error parameter, but to access error details, it must be declared.

2. Step 2: Identify the problem with missing error parameter

   The code tries to catch error but does not declare error variable, so error details can't be accessed if needed.

3. Final Answer:

   Missing error parameter in catch block -> Option C

4. Quick Check:

   Catch needs error param to access error = Missing error parameter in catch block [OK]

Hint: Always include error param in catch to access error info [OK]

Common Mistakes:

• Assuming catch() always requires error param
• Thinking console.log is wrong for errors
• Believing try block can't have code

5. You want to log an error with a timestamp and the error message in Deno. Which code snippet correctly does this?

hard

A. try {
throw new Error('Fail')
} catch (e) {
console.log('Error:', e)
}

B. try {
throw new Error('Fail')
} catch (e) {
console.error(e)
console.log(new Date())
}

C. try {
throw new Error('Fail')
} catch {
console.error('Error occurred')
}

D. try {
throw new Error('Fail')
} catch (e) {
console.error(`[${new Date().toISOString()}] Error: ${e.message}`)
}

Solution

1. Step 1: Understand the requirement for timestamp and message

   The log must include current time in ISO format and the error message.

2. Step 2: Check each option for correct formatting

   try { throw new Error('Fail') } catch (e) { console.error(`[${new Date().toISOString()}] Error: ${e.message}`) } uses template literals to combine timestamp and error message in one console.error call, which is correct.

3. Final Answer:

   try { throw new Error('Fail') } catch (e) { console.error(`[${new Date().toISOString()}] Error: ${e.message}`) } -> Option D

4. Quick Check:

   Timestamp + error message in one log = try { throw new Error('Fail') } catch (e) { console.error(`[${new Date().toISOString()}] Error: ${e.message}`) } [OK]

Hint: Use template literals with new Date().toISOString() for timestamps [OK]

Common Mistakes:

• Logging error and timestamp separately
• Missing error parameter in catch
• Using console.log instead of console.error for errors