Custom error classes in Node.js - Mini Project: Build & Apply

Custom Error Classes in Node.js

📖 Scenario: You are building a simple Node.js application that processes user input. To handle errors clearly, you want to create a custom error class that extends the built-in Error class.

🎯 Goal: Create a custom error class called ValidationError that extends Error. Then use it to throw an error with a specific message.

📋 What You'll Learn

Create a class named ValidationError that extends Error

Add a constructor that accepts a message parameter

Call the parent Error constructor with the message

Set the name property of the error to ValidationError

Throw an instance of ValidationError with the message 'Invalid input'

💡 Why This Matters

🌍 Real World

Custom error classes help make error handling clearer and more specific in Node.js applications, improving debugging and user feedback.

💼 Career

Understanding custom errors is important for backend developers to write robust, maintainable code and handle different error cases properly.

1

Create the custom error class skeleton

Create a class called ValidationError that extends Error. Add a constructor that takes a message parameter.

Node.js

class ValidationError extends Error {
  // Your code here
}

Hint

Remember to use extends to inherit from Error and call super(message) inside the constructor.

2

Set the error name property

Inside the ValidationError constructor, set this.name to the string 'ValidationError'.

Node.js

class ValidationError extends Error {
  constructor(message) {
    super(message);
    // Your code here
  }
}

Hint

Setting this.name helps identify the error type when caught.

3

Throw the custom error

Write a line that throws a new ValidationError with the message 'Invalid input'.

Node.js

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

// Your code here

Hint

Use the throw keyword followed by new ValidationError('Invalid input').

4

Wrap throw in try-catch and log error name and message

Wrap the throw statement inside a try block. Add a catch block that catches the error as err and logs err.name and err.message.

Node.js

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

// Your code here

Hint

Use try { ... } catch (err) { ... } and inside catch log the error's name and message.

Practice

1. What is the main reason to create a custom error class in Node.js?

easy

A. To define specific error types for clearer error handling

B. To make the program run faster

C. To avoid using try-catch blocks

D. To replace the built-in Error class completely

Solution

1. Step 1: Understand the purpose of custom errors

   Custom error classes help identify and handle specific error cases clearly in your code.

2. Step 2: Compare with other options

   Custom errors do not speed up code, avoid try-catch, or replace Error class but extend it.

3. Final Answer:

   To define specific error types for clearer error handling -> Option A

4. Quick Check:

   Custom error purpose = Specific error types [OK]

Hint: Custom errors clarify error types, not speed or structure [OK]

Common Mistakes:

• Thinking custom errors improve performance
• Believing custom errors remove need for try-catch
• Assuming custom errors replace built-in Error

2. Which of the following is the correct way to define a custom error class named MyError in Node.js?

easy

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

B. function MyError() { this.message = 'Error'; this.name = 'MyError'; }

C. class MyError { constructor(message) { this.message = message; } }

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

Solution

1. Step 1: Check class inheritance

   Custom errors must extend the built-in Error class to behave like errors.

2. Step 2: Verify constructor and name setting

   The constructor calls super(message) and sets this.name to the class name for clarity.

3. Final Answer:

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

4. Quick Check:

   Extend Error and set name = MyError [OK]

Hint: Extend Error and set this.name in constructor [OK]

Common Mistakes:

• Not extending Error class
• Forgetting to call super(message)
• Not setting the error name property

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

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

try {
  throw new NotFoundError('Item not found');
} catch (e) {
  console.log(e.name + ': ' + e.message);
}

medium

A. Error: Item not found

B. NotFoundError: Item not found

C. TypeError: Item not found

D. undefined: Item not found

Solution

1. Step 1: Understand custom error name

   The custom error sets this.name = 'NotFoundError', so e.name is 'NotFoundError'.

2. Step 2: Check the output format

   The console.log prints e.name + ': ' + e.message, which becomes 'NotFoundError: Item not found'.

3. Final Answer:

   NotFoundError: Item not found -> Option B

4. Quick Check:

   Custom error name shows in output [OK]

Hint: Custom error name property appears in error output [OK]

Common Mistakes:

• Assuming default 'Error' name instead of custom
• Confusing error type with TypeError
• Missing the custom name property effect

4. Identify the error in this custom error class definition:

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

medium

A. Missing call to super() in constructor

B. Incorrect class name

C. Should extend Object instead of Error

D. No error, code is correct

Solution

1. Step 1: Check constructor for super call

   When extending Error, constructor must call super() before using this.

2. Step 2: Identify missing super call

   The code sets this.message and this.name without calling super(msg), causing a runtime error.

3. Final Answer:

   Missing call to super() in constructor -> Option A

4. Quick Check:

   Always call super() first in subclass constructor [OK]

Hint: Always call super() before using this in constructor [OK]

Common Mistakes:

• Forgetting super() call causes ReferenceError
• Setting this.message before super()
• Extending wrong base class

5. You want to create a custom error class AuthError that includes a statusCode property for HTTP status codes. Which implementation correctly adds this property and preserves the error behavior?

hard

A. class AuthError extends Error {
constructor(statusCode) {
super();
this.name = 'AuthError';
this.statusCode = statusCode;
}
}

B. class AuthError extends Error {
constructor(message, statusCode) {
this.message = message;
this.statusCode = statusCode;
this.name = 'AuthError';
}
}

C. class AuthError extends Error {
constructor(message, statusCode) {
super(message);
this.name = 'AuthError';
this.statusCode = statusCode;
}
}

D. class AuthError {
constructor(message, statusCode) {
this.message = message;
this.statusCode = statusCode;
this.name = 'AuthError';
}
}

Solution

1. Step 1: Check proper Error extension and constructor

   The class must extend Error and call super(message) to set the error message correctly.

2. Step 2: Verify additional property and name

   Setting this.statusCode after super() adds the extra info; setting this.name clarifies error type.

3. Final Answer:

   class AuthError extends Error { constructor(message, statusCode) { super(message); this.name = 'AuthError'; this.statusCode = statusCode; } } -> Option C

4. Quick Check:

   Extend Error, call super(message), add extra properties [OK]

Hint: Call super(message) first, then add extra properties [OK]

Common Mistakes:

• Not calling super(message) in constructor
• Not extending Error class
• Missing message parameter in super call