Call a "local" function within module.exports from another function in module.exports?

Question

How do you call a function from within another function in a module.exports declaration?

app.js

var bla = require('./bla.js');
console.log(bla.bar());

bla.js

module.exports = {

  foo: function (req, res, next) {
    return ('foo');
  },

  bar: function(req, res, next) {
    this.foo();
  }

}

I'm trying to access the function foo from within the function bar, and I'm getting:

TypeError: Object # has no method 'foo'

If I change this.foo() to just foo() I get:

ReferenceError: foo is not defined

I tested your code and have no errors. The bar function returns undefined because have no return statement. Are you sure you are testing correctly? — Ferchi, Oct 02 '14 at 19:25
Tested in node version `v8.12.0` and does no longer throw the error. `bar` has no return statement so running `console.log(bla.bar())` simply returns `undefined` — VladNeacsu, Apr 15 '19 at 19:00

score 497 · Accepted Answer · edited Dec 15 '19 at 03:46

497

Change this.foo() to module.exports.foo()

edited Dec 15 '19 at 03:46

Let Me Tink About It

15,156
21
98
207

answered May 05 '12 at 13:21

k00k

17,314
13
59
86

3

@NamNguyen Calling `exports.foo()` seems a little bit awkward and hard to read. – Afshin Mehrabani Jul 19 '14 at 12:20
5

I think that this is better than the accepted answer. If you define functions outside of the exports scope, it adds an extra level of indirection, and while it can be desirable sometimes, it makes it more complicated, to refactor, e.g. rename the function, of find usage of the function, etc. – Pierre Henry Sep 21 '15 at 14:48
8

`module.exports.foo()` and `exports.foo()` do not work for me with Node.js v5.8.0. – betweenbrain Jul 15 '16 at 15:35
16

exports.foo() is not working but module.exports.foo() is working with NodeJS v6.9.1 – Canser Yanbakan Nov 22 '16 at 14:04
This worked for me but instead of doing `module.exports = {...}` I had to do `exports.myFunction = function()` for each of the exported methods. – Joshua Pinter Jan 12 '17 at 21:01
1

`exports.foo` only works if you define an `exports` varible that references the `module.exports` object `const exports = module.exports = {}` and then set functions `foo` and `bar` as its methods `exports.foo = function() {}` and `exports.bar = function (){ exports.foo() }` here to reference `foo` in the `bar` use `exports.foo`. If you want to reference `foo` from `bar` inside `module.exports` object then use `module.exports.foo` inside `bar`. – pouya Jul 19 '17 at 12:24
@k00k: Can you please put link of your own answer to your question? It'll help us to get it over there itself instead of scrolling down to here. Thanks :) – Sandeep Jul 17 '18 at 12:45
You don't need your exports variable to reference module.exports, it is done for you: "The exports variable is available within a module's file-level scope, and is assigned the value of module.exports before the module is evaluated. It allows a shortcut, so that module.exports.f = ... can be written more succinctly as exports.f = ..." https://nodejs.org/api/modules.html#modules_exports_shortcut – ScottBro Nov 01 '18 at 15:09
its weird cant use `this` in module.exports – Fauzan Edris Mar 21 '21 at 14:02

score 202 · Answer 2 · edited Dec 15 '19 at 09:19

202

You could declare your functions outside of the module.exports block.

var foo = function (req, res, next) {
  return ('foo');
}

var bar = function (req, res, next) {
  return foo();
}

Then:

module.exports = {
  foo: foo,
  bar: bar
}

edited Dec 15 '19 at 09:19

Let Me Tink About It

15,156
21
98
207

answered Oct 09 '12 at 06:43

Brett

3,825
3
24
27

12

what if I wanted to access properties of the object from the method? – Rockstar5645 Jul 11 '16 at 15:12
1

I'm getting TypeError: yourClass.youMethod is not a function when I did this. I'm using node version 6.9.1. Do you have to have a return statement? I do not have return statements since all my code is async in the functions. – Brett Mathe Dec 12 '16 at 22:12
1

Nice comparison of different styles -- https://gist.github.com/kimmobrunfeldt/10848413 – Tadas V. Sep 10 '17 at 17:59
4

Or, more concisely using ES6, `module.exports = { foo, bar, }` – Let Me Tink About It Dec 15 '19 at 09:21

score 131 · Answer 3 · answered Mar 20 '15 at 21:45

131

You can also do this to make it more concise and readable. This is what I've seen done in several of the well written open sourced modules:

var self = module.exports = {

  foo: function (req, res, next) {
    return ('foo');
  },

  bar: function(req, res, next) {
    self.foo();
  }

}

answered Mar 20 '15 at 21:45

Calvin Alvin

2,448
2
16
15

Is this Node.js version specific? I am trying this with v5.8.0 and it is logging undefined. – betweenbrain Jul 15 '16 at 15:38
1

@doublejosh Did... did you read the question? It's asking how you call one exported function from another. It has _nothing to do_ with access restrictions. – Nic May 16 '18 at 19:14
1

