Custom error classes in Node.js - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this custom error class code?

Consider this Node.js code defining a custom error class and using it:

class MyError extends Error {
  constructor(message) {
    super(message);
    this.name = 'MyError';
  }
}

try {
  throw new MyError('Oops!');
} catch (e) {
  console.log(e.name + ': ' + e.message);
}

What will be printed to the console?

Node.js

class MyError extends Error {
  constructor(message) {
    super(message);
    this.name = 'MyError';
  }
}

try {
  throw new MyError('Oops!');
} catch (e) {
  console.log(e.name + ': ' + e.message);
}

A TypeError: Oops!

B Error: Oops!

C MyError: Oops!

D ReferenceError: Oops!

💡 Hint

Look at how the name property is set in the constructor.

The custom error class sets this.name = 'MyError', so the error's name is 'MyError'. The message is 'Oops!'. Thus, the output is 'MyError: Oops!'.

❓ component_behavior

intermediate

What happens when throwing a custom error without calling super()?

Examine this code snippet:

class BadError extends Error {
  constructor(message) {
    this.message = message;
    this.name = 'BadError';
  }
}

try {
  throw new BadError('Fail');
} catch (e) {
  console.log(e instanceof Error);
}

What will be logged to the console?

Node.js

class BadError extends Error {
  constructor(message) {
    this.message = message;
    this.name = 'BadError';
  }
}

try {
  throw new BadError('Fail');
} catch (e) {
  console.log(e instanceof Error);
}

A ReferenceError

B true

C SyntaxError

D false

💡 Hint

What happens when you access this without calling super() first?

Accessing this before calling super() in a subclass constructor throws a ReferenceError. Since the constructor throws an error, the catch block receives that error, which is a ReferenceError, so logging e instanceof Error is not reached. The code will throw a ReferenceError at runtime.

📝 Syntax

advanced

Which option correctly defines a custom error class with a stack trace?

Choose the code that correctly creates a custom error class preserving the stack trace in Node.js:

A

class CustomError extends Error {
  constructor(msg) {
    super(msg);
    this.name = 'CustomError';
  }
  captureStack() {
    Error.captureStackTrace(this, this.constructor);
  }
}

B

class CustomError extends Error {
  constructor(msg) {
    super(msg);
    this.name = 'CustomError';
    Error.captureStackTrace(this, CustomError);
  }
}

C

class CustomError extends Error {
  constructor(msg) {
    super(msg);
    this.name = 'CustomError';
    this.stack = new Error().stack;
  }
}

D

class CustomError extends Error {
  constructor(msg) {
    this.message = msg;
    this.name = 'CustomError';
    Error.captureStackTrace(this, CustomError);
  }
}

💡 Hint

Look for the standard way to capture stack trace in Node.js custom errors.

Option B calls super(msg), sets the name, and uses Error.captureStackTrace(this, CustomError) to properly capture the stack trace excluding the constructor call.

🔧 Debug

advanced

Why does this custom error not show the correct name when logged?

Look at this code:

class MyError extends Error {
  constructor(message) {
    super(message);
  }
}

const err = new MyError('Problem');
console.log(err.name);

What will be printed and why?

Node.js

class MyError extends Error {
  constructor(message) {
    super(message);
  }
}

const err = new MyError('Problem');
console.log(err.name);

A Error - because the name property was not set explicitly

B MyError - because the class name is used automatically

C undefined - because name is not set in Error

D Problem - because message is printed instead of name

💡 Hint

Check if the name property is set in the constructor.

The name property defaults to 'Error' unless explicitly set. Since this.name is not assigned, it remains 'Error'.

🧠 Conceptual

expert

What is the main benefit of using custom error classes in Node.js?

Why should developers create custom error classes instead of using the built-in Error class directly?

A To avoid using try-catch blocks in asynchronous code

B To make errors run faster in Node.js runtime

C To automatically fix bugs in the code without manual intervention

D To add specific error names and properties for better error identification and handling

💡 Hint

Think about how custom errors help in debugging and managing errors.

Custom error classes allow adding meaningful names and extra properties, making it easier to identify and handle different error types in code.