Custom error classes in Node.js - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a custom error class named MyError.

Node.js

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

Drag options to blanks, or click blank then click option'

AObject

BArray

CError

DFunction

Attempts:

3 left

💡 Hint

Common Mistakes

Extending Object or Array instead of Error.

Forgetting to call super(message) in constructor.

The custom error class should extend the built-in Error class to behave like an error.

2fill in blank

medium

Complete the code to throw a new instance of the custom error MyError with a message.

Node.js

throw new [1]('Something went wrong');

Drag options to blanks, or click blank then click option'

AError

BMyError

CTypeError

DReferenceError

Attempts:

3 left

💡 Hint

Common Mistakes

Throwing the base Error instead of the custom error.

Forgetting the new keyword.

To throw the custom error, create a new instance of MyError.

3fill in blank

hard

Fix the error in the custom error class by completing the missing call to the parent constructor.

Node.js

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

Drag options to blanks, or click blank then click option'

Asuper(message)

Bthis.message = message

CError.call(this, message)

Dreturn message

Attempts:

3 left

💡 Hint

Common Mistakes

Assigning message directly without calling super.

Calling Error.call without super in ES6 classes.

Calling super(message) ensures the base Error class is properly initialized with the message.

4fill in blank

hard

Fill both blanks to create a custom error class named DatabaseError that sets the name and captures the stack trace.

Node.js

class DatabaseError extends Error {
  constructor(message) {
    super(message);
    this.name = [1];
    if (Error.captureStackTrace) {
      Error.captureStackTrace(this, [2]);
    }
  }
}

Drag options to blanks, or click blank then click option'

A'DatabaseError'

BDatabaseError

C'Error'

DError

Attempts:

3 left

💡 Hint

Common Mistakes

Setting name to the class instead of a string.

Passing a string instead of the class to captureStackTrace.

The name property should be set to the string 'DatabaseError'. The captureStackTrace method takes the class itself as the second argument.

5fill in blank

hard

Fill all three blanks to create a custom error class ApiError that accepts a message and a status code, sets the name, and stores the status code.

Node.js

class ApiError extends Error {
  constructor(message, statusCode) {
    super([1]);
    this.name = [2];
    this.statusCode = [3];
  }
}

Drag options to blanks, or click blank then click option'

Amessage

B'ApiError'

CstatusCode

D'Error'

Attempts:

3 left

💡 Hint

Common Mistakes

Passing statusCode to super instead of message.

Setting name to 'Error' instead of 'ApiError'.

Not storing the statusCode property.

The constructor passes message to super, sets name to 'ApiError', and stores the statusCode property.

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