Shulou(Shulou.com)06/03 Report--

This article is to share with you about how to use the module system in Nodejs, the editor thinks it is very practical, so I share it with you to learn. I hope you can get something after reading this article.

Modular background

Early JavaScript is to achieve simple page interaction logic, but with the development of the times, browsers not only can only show simple interaction, a variety of websites began to shine. As websites become more complex and front-end code increases, JavaScript's lack of modularity compared to other static languages begins to expose, such as naming conflicts. Therefore, in order to facilitate the maintenance and management of the front-end code, the community began to define the modular specification. In this process, there are many modularization specifications, such as CommonJS, AMD, CMD, ES modules. This article mainly discusses the modularization implemented by CommonJS in Node.

CommonJS specification

First of all, in the Node world, the module system conforms to the CommonJS specification, which is defined in the CommonJS specification, which is simply:

Every file is a module.

Represent the information of a module through a module object

Exports is used to export the information exposed by the module.

Reference a module through require

Node module classification

Core modules: modules such as fs,http,path, which do not need to be installed and are already loaded in memory at run time. [recommended: "nodejs tutorial"]

Third-party modules: stored in node_modules through installation.

Custom module: mainly refers to the file module, which is introduced through absolute path or relative path.

Module object

As we said above, a file is a module, and the current module information is described by a module object. A module object pair should have the following attributes:-id: current module id-path: current module corresponding path-exports: current module exposed variable-parent: it is also a module object, representing the parent module of the current module. That is, the module that calls the current module-filename: the file name (absolute path) of the current module, which can be used to add the loaded module to the global module cache when the module is introduced. Subsequent introduction takes values directly from the cache-loaded: indicates whether the current module has been loaded-children: is an array, which stores the module called by the current module-paths: is an array Record starting from the current module to find the node_modules directory, recursively looking up to the root directory under the node_modules directory

Module.exports and exports

After talking about the CommonJS specification, let's first talk about the difference between module.exports and exports.

First, let's do a simple verification with a new module.

Console.log (module.exports = = exports); / / true

As you can see, module.exports and epxorts actually point to the same reference variable.

Demo1

/ / a module module.exports.text = 'xxx';exports.value = 2umbram / b module code let a = require ('. / a'); console.log (a); / / {text: 'xxx', value: 2}

This verifies why attributes are added through module.exports and exports in the above demo1, both of which exist when the module is introduced, because both end up adding attributes to the same reference variable. According to the demo, it can be concluded that module.exports and exports point to the same reference variable.

Demo2

/ / a module module.exports = {text: 'xxx'} exports.value = 2 let / b module code let a = require ('. / a'); console.log (a); / / {text: 'xxx'}

In the above demo example, module.exports is re-assigned and exports adds attributes, but after introducing the module, the final export is the value defined by module.exports. It can be concluded that the module of noed finally exports module.exports, while exports is only a reference to module.exports, similar to the following code:

Exports = module.exports = {}; (code in function (exports, module) {/ / a module module.exports = {text: 'xxx'} exports.value = 2; console.log (module.exports = exports); / / false}) (exports, module)

Because in the function execution, exports is only a reference to the corresponding variable of the original module.exports, when the module.exports is assigned, the corresponding variable of exports and the latest module.exports are not the same variable.

Require method

The process of introducing the module into require is mainly divided into the following steps:

Parse the file path to an absolute path

Check whether the module you currently need to load already has a cache. If so, you can use the cache directly.

Check whether it comes with node modules, such as http,fs, and return it directly.

Create a module object based on the file path

Add the module to the module cache

Parse, compile and execute files through the corresponding file parsing method (node only supports parsing files with .js, .json, .node suffixes by default)

Returns the loaded module exports object

Module.prototype.require = function (id) {/ /. Try {/ / loads the module return Module._load (id, this, / * isMain * / false) mainly through Module's static method _ load;} finally {} / /.}; / /. Module._load = function (request, parent, isMain) {let relResolveCacheIdentifier; / parse the file path to the absolute path const filename = Module._resolveFilename (request, parent, isMain) / / check whether the module you currently need to load already has a cache const cachedModule = Module._ cache [filename]; / / if there is cache, you can simply use the cached if (cachedModule! = = undefined) {/ /. Return cachedModule.exports;} / / check whether it comes with node module, such as http,fs, return const mod = loadNativeModule (filename, request) directly; if (mod & & mod.canBeRequiredByUsers) return mod.exports; / / initialize a module const module = cachedModule according to the file path | | new Module (filename, parent); / / add the module to the module cache Module._ [filename] = module If (parent! = = undefined) {relativeResolveCache [relResolveCacheIdentifier] = filename;} / /... / / load the module module.load (filename); return module.exports;}

At this point, the module principle flow of node is basically over. The ESM feature has been officially supported since node v13.2.0.

_ _ filename, _ _ dirname

When you come into contact with node, do you wonder where _ _ filename, _ _ dirname come from and why there are these variables? Read this chapter carefully and you will have a systematic understanding of these.

Follow the require source code above. When a module is loaded, the module content will be read.

Wrap the content into a function body

Compile the concatenated function number string into a function

Execute the compiled function, passing in the corresponding parameters

Module.prototype._compile = function (content, filename) {/ /. Const compiledWrapper = wrapSafe (filename, content, this); / / result = compiledWrapper.call (thisValue, exports, require, module, filename, dirname); / / Return result;}; function wrapSafe (filename, content, cjsModuleInstance) {/ /. Const wrapper = Module.wrap (content); / /...} let wrap = function (script) {return Module.wrapper [0] + script + Module.wrapper [1]; const wrapper = ['(function (exports, require, module, _ _ filename, _ _ dirname) {','\ n});']; ObjectDefineProperty (Module, 'wrap', {get () {return wrap;}, set (value) {patched = true; wrap = value) })

To sum up, that is why there are variables such as _ _ dirname,__filename, module, exports and require in the module, which is actually introduced by node during the execution process to see whether it has solved the problem that has been puzzled for many years ^ _ ^

Using ES Modules in NodeJS

Add "type": "module" configuration to package.json

/ / test.mjsexport default {a: 'xxx'} / / import.jsimport a from'. / test.mjs';console.log (a); / / {a: 'xxx'} the difference between import and require

The obvious difference lies in the timing of execution:

When the ES module executes, all import imported modules will be pre-parsed first and executed before other modules in the module.

/ / entry.jsconsole.log ('execute entry'); let a = require ('. / a.js') console.log (a); / / a.jsconsole.log ('- Amurk'); module.exports = 'this is a this is' / the final output order is: / / execute entry//-Agamot / this is an amp / entry.jsconsole.log ('execute entry'); import b from'. / b.mjs' Console.log (b); / / b.mjsconsole.log ('- bmurf'); export default 'this is baccalaureate / final output order is: / /-bmelmelink / execute entry// this is b

Import can only be at the top level of the module, not in the code block (for example, in the if code block). If you need to introduce it dynamically, you need to use import () to dynamically load it.

The ES module differs from the CommonJS module in the following ways:

No require, exports, or module.exports

In most cases, you can use the ES module import to load the CommonJS module. (the CommonJS module file suffix is cjs) if you need to introduce a CommonJS module with the .js suffix, you can use module.createRequire () to construct the require function in the ES module

/ / test.cjsexport default {a: 'xxx'} / / import.jsimport a from'. / test.cjs';console.log (a); / {a: 'xxx'} / / test.cjsexport default {a:' xxx'} / / import.jsimport a from'. / test.cjs';console.log (a); / / {a: 'xxx'} / / test.cjsexport default {a:' xxx'} / / import.mjsimport {createRequire} from 'module' Const require = createRequire (import.meta.url); / / test.js is the CommonJS module. Const siblingModule = require ('. / test'); console.log (siblingModule); / / {a: 'xxx'}

No _ _ filename or _ _ dirname

These CommonJS variables are not available in the ES module.

No JSON module loaded

JSON import is still in the experimental stage and is only supported through the-- experimental-json-modules flag.

No require.resolve.

No NODE_PATH.

No require.extensions.

No require.cache.

Mutual reference between ES module and CommonJS

Introducing ES module into CommonJS

Because the loading, parsing, and execution of ES Modules are asynchronous, and the process of require () is synchronous, you cannot reference an ES6 module through require ().

The import () function proposed by ES6 will return a Promise that is marked up after the ES Modules is loaded. With this, we can import ES Modules asynchronously in CommonJS:

/ / b.mjsexport default 'esm baccarap / entry.js (async () = > {let {default: B} = await import ('. / b.mjs'); console.log (b); / / esm b}) ()

Introducing CommonJS into ES module

You can easily use import to reference a CommonJS module in an ES6 module, because asynchronous loading is not necessary in an ES6 module:

/ / a.cjsmodule.exports = 'commonjs commonjs from'. / commonjs a console.log (a)

So far, provide 2 demo for you to test whether the above knowledge points have been mastered, if not, you can go back to read.

Demo module.exports&exports

/ / a module exports.value = 2ramp / b module code let a = require ('. / a'); console.log (a); / / {value: 2}

Demo module.exports&exports

/ / a module exports = 2politics / b module code let a = require ('. / a'); console.log (a); / / {}

Require&_cache module caching mechanism

/ / origin.jslet count = 0 count++ exports.addCount = function () {count++} exports.getCount = function () {return count;} / / b.jslet {getCount} = require ('. / origin'); exports.getCount = getCount;// a.jslet {addCount, getCount: getValue} = require ('. / origin'); addCount (); console.log (getValue ()); / / 1let {getCount} = require ('. / b'); console.log (getCount ()); / / 1require.cache

According to the above example, the module is added to the cache object require.cache when require is introduced. If you need to delete the cache, you can consider clearing the contents of the cache, and the require module will reload the module next time.

Let count = 0political exports.addCount = function () {count++} exports.getCount = function () {return count;} / / b.jslet {getCount} = require ('. / origin'); exports.getCount = getCount;// a.jslet {addCount, getCount: getValue} = require ('. / origin'); addCount (); console.log (getValue ()); / / 1delete require.cache [require.resolve ('. / origin')]; let {getCount} = require ('. / b') Console.log (getCount ()); / / above is how to use the module system in Nodejs. The editor believes that there are some knowledge points that we may see or use in our daily work. I hope you can learn more from this article. For more details, please follow the industry information channel.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.