Modules

Question 1

What are four reasons we might use modules to contain JavaScript code?

Answer 1

1. Allows us to find, fix, and debug more easily
2. Allows us to reuse and recycle logic in different areas of the application.
3. Keep information private and protected from other modules
4. Avoid polluting the global namespace and potential naming collisions.

Question 2

What the does process.argv[n] method return?

Answer 2

process.argv is an array of commands passed into the node environment. process.argv[n] returns the nth argument in the command (Zero-based indexing)

Question 3

describe two ways of exporting a function from a module

Answer 3

1. By defining a function, then passing that function definition via module.exports.functionName = functionName
2. By setting module.exports.functionName to a function defined in the export dialogue. module.exports.functionName = function(name){code}

Question 4

How would you import a function from a module after it has been exported?

Answer 4

You can use the require() function in the receiving file to import a function from a module. The require() function accepts a file path as a string.

require(‘./modules/moduleName.js’ would import all exported functions from moduleName.js.

You will then assign the functions via const functionName = moduleName.functionName

Question 5

What does module.exports() create?

Answer 5

module.exports() creates an object that contains all exported functions from the moduleName.js file.

Question 6

Why would we use Object Destructuring to import from a module?

Answer 6

Object Destructuring allows us to import only select functions from a module when not all of the exported functions are needed:

const { desiredFunctionName } = require(‘./modules/moduleName.js’)

Question 7

How do we use object deconstruction to import a function from a module file?

Answer 7

We would write:

const { desiredFunctionName } = required(‘filePath/to/module.js’)

Question 8

How does module importation/exportation differ between node and browser runtime environment?

Answer 8

Node uses module.exports and require(‘filePath) syntax

Browsers use export and import syntax

export {exportA, exportB } and import {exportA, exportB} from ‘filePath’

Question 9

How do we export and import module files in a browser based runtime environment?

Answer 9

export {moduleExport} or export const moduleName = function

import {moduleExport} from ‘filePathName’

we also need to include type=’module’ to the script import to html

Question 10

What do we need to remember when importing modules into HTML via the script tags?

Answer 10

We need to include type=”module” in addition to the filepath for the script

Question 11

What might we do to avoid naming conflicts when importing a module?

Answer 11

We might use the import … as … syntax to avoid naming conflicts

import {greet as greetFrench } from ‘filePathName’

Question 12

How do we use the default export to export the entire module file and all contained functions?

Answer 12

We first define the module code as an object by:

const resources = { codeBlockHere }

and then export {resources as default }

this will export the entire module file

Question 13

How do we import a module exported as default?

Answer 13

We use:

import importedResources from ‘filePathName’

note that this is actually import {resources as importedResources} from ‘filePathName’

Question 14

What is different in the import syntax of a browser runtime environment when we are importing a default export?

Answer 14

The curly braces are gone from around the imported moduleName

Question 15

How do we create individual function variables having used a default export?

Answer 15

We import the default as normal and then deconstruct the default like so:

const {functionOne, functionTwo } = defaultName

Question 16

How can we export functions to avoid naming conflicts?

Answer 16

We can use the export … as … syntax, much like the import syntax

export { functionName as newFunctionName } and then

import { newFunctionname } from ‘./filePathName’

Question 17

If we had a large number of functions to export from a module, how might we import them efficiently?

Answer 17

We could import all functions form a module in a module object:

import * as Module from ‘filePathname’

We could then call the functions by using dot-notation with the function name - Module.functionName( )