在ES6 Node.js中，如何在任何地方提供类？

Question

In my ES6 Node.js application, I have a file with a bunch of custom error classes, ie

class FirstCustomError extends Error {
  constructor(message) {
    super(message);
    this.name = "FirstCustomError";
  }
}

class SecondCustomError extends Error {
  constructor(message) {
    super(message);
    this.name = "SecondCustomError";
  }
}

// ...

How can I make these classes available everywhere in the application? Ideally, I don't have to import them in every file I need them in, and I don't have to resort to throw new global.errors.FirstCustomError('error message') .

That is, ideally, I can just do throw new FirstCustomError('error message') .

Answer 1

You can indeed just put them on the global object :

global.FirstCustomError = class extends Error {
  constructor(message) {
    super(message);
    this.name = "FirstCustomError";
  }
};

global.SecondCustomError = class extends Error {
  constructor(message) {
    super(message);
    this.name = "SecondCustomError";
  }
};

You would need to ensure that this happens before any other module is using them, ie you'd put it in a module that is required once at the beginning of your main script. An even better (more reusable) approach would be to export them as normal from your errors module, and then do

Object.assign(global, require('./errors.js'));

in your main script to install all exports as globals.

---

Disclaimer : Of course, this is a horrible practice! Don't do that! Just do explicitly import them everywhere you need them. It's a breeze with ES6 module syntax, and it makes everything much clearer. Also it is unlikely that you have so many custom errors in your application that are of truly cross-cutting concerns and not tied to specific functionality, in which case you shouldn't put them all in the same module anyway.

Answer 2

You can add them to the first js file that runs, like app.js, and make sure they are in the global scope so they will be reusable from everywhere, but it's essential they are run first so they exist when some other code tries to call them

global.customErrFunc = class FirstCustomError extends Error {
   constructor(message) {
     super(message);
     this.name = "FirstCustomError";
   }
}
throw new customErrFunc('Custom error')

Answer 3

Normally to have a class accessible you need to export it like this:

exports.NameOfFunction = async (req, resp) =>{..... your code}; 

The async is not required! just if you need to wait for a full response of a Promise i hope this helps!

Answer 4

What you are trying to achieve is possible as suggested by other posters, but it is not recommended . An ideal way would be to export them into a module and import the module where ever you need it.

customErrors.js

export.modules.FirstCustomError = FirstCustomError
export.modules.SecondCustomError = SecondCustomError

I know this isn't what you are looking for, but opinionated development is good sometimes. global assignment is a very frowned upon practice while working in modular environments. You can use them in your code by importing.

import { FirstCustomError } from './customErrors.js'