Yes I read it, please re-read. This answer makes foo() exported with the module, which goes against the point of a "local" function only called within the module. – doublejosh May 18 '18 at 19:34
This works great. I actually need foo() exported to be used outside, but also need to call it within sibling function. Thank you! – Paul Jan 30 '23 at 07:14

score 68 · Answer 4 · answered May 07 '13 at 20:09

68

You can also save a reference to module's global scope outside the (module.)exports.somemodule definition:

var _this = this;

exports.somefunction = function() {
   console.log('hello');
}

exports.someotherfunction = function() {
   _this.somefunction();
}

answered May 07 '13 at 20:09

Ville

4,088
2
37
38

It's more cleaner solution! – IvanZh Dec 18 '14 at 08:13
no need for the _this and you can simply use this where you need it – Yuki Jul 04 '18 at 13:30
used `this` directly, no need to declare `_this` – Darius Oct 12 '18 at 10:34
2

That suggestion is useful once `this` is no longer the right `this`. (Promises and callbacks) – Andrew McOlash Mar 14 '19 at 21:21
I like this solution the best because it also gives an example of scoping in NodeJS modules. – miguelmorin Apr 03 '20 at 18:21

score 42 · Answer 5 · answered Oct 03 '13 at 15:54

Another option, and closer to the original style of the OP, is to put the object you want to export into a variable and reference that variable to make calls to other methods in the object. You can then export that variable and you're good to go.

var self = {
  foo: function (req, res, next) {
    return ('foo');
  },
  bar: function (req, res, next) {
    return self.foo();
  }
};
module.exports = self;

score 28 · Answer 6 · answered Jun 09 '17 at 15:22

28

const Service = {
  foo: (a, b) => a + b,
  bar: (a, b) => Service.foo(a, b) * b
}

module.exports = Service

answered Jun 09 '17 at 15:22

david_adler

9,690
6
57
97

3

This is particularly usable because your code there is calling `Service.foo()`, and your client code will also be calling `Service.foo()` with the same naming. – Vince Bowdren Jan 31 '18 at 11:57
This is a perfect answer! – Jayant Varshney Aug 30 '18 at 23:18
I used it with Salesforce lwc and it works perfectly, I like this clean method – Emmanuel BRUNO Nov 03 '22 at 17:46

m.spyratos · Answer 7 · 2020-02-03T22:43:24.363

21

Starting with Node.js version 13 you can take advantage of ES6 Modules.

export function foo() {
    return 'foo';
}

export function bar() {
    return foo();
}

Following the Class approach:

class MyClass {

    foo() {
        return 'foo';
    }

    bar() {
        return this.foo();
    }
}

module.exports = new MyClass();

This will instantiate the class only once, due to Node's module caching:
https://nodejs.org/api/modules.html#modules_caching

edited Feb 03 '20 at 22:43

answered Oct 23 '16 at 18:47

m.spyratos

3,823
2
31
40

and how does one call a static method with this approach? – Plixxer Jun 07 '18 at 20:55
@CodeofGod Just call it as you would call any other static method. In this case, if `foo` was static you would call it from inside `bar` like this: `MyClass.foo()`. – m.spyratos Jun 07 '18 at 21:08
yeah i get that, but how would you call it from a controller that is importing it like... const oAccounts = require("..."); – Plixxer Jun 07 '18 at 21:11
You can export the actual class, not an instance of the class. That way you can use its static methods. If you then need to use its instance methods though, then you will have to instantiate the class in your controller. – m.spyratos Jun 08 '18 at 00:44

score 8 · Answer 8 · answered Jul 17 '18 at 14:11

8

To fix your issue, i have made few changes in bla.js and it is working,

var foo= function (req, res, next) {
  console.log('inside foo');
  return ("foo");
}

var  bar= function(req, res, next) {
  this.foo();
}
module.exports = {bar,foo};

and no modification in app.js

var bla = require('./bla.js');
console.log(bla.bar());

answered Jul 17 '18 at 14:11

Akash Jain

483
5
5

3

In the function bar, this.foo() doesn't work... it needs to be foo() – Falcoa May 17 '19 at 05:26

score 0 · Answer 9 · answered Sep 09 '21 at 20:59

What I do is to create a standalone foo function and reference it in both places.

That way, it prevents any issue with this irrespective of using an arrow or regular function

function foo(req,res,next) {
  return ('foo');
}

Then I can reference foo at both places

module.exports = {

  foo, // ES6 for foo:foo

  bar: function(req, res, next) {
    foo();
  }

}

score 0 · Answer 10 · answered Dec 23 '22 at 05:30

If you do like this, you will be losing your this object reference inside your calling function. For eg:

    module.exports.a = function () {
      return true
    }
    
    module.exports.b = function() {
      return this.a();
    }

here you will get the issue because when you call this.a(), it is referencing the this object of the b function.

To solve this your have to store your this object reference somewhere or use the arrow function, because the arrow function doesn't have there own this object so it will always reference the outer this object

To solve this, modify your function like this

    module.exports.a = function () {
      return true
    }
    
    module.exports.b = () => {
      return this.a();
    }

Call a "local" function within module.exports from another function in module.exports?

10 Answers10

Linked

Related