Detailed explanation of how Node.js loads modules and installs module instances

Modules in Node.js can obtain module references through file paths or names. The module reference will be mapped to a js file path, unless it is a Node built-in module. Node's built-in modules expose some commonly used APIs to developers, and they are preloaded when the Node process starts.

Others, such as third-party modules or local modules installed through NPM, each module will expose a public API. So that developers can import it. For example,

var mod = require('module_name')

After this sentence is executed, Node will load built-in modules or modules installed through NPM. The require function returns an object. The API exposed by the object may be a function, object, or attribute such as a function, array, or even any type of JS object.

The loading and caching mechanism of the node module is listed here

1) Load the built-in module (A Core Module)
2) Load the file module (A File Module)
3) Load the file directory module (A Folder Module)
4) Load the module in node_modules
5) Automatically cache the loaded module

1. Load the built-in module

Node's built-in modules are compiled into binary form, and are referenced directly by name instead of file path. When a third-party module has the same name as a built-in module, the built-in module will overwrite the third-party module with the same name. Therefore, when naming, you need to be careful not to have the same name as the built-in module. For example, if you get an http module

var http = require('http')

, the http returned is the built-in module of Node that implements the HTTP function.

2. Load the file module

Absolute path

var myMod = require('/home/base/my_mod')

or relative path

var myMod = require('./my_mod')

Note that the extension ".js" is ignored here , the following are equivalent

var myMod = require('./my_mod')
var myMod = require('./my_mod.js')

3. Load the file directory module

You can directly require a directory, assuming there is a directory named folder, such as

var myMod = require('./folder')

At this time , Node will search the entire folder directory, Node will assume that the folder is a package and try to find the package definition file package.json. If the folder directory does not contain the package.json file, Node will assume that the default main file is index.js and load index.js. If index.js doesn't exist either, then loading will fail.

If the directory structure is as follows

package.json is defined as follows

{
    "name": "pack",
    "main": "modA.js"
}

At this time require('./folder') will return the module modA.js. If package.json does not exist, the module index.js will be returned. If index.js also does not exist, a loading exception will occur.

4. Load the module in node_modules

If the module name is not a path or a built-in module, Node will try to search in the node_modules folder of the current directory. If the node_modules in the current directory is not found, Node will search from the node_modules in the parent directory and recurse until the root directory.

Don’t worry, the npm command allows us to easily install, uninstall, and update the node_modules directory.

5. Automatically cache loaded modules

Node will cache loaded modules without having to search again every time. Here is an example

modA.js

console.log('模块modA开始加载...')
exports = function() {
    console.log('Hi')
}
console.log('模块modA加载完毕')

init.js

var mod1 = require('./modA')
var mod2 = require('./modA')
console.log(mod1 === mod2)

Command line execution:

node init.js

Enter the following

#. You can see that although require is required twice, modA.js is still only executed once. mod1 and mod2 are the same, that is, both references point to the same module object.

The above is the detailed content of Detailed explanation of how Node.js loads modules and installs module instances. For more information, please follow other related articles on the PHP Chinese website!