CODEWITHSUNDEEP
node.jsexpress
tommyd456
tommyd456

Reputation: 10673

Using require without export

I have this code (which works perfectly well) which I've borrowed from an online resource:

var express = require('express');
var bodyParser = require('body-parser');
var logger = require('morgan');

var app = express();

require('./init/db');
require('./init/cache'); //Bring in Redis

//Define Routes
var userRoutes = require('./routes/user');

module.exports = app;

The bit I don't understand is "require" when used in this way? Here is the file it brings in:

//db.js
var mongoose = require('mongoose');
var dbURI = <theURI>;

mongoose.connect(dbURI);

// CONNECTION EVENTS
mongoose.connection.on('connected', function() {
  console.log('Mongoose connected successfully');
});

It's the same with my Redis connection:

//cache.js
var redis  = require("redis");

var redisClient  = redis.createClient(process.env.CACHE_PORT, process.env.CACHE_URL);
redisClient.auth(process.env.CACHE_PASS);

redisClient.on("ready", function () {
  console.log("Cache is connected");
});

but as you can see there is no module.exports anywhere in the db.js or cache.js files! When I google this to understand how it works the examples always talk about module.exports and require together.

Questions

  1. Could someone explain how require works when used on its own like this?

  2. How can I make the cache/Redis connection available so that it can be used in my userRoutes file using something like: var userRoutes = require('./routes/user')(redis);

Upvotes: 40

Views: 24865

Answers (3)

Ebrahim Pasbani
Ebrahim Pasbani

Reputation: 9406

When you call require the module is loaded and executed. So you have a connected mongoose. Actually require makes a function that your entire module code injected there and finally run.

Now, if you want to reuse variables created in modules you should export that. Like :

//cache.js
var redis  = require("redis");

var redisClient  = redis.createClient(process.env.CACHE_PORT, process.env.CACHE_URL);
redisClient.auth(process.env.CACHE_PASS);

redisClient.on("ready", function () {
  console.log("Cache is connected");
});

module.exports = redisClient;

Upvotes: 4

Hemaolle
Hemaolle

Reputation: 2138

Besides requiring a module that doesn't include exports to run it's side effects it's also possible for a module to define variables in the global scope which can be accessed in the file where the module is required. This happens by defining variables without the var keyword. It's not a good or common practice, but you might encounter it somewhere so it's good to know what is going on.

Example:

// foo.js
bar = 5;

And

// test.js
require('./foo');

console.log(bar);
// prints 5

If barwas defined as:

var bar = 5;

it would be in the module scope and not be accessible in test.js.

Upvotes: 17

Drown
Drown

Reputation: 5982

Could someone explain what is happening with this code? In other words, how does require work when not used with export.

We almost always see require() being used with module.exports, but you don't have to. When you don't export anything, the code in the imported module will still run, but you can't bind the import to a variable and interact with it.

Consider the following Foo.js module : 

var foo = {};

foo.greet = function(){
    console.log('Hello from Foo!');
}

foo.greet();

I can import this module in my main file, like so : 

require('./foo');

If I run this main file, the code inside the Foo.js module will run, and Hello from Foo! will be printed to the console.

However, I can't interact with the foo object directly. The following code will not work :

require('./foo');
foo.greet(); //ReferenceError, foo is not defined

I can bind the module import to a variable, but even this will not work : 

var foo = require('./foo');
foo.greet(); //TypeError, foo.greet is not a function

To get it to work, I need to export the foo object from my module, using the module.exports that you are familiar with.

This demonstrates that you don't need to export anything from your modules, just like you don't need to bind the imported module to a variable when you are requiring it. The difference is that you won't be able to interact with the code in the imported module, if you don't export what you don't want to make visible in that module.

In the code in your question, importing Redis works because that module is self-contained, you don't need to interact with it in your code. You only need to import the code so that it can run (require the main Redis module and create the client)

Upvotes: 68

Related Questions