How do you share constants in NodeJS modules?


How do you share constants in NodeJS modules?

Currently I’m doing this:
const FOO = 5;

module.exports = {

And using it in bar.js:
var foo = require(‘foo’);
foo.FOO; // 5

Is there a better way to do this? It feels awkward to declare the constant in the exports object.


Solution 1:

You can explicitly export it to the global scope with global.FOO = 5. Then you simply need to require the file, and not even save your return value.

But really, you shouldn’t do that. Keeping things properly encapsulated is a good thing. You have the right idea already, so keep doing what you’re doing.

Solution 2:

In my opinion, utilizing Object.freeze allows for a DRYer and more declarative style. My preferred pattern is:


module.exports = Object.freeze({
    MY_CONSTANT: 'some value',
    ANOTHER_CONSTANT: 'another value'


var constants = require('./constants');

console.log(constants.MY_CONSTANT); // 'some value'

constants.MY_CONSTANT = 'some other value';

console.log(constants.MY_CONSTANT); // 'some value'

Outdated Performance Warning

The following issue was fixed in v8 in Jan 2014 and is no longer relevant to most developers:

Be aware that both setting writable to false and using Object.freeze have a massive performance penalty in v8 – and

Solution 3:

Technically, const is not part of the ECMAScript specification. Also, using the “CommonJS Module” pattern you’ve noted, you can change the value of that “constant” since it’s now just an object property. (not sure if that’ll cascade any changes to other scripts that require the same module, but it’s possible)

To get a real constant that you can also share, check out Object.create, Object.defineProperty, and Object.defineProperties. If you set writable: false, then the value in your “constant” cannot be modified. 🙂

It’s a little verbose, (but even that can be changed with a little JS) but you should only need to do it once for your module of constants. Using these methods, any attribute that you leave out defaults to false. (as opposed to defining properties via assignment, which defaults all the attributes to true)

So, hypothetically, you could just set value and enumerable, leaving out writable and configurable since they’ll default to false, I’ve just included them for clarity.

Update – I’ve create a new module (node-constants) with helper functions for this very use-case.

constants.js — Good

Object.defineProperty(exports, "PI", {
    value:        3.14,
    enumerable:   true,
    writable:     false,
    configurable: false

constants.js — Better

function define(name, value) {
    Object.defineProperty(exports, name, {
        value:      value,
        enumerable: true

define("PI", 3.14);


var constants = require("./constants");

console.log(constants.PI); // 3.14
constants.PI = 5;
console.log(constants.PI); // still 3.14

Solution 4:

ES6 way.

export in foo.js

const FOO = 'bar';
module.exports = {

import in bar.js

const {FOO} = require('foo');

Solution 5:

I found the solution Dominic suggested to be the best one, but it still misses one feature of the “const” declaration. When you declare a constant in JS with the “const” keyword, the existence of the constant is checked at parse time, not at runtime. So if you misspelled the name of the constant somewhere later in your code, you’ll get an error when you try to start your node.js program. Which is a far more better misspelling check.

If you define the constant with the define() function like Dominic suggested, you won’t get an error if you misspelled the constant, and the value of the misspelled constant will be undefined (which can lead to debugging headaches).

But I guess this is the best we can get.

Additionally, here’s a kind of improvement of Dominic’s function, in constans.js:

global.define = function ( name, value, exportsObject )
    if ( !exportsObject )
        if ( exports.exportsObject )
            exportsObject = exports.exportsObject;
            exportsObject = exports;        

    Object.defineProperty( exportsObject, name, {
        'value': value,
        'enumerable': true,
        'writable': false,

exports.exportObject = null;

In this way you can use the define() function in other modules, and it allows you to define constants both inside the constants.js module and constants inside your module from which you called the function. Declaring module constants can then be done in two ways (in script.js).


require( './constants.js' );

define( 'SOME_LOCAL_CONSTANT', "const value 1", this ); // constant in script.js
define( 'SOME_OTHER_LOCAL_CONSTANT', "const value 2", this ); // constant in script.js

define( 'CONSTANT_IN_CONSTANTS_MODULE', "const value x" ); // this is a constant in constants.js module


constants = require( './constants.js' );

// More convenient for setting a lot of constants inside the module
constants.exportsObject = this;
define( 'SOME_CONSTANT', "const value 1" ); // constant in script.js
define( 'SOME_OTHER_CONSTANT', "const value 2" ); // constant in script.js

Also, if you want the define() function to be called only from the constants module (not to bloat the global object), you define it like this in constants.js:

exports.define = function ( name, value, exportsObject )

and use it like this in script.js:

constants.define( 'SOME_CONSTANT', "const value 1" );

Solution 6:

From previous project experience, this is a good way:

In the constants.js:

// constants.js

'use strict';

let constants = {
    key1: "value1",
    key2: "value2",
    key3: {
        subkey1: "subvalue1",
        subkey2: "subvalue2"

module.exports =
        Object.freeze(constants); // freeze prevents changes by users

In main.js (or app.js, etc.), use it as below:

// main.js

let constants = require('./constants');