Custom error classes in Node.js - Step-by-Step Execution

Concept Flow - Custom error classes

Define class extending Error

↓

Create instance of custom error

↓

Throw custom error

↓

Catch error in try-catch

↓

Check error type with instanceof

↓

Handle or log error

↓

End

This flow shows how to define a custom error class, throw it, catch it, and handle it by checking its type.

Execution Sample

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);
}

Defines a custom error class, throws it, catches it, and logs its name and message.

Execution Table

Step	Action	Evaluation	Result
1	Define class MyError extending Error	Class MyError created	MyError class ready
2	Create new MyError with message 'Oops!'	new MyError('Oops!')	Error object with name 'MyError' and message 'Oops!'
3	Throw the MyError instance	throw new MyError('Oops!')	Exception thrown, jumps to catch
4	Catch error in catch block	catch(e)	e is MyError instance
5	Log e.name + ': ' + e.message	console.log output	MyError: Oops!

💡 Execution stops after catch block finishes handling the thrown error.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
MyError	undefined	Class defined	Class defined	Class defined	Class defined
e	undefined	undefined	undefined	MyError instance	MyError instance

Key Moments - 3 Insights

Why do we set this.name = 'MyError' inside the constructor?

Because the default Error name is 'Error', setting this.name helps identify the error type clearly in logs, as shown in step 5 of the execution_table.

What happens if we throw the error outside a try-catch block?

The program will crash or stop running because the error is unhandled. The try-catch in step 3 and 4 shows how to catch and handle it safely.

How do we check if the caught error is our custom error?

We use 'instanceof MyError' to check the error type, which is possible because the error object is created from the MyError class as shown in step 4.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'e.name' at step 5?

A 'MyError'

B 'Error'

C 'Oops!'

D undefined

💡 Hint

Check the 'Result' column at step 5 where the error name is logged.

At which step is the custom error instance created?

A Step 1

B Step 3

C Step 2

D Step 4

💡 Hint

Look at the 'Action' column where 'new MyError' is called.

If we remove 'this.name = "MyError"' from the constructor, what changes in the output at step 5?

A The output will not change

B The output will show 'Error: Oops!' instead of 'MyError: Oops!'

C The program will crash

D The error message will be empty

💡 Hint

Refer to the key_moments about setting the error name and the output logged at step 5.

Concept Snapshot

Custom error classes extend Error to create specific error types.
Set this.name in constructor to identify error type.
Throw instances with throw new MyError(message).
Catch with try-catch and check type with instanceof.
Helps organize error handling clearly.

Full Transcript

This lesson shows how to create custom error classes in Node.js by extending the built-in Error class. We define a class MyError that sets its name property to identify the error type. Then we create an instance of MyError with a message and throw it inside a try block. The catch block catches the error object, which is an instance of MyError. We log the error's name and message to show how custom errors can be identified and handled. This helps organize error handling in programs by creating specific error types instead of using generic errors.

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