Common JS modular specification from a code question

CommonJS

stay node.js in , Use CommonJS As its modular specification .

according to CommonJS Modular specification , A single JS File is a module , Each module is a separate one Scope , Variables defined inside the module , Cannot read in other modules . If you want to communicate between modules , You need to use the export and import syntax of the module ：

• Module through variable exports Outward exposure API, Be careful ,exports It can only be one object , The properties of the object are exposed API.
• In another module , Through global functions require Import exported from other modules exports object .

Basic grammar

for example ,a.js Export objects from file exports, Which includes name、add attribute , They are constants defined in the file .

const name = 'Jack';

const add = (a, b) => a + b;

module.exports = {
    
  name,
  add
};

In the file b.js in , Through global functions require Import the exported object exports.

const api = require('./a');

console.log(api);
// { name: 'Jack', add: [Function: add] }

Be careful ,api This can be taken at will . Usually , It can also be done through Deconstruct assignment In the form of , Import on demand ：

const {
     name } = require('./a');

console.log(name);
// Jack

Multiple import

Follow the example above , If in b.js In file , Multiple import a modular , What will happen ？ Is the same object imported twice ？

const api1 = require('./a');
const api2 = require('./a');

console.log(api1 === api2);
// true

As shown in the above code ,b.js Introduced twice in a modular , And judge whether the two imported variables are equal . Results output true, Explain that if you quote more than once , In fact, the imported module is the same object .

actually , In the first import , Will execute the file to be imported , And cache an object in memory , among exports Is the object to import . When importing the same module again , It will not be implemented anymore , Will get this directly from memory exports object .

{
    
  id: '...', //  Module name 
  exports: {
     ... }, //  Interface of module output 
  loaded: true, //  Whether the script of the module is finished 
  ...
}

Whether changes are supported

The import module , In fact, it is to execute the module to be imported , And then the output of exports object , As require The return value of the function . It's actually ordinary Assignment statement , If you use var、let Make a statement , Of course, changes are supported .

let api1 = require('./a');

api1 = {
    };

console.log(api1);
// {}

Circular reference

If a module is loaded circularly , Output only the executed part , Unexecuted will not output .

If in a.js Introduction in b.js, stay b.js Introduction in a.js, Form a circular reference , Will it be wrong to report ？ If no error is reported , What is the result of the operation ？

It is clear to take code as an example . As shown in the following code ,a Module introduction b modular ,b Module introduction a modular .

// a.js
const b = require('./b');

console.log('b', b);

const name = 'Jack';
const age = 18;

module.exports = {
    
  name,
  age
};

// b.js
const a = require('./a');

console.log('a', a);

const id = '001';

module.exports = {
    
  id
};

function node a.js, The console output is as follows ：

a {
    }
b {
     id: '001' }

No report error , The normal operation . This is because of the reasons mentioned above ： If a module is loaded circularly , Output only the executed part , Unexecuted will not output .

A brief analysis of ：

• function node a.js. First go to a modular ,a The module is imported at the beginning b modular , Then it will be executed first b.js, Then return b.js Derived exports The object is to a Constant in module b.
• perform b.js. At the beginning, I imported a.js. however a.js Not completed , Only the executed part will be returned . because a.js Exported is name、age, here a.js Only execute until 1 That's ok , So actually import at this time a.js, Only empty objects will be returned , because name、age Not yet implemented to . therefore require('./a') Return empty object , Assign to constant a, So print it out An empty object .
• So let's continue b.js, Finish executing the rest of the code , Normal export exports object , Which includes id attribute .
• After execution , Back to the a.js In the first line of ,require('./b') return b Derived exports object , Contains id attribute . therefore , The following can be printed normally { id: '001' }.
• And then a.js in , Finish executing the remaining code .

Thinking questions

Yes a.js、b.js、c.js Three files , perform node a.js, What will the console output ？

// a.js
const b = require('./b');

console.log(exports.x);

exports.x = 'x';

require('./c');

// b.js

const a = require('./a');

console.log(a);

a.x = 'y';

// c.js
const a = require('./a');

console.log(a.x);

answer ：

{
    }
y
x

---

The above is what I learned , If there is something wrong , Welcome the criticism that ！