Skip to content

Instantly share code, notes, and snippets.

Forked from subfuzion/
Last active April 22, 2024 17:19
Show Gist options
  • Save justmoon/15511f92e5216fa2624b to your computer and use it in GitHub Desktop.
Save justmoon/15511f92e5216fa2624b to your computer and use it in GitHub Desktop.
Creating custom Error classes in Node.js
'use strict';
module.exports = function CustomError(message, extra) {
Error.captureStackTrace(this, this.constructor); =;
this.message = message;
this.extra = extra;
require('util').inherits(module.exports, Error);

It's nice to be able to distinguish error types by classes. But it's a bit tricky to correctly create a custom error class in Node.js, so here is an example.

The example also shows how to add an extra parameter called extra that will be stored as a property on the error.


var CustomError = require('./errors/custom-error');

function doSomethingBad() {
  throw new CustomError('It went bad!', 42);


  • Name appears once - less editing if you have to create lots of custom error classes
  • Easy to subclass - just change the last line to inherit from another custom error class you created
  • Correct stack trace - no extra stack frames, no double capturing of the stack trace


These are some things that I've seen in other proposed solutions that you should avoid.

  • - creates another error object (wasting a bunch of time) and doesn't touch this at all
  • Error.captureStackTrace(this, arguments.callee); - works, but arguments.callee is deprecated, so don't use it
  • this.stack = (new Error).stack - this... I don't even...
// Mini test suite for our custom error
var assert = require('assert');
var CustomError = require('./errors/custom-error');
function doSomethingBad() {
throw new CustomError('It went bad!', 42);
try {
} catch (err) {
// The name property should be set to the error's name
assert( = 'CustomError');
// The error should be an instance of its class
assert(err instanceof CustomError);
// The error should be an instance of builtin Error
assert(err instanceof Error);
// The error should be recognized by Node.js' util#isError
// The error should have recorded a stack
// toString should return the default error message formatting
'CustomError: It went bad!');
// The stack should start with the default error message formatting
'CustomError: It went bad!');
// The first stack frame should be the function where the error was thrown.
assert.strictEqual(err.stack.split('\n')[1].indexOf('doSomethingBad'), 7);
// The extra property should have been set
assert.strictEqual(err.extra, 42);
// Spoiler: It passes!
Copy link

westy92 commented Jul 30, 2016

I'm using TypeScript and came up with the following solution:

class MyError extends Error {

  static name: string;

  constructor(public message?: string, public extra?: number) {
    Error.captureStackTrace(this, MyError); = (this as any); // OR = (<any>this);


Note that you must have the node typings installed in order to use Error.captureStackTrace.

Copy link

Thank you for this great Gist!

I've made a custom version of it to be used in ES6/ES2015:

Would love to hear your opinion on it.

Copy link

mizunashi-mana commented Nov 23, 2016

In Node 7.1 and TypeScript, this works:

export class ErrorBase extends Error {
  public name: string;

  constructor(message: string) {
    super(message); = (this.constructor as any).name;
    this.message = message;
    Error.captureStackTrace(this, this.constructor); // after initialize properties


this features was added in typescript 2.1, so this implementation is better (see also below comment):

export interface ErrorBase extends Error {
  readonly name: string;
  readonly message: string;
  readonly stack: string;
export interface ErrorBaseConstructor {
  new (message: string): ErrorBase;
  readonly prototype: ErrorBase;

export const ErrorBase: ErrorBaseConstructor = <any>class ErrorBase {
  public constructor(message: string) {
    Object.defineProperty(this, 'name', {
      get: () => (this.constructor as any).name,
    Object.defineProperty(this, 'message', {
      get: () => message,
    Error.captureStackTrace(this, this.constructor);
(ErrorBase as any).prototype = Object.create(Error.prototype);
ErrorBase.prototype.constructor = ErrorBase;

Copy link

In Node (7.2) console.log will print custom errors a bit differently unless all properties are defined as non-enumerable:

class CustomError extends Error {
  constructor(...args) {    
    Object.defineProperty(this, "name", {           
    Error.captureStackTrace(this, this.constructor);

Copy link

@urugator: do you have a link about this? Thank you!

Copy link

gunar commented Apr 11, 2017

I avoid classes (classical-inheritance is flawed) and types (google: instanceof lies).
The best solution is just to duck-type. See

Copy link

tinybug commented Jul 10, 2017

It's more better move Error.captureStackTrace(this, this.constructor); after this.message = message;, then the e.stack will output like this:
CustomError: custom ...
Otherwise it will output:
Error ...
that output of stack will miss error type and message

Copy link

So tricky

node --version  
module.exports = function CustomError(message, extra) { =
  this.message = message
  Error.captureStackTrace(this, this.constructor)
  this.extra = extra

module.exports.prototype.inspect = function () {
  return this.stack


class MyCustomError extends require('./Errors') {}

try {
  throw new MyCustomError ('message')
} catch (err) {
  console.log(err instanceof MyCustomError)

node Error.test.js

MyCustomError: message
    at Object.<anonymous> (Error.test.js:4:9)
    at Module._compile (module.js:571:32)
    at Object.Module._extensions..js (module.js:580:10)
    at Module.load (module.js:488:32)
    at tryModuleLoad (module.js:447:12)
    at Function.Module._load (module.js:439:3)
    at Module.runMain (module.js:605:10)
    at run (bootstrap_node.js:427:7)
    at startup (bootstrap_node.js:151:9)
    at bootstrap_node.js:542:3

Copy link

Why Not

     function MyCustomError(message, extra) {
          const error  = new Error(message);
 = 'MyCustomError';
          if (extra) {
                error.extra = extra;

          return error;

throw MyCustomError('Something Went Wrong');

Copy link

constgen commented Mar 2, 2018


var error = new MyCustomError('Something Went Wrong');
error instanceof MyCustomError // false

Which is not expected. You can't check the type of error for example in this case

try { }
    case err instanceof MyCustomError: break;
    case err instanceof Error: break;

Copy link

Copy link

These were all showing up in the console as an object, not as the usual Error:

{ CustomError: test
    at ... 
        name: 'CustomError' }

Instead if I use the name getter, I get the usual error-like appearance:

class CustomError { 
    get name () { return } 
CustomError: test
    at ...

Copy link

tcf909 commented Jul 15, 2019

How do you match the string representation of CustomError to that of Error object? Error); // '[object Error]' CustomError); //  '[object Object]'

You need to define the toStringTag for the CustomError:

Object.defineProperty(CustomError.prototype, Symbol.toStringTag, {
	value: 'Error',
	writable: false, configurable: false, enumerable: false

This consequently help with libraries like lodash and it's _.isError().

Copy link

Thanks for the gist, and thanks to all the commenters for the suggestions.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment