Use Module.exports to Keep Node.js Code Organized
Tags: node, javascript, modules
Published: 2018-12-20 16:55:21

---
title: Use Module.exports to Keep Node.js Code Organized
published: true
description: Learn to organize your Node.js code using modules.
tags: node, javascript, modules
canonical_url: https://medium.com/@lullaboteducation/use-module-exports-to-keep-node-js-code-organized-9379526ebac8
---

# Use Module.exports to Keep Node.js Code Organized

![Photo by frank mckenna on Unsplash](https://d2mxuefqeaa7sj.cloudfront.net/s_892B56BE495B9FD4F289D7009ED6F7DBB7905EFB12BD11CDF71950D13D1D1F6C_1539096352900_frank-mckenna-252014-unsplash.jpg)

_Written by Jon Church and Joe Shindelar. [Originally published on Medium](https://medium.com/@lullaboteducation/use-module-exports-to-keep-node-js-code-organized-9379526ebac8)._

Node doesn’t care if we write our entire project in one huge *index.js* file. But if you want people to be able to read your code, you need to organize it in a way that makes sense and is easy to maintain. Enter Node’s module system! 

What exactly is a module? Modules organize related functions together into a file, that we can import later when we need to use them. A module encapsulates related code into a single unit, usually stored in a file. Every file in Node can be considered a module, and each has its own  `module` global object available in the file that we will use to expose code for importing in another file. 

In this tutorial we’ll:

- Learn about `module.exports` 
- Export helper functions from a file
- Include our helper functions in another file using `require`

By the end of this tutorial you should be able to use Node’s module system to create your own modules so you can reuse code in your project.


## Goal

Import helper functions from *helpers.js* in another file, *index.js*.

## What is module.exports?

To export code from a file, we assign values to the file's `module.exports` object. Each JavaScript file in Node has a `module.exports` object in its global scope that represents that specific file. That object will hold any code that we want to export from the file. We can assign an object, a single function, or any value to `module.exports` to be used again in another file.

This is part of the module system in Node. Each file has a global object in its scope called `module` , which holds information about that specific file. We can expose code from that file by assigning it to `module.exports`.


## What is `require`?

Require helps us load modules. To import code from a file, we must pass the file’s path to require: `require('./filepath')`. Calling `require` on a JavaScript file will run the code in the file, and return the value of `module.exports`.

This is actually very similar to what happens when you `require` an npm module. Except in this instance, we are passing `require` a path to a file instead of the name of a package. When you `require` an npm package, the same thing is happening behind the scenes in your *node_modules**/* folder, where the package is installed to.

Here we export a string from a file called `testModule.js`:

```js
// testModule.js
module.exports = "This is a test!"

// index.js
const test = require('./testModule.js')
console.log(test) // => "This is a test!"
```

In any given file, we can assign things to `module.exports` to allow us to import them in another file using a `require` statement.

When the `require` is called with a file path, the code in that file will be evaluated and `module.exports` will be returned.

```js
// helpers.js
console.log('I got required!)
module.exports = "Exported!"
// index.js
const exportedValue = require('./helpers.js')
```

The above code will output “I got required!” to the console, and `exportedValue` will be equal to `“Exported!”` .

If we rerun the require statement (after the first instance), we would still get the exported value of `module.exports`, but the `console.log` would not run again. This is because require statements are cached; they are run once, and then calling them again will just return the value of `module.exports`.

You might also see ES6 code like this at some point:

```
// helpers.js
export default = "I'm an export!"

// index.js
import helpers from './helpers.js'
```

This uses ES6 module syntax, and currently no Node engine supports this by default. You can use this style if working with something like Babel that transpiles your code for you. But for now, know that we are talking about the CommonJS syntax of exports, `module.exports` .

## Creating a Helpers File

So let’s use `module.exports` to export some functions from a `helpers.js` file to do some simple math, and then use them in another file, `index.js`, with the help of `require`.
One option is to export a single anonymous function from a file.

**Let’s export a single function that multiplies a number by 2 and use it in our index.js file:**

```js
// helpers.js
module.exports = function(x) {
    return x * 2
}

// index.js
const helpers = require('./helpers.js')
helpers(4) // => 8
```

We set the value of `module.exports` to the function we want to import, and require it in *index.js*.
Handy, but what if you want to export several functions at once? Well, we can export an object literal that holds several functions, then access the functions by their names. This is also called Named Exports, because we can choose to later import only the properties we want by name.

```js
// helpers.js
module.exports = {
    multiplyByTwo: function(x) { return x *2 },
    divideByTwo: function(x) { return x / 2}
}

// index.js
const helpers = require('./helpers.js')
helpers.multiplyByTwo(10) // => 5
// or, you can import just the named property you need
const divideByTwo = require('./helpers.js').divideByTwo
divideByTwo(18) // => 9
```

Requiring the file returns the object we exported with `module.exports` . You can also import only the property you need, by using dot syntax after the require statement.

Instead of having to declare the functions all in one place, we can make use of a different syntax. Here, we directly export a named property on the `module.exports` object.

```js
// helpers.js
module.exports.multiplyByTwo = function(x) { return x * 2 }
module.exports.divideByTwo = function(x) { return x / 2 }
function nonExportedFunction(x) {
    return x * 3
}
// index.js
const helpers = require('./helpers.js/)
const divideByTwo = require('./helpers.js').divideByTwo
```

In the code above, `module.exports` will look the same as the object we exported in the previous example. Both will be an object with two keys, `multiplyByTwo` and `divideByTwo`. The only difference is that we assigned them one at a time.

**Note:** Make sure you don’t mix the above syntax with exporting an object directly. If you assign something to `module.exports` later in your file, it will overwrite anything you had already exported.

```js
// helpers.js
module.exports.multiplyByTwo = function(x) { return x * 2 }
module.exports.divideByTwo = function(x) { return x / 2 }
module.exports = "I just overwrote all my exports! Don't mix these styles!"
```

## Passing arguments to a module

We can have a little fun with our math helpers by using some currying. [Currying is a concept from functional programming](https://www.sitepoint.com/currying-in-functional-javascript/): you call a function with a variable and get another function back that has that variable baked in already. It’s a sort of configuration, if you will. That’s a simple way to put it, but it can be very powerful.

Let’s make our math functions center around a single number to do operations with. We can pass in that number when requiring the file, and get back functions that multiply, divide, or add with the number we initially passed to our curry function.

```js
// curryHelpers.js
module.exports = function(x) {
    return {
    multiply: function(y) { return y * x },
    divide: function(y) { return y / x },
    add: function(y) { return y + x }
    }
}

// index.js
const byTwo = require('./curryHelpers.js')(2)
const byTen = require('./curryHelpers.js')(10)

byTwo.multiply(5) // => 10
byTwo.divide(14) // => 7
byTwo.add(9) // => 11

byTen.multiply(5) // => 50
```

This is an example of passing a variable into a file’s scope using `require` and `module.exports`. We passed the number 2 into the curryHelpers file’s scope by calling the function returned by `require`. The object of functions we exported are now configured to multiply, divide, and add any number passed to it by the initial number we passed in, 2. We did the same thing with the number 10, and got back an object of functions configured with the number 10.


## `exports` as shorthand for `module.exports`

Finally, a shorthand for `module.exports` can be used. The `exports` object is globally available as well, and points to the same object as `module.exports`.

So the following code is equivalent:

```js
// assigning named exports
module.exports.pizza = true
exports.pizza = true

// exporting an object
module.exports = {}
exports = {}
```

## Wrapping up

Node is a very modular language, and you can take advantage of that yourself by using `module.exports` to help export and reuse code in your project. Using `require`, you can import that code in any other file in your project. The idea of importing modules is very common in Node and understanding `module.exports` will help you navigate that modular approach.

I hope you’re able to use some of these patterns in your code!

If you want to learn more about `module.exports` and how it works, you could learn about [module scope](https://stackoverflow.com/questions/15406062/in-what-scope-are-module-variables-stored-in-node-js) and the [CommonJS](https://blog.risingstack.com/node-js-at-scale-module-system-commonjs-require/) module system.

---

Lullabot Education is ramping up our Node.js training. Sign up for our [newsletter](https://www.getdrip.com/forms/662782570/submissions/new) and learn about upcoming guides and tutorials — and help shape the future of Node.js education.