How does require() work in Node.js? Introduction to working principle

Related recommendations: "nodejs Tutorial"

Most people know what the require() function in Node.js does, but there are How many people know how it works? We use it every day to load library packages and modules, but its internal behavior is mysterious.

We are pursuing the core of Node module system: module.js. This file contains a surprising magical function. It is responsible for loading, compiling and caching each used file. Let us unveil its mystery. .

function Module(id, parent) { this.id = id; this.exports = {}; this.parent = parent; // ...

This Module type can be found in module.js and plays two main roles: First, it provides a basic functionality for all Node.js modules to build an instance when it is loaded from its file, even in the file Runtime persistence, that's why we can add some properties to module.exports and return them when needed.

The second thing of module is to handle the loading mechanism of Node module. The standard require function is actually based on the abstraction of module.require. The latter is just a simple wrapper for Module._load. The loading method handles each The actual loading of the file. Take a look at its code as follows:

Module._load = function(request, parent, isMain) { // 1.在Module._cache中检查模块是否被缓存 // 2.如果缓存中为空，创建一个新的模块实例。 // 3. 保存到缓存 // 4. 使用指定的名称调用module.load() // 在读取了文件内容后将调用module.compile() // 5.如果加载和分析文件时有错误 // 从缓存中删除坏的模块 // 6. 返回 module.exports };

Module._load is responsible for loading new modules and managing the module cache. Caching each module can reduce the frequency of file reading, thus improving performance. Shared module instances allow like a single Save state across applications like an example module.

If a module does not exist in the cache, Module._load will read the file and create a new one. After successfully reading the file content, module._compile will be called

If you pay attention to the sixth step above Step 1, you will see that module.exports is returned, which is why when you define the public interface, you can use exports and module.exports, because they are indeed returned by Model._load and require.

Let’s take a look at module._compile:

Module.prototype._compile = function(content, filename) { // 1. 创建调用模块需要的require标准函数 // 2.将其他帮助方法加入require. // 3.包装JS代码到一个函数，这个函数提供我们的require // 模块, 比如变量本地化到模块的作用域 // 4.返回这个函数 };

The magic happens here. First, a special standard require function will be created. This is the require() function we are familiar with. When the function itself Wrapping Module.require, it also contains some helper properties and methods that few people know, such as:

• require(): Load an external module

• require.resolve(): Resolve the module name according to its absolute path

• require.main: The main module

• require. cache: All cache modules

• require.extensions: File-based extensions available for compiled methods.

Once require is ready, the entire source code will be wrapped into a new function. This function takes the require module and exports and other exposed variables as parameters. This creates a new function of the module. scope so that it doesn't pollute the rest of the Node.js environment.

(function (exports, require, module, __filename, __dirname) { // YOUR CODE INJECTED HERE! 你的代码在这里 });

Finally, the function that wraps the module will run, and the entire Module._compile method will be executed synchronously, so that the original call to the Module._load method will wait for this code to run before it completes and returns to module.exports to users.

Now, we already know how require('module') loads the module you define through the module system. The module.js source code contains more code principles. You can discover more if you are interested.

For more programming-related knowledge, please visit:Programming Teaching! !

The above is the detailed content of How does require() work in Node.js? Introduction to working principle. For more information, please follow other related articles on the PHP Chinese website!