Análisis de las reglas de carga del método require en Node.js (demostración de código)

requieren reglas de carga de métodos

Los parámetros del método require también se denominan identificadores de módulo.

Hay tres tipos de identificadores de módulo:

El nombre del módulo del módulo principal, en formato sin ruta, como require('http')
El nombre del módulo del módulo de terceros, en forma sin ruta, como require('art-template')
- Todos los módulos de terceros se descargan a través de npm
- Cuando lo use, puede cargarlo discutiendo require (nombre)
- Es imposible que un módulo de terceros tenga el mismo nombre que el módulo principal , de lo contrario habrá conflictos
Módulos escritos por los propios usuarios, forma de ruta, como require('../xxx')

1. Primero cargue desde la caché

Demostración de código:

archivo main.js

require('./a');
let fn = require('./b');
console.log(fn);

archivo a.js

console.log('a被加载了');
let fn = require('./b')
console.log(fn);

archivo b.js

console.log('b被加载了');

module.exports = function () {
    
    
  console.log('hello');
}

El resultado de ejecutar main.js:

a被加载了
b被加载了
[Function]
[Function]

El resultado no es que "b is loading" saldrá dos veces como imaginamos, sino solo una vez. La salida "b is loading" se genera en el archivo a.js, pero el archivo main.js no se genera

Dado que b.js se ha cargado en a.js
, el código en b.js no se ejecutará repetidamente en main.js, solo obtendrá el valor exportado en b.js.
El propósito de esto es evitar la carga repetida Para mejorar la eficiencia de carga del módulo

requireEl método tiene dos funciones

Cargue el módulo de archivo y ejecute el código en él
Obtener el objeto de interfaz exportado desde el módulo de archivo cargado

require()El mecanismo de carga se carga nuevamente en el módulo, el nodo se almacenará en caché, y el segundo no se cumpliría si la implementación del código en el interior nuevamente, pero la caché en memoria de module.exports se hará cargo . Entonces, la función de la segunda carga es obtener el valor u objeto exportado dentro . El propósito de esto es evitar la carga repetida y mejorar la eficiencia de la carga del módulo .

2. Cargue el módulo principal

La esencia del módulo principal también es un archivo, pero se ha compilado en un archivo binario y se puede buscar directamente por nombre.

3. Cargue el módulo escrito por el usuario (formulario de ruta)

Use require(路径)para cargar, donde la ruta tiene las siguientes formas

./xxx
../xxx
/xxxAquí /representa el directorio raíz del disco al que pertenece el módulo de archivo actual, rara vez se usa
Utilice rutas absolutas, como D:\code\frontend\nodeProject\test.js(casi sin uso)
.jsEl sufijo de nombre se puede omitir, pero ./o ../no se puede omitir
nodo encontrará el módulo correspondiente de acuerdo con la ruta

4. Cargue módulos de terceros

Descargamos todos los módulos de terceros a través de npm y los cargamos a través de require ('nombre del paquete') cuando los usamos. Tenga en cuenta que en qué directorio se ejecuta el comando npm install, el directorio node_modules se generará en qué directorio. El nombre del paquete de terceros no puede ser el mismo que el del módulo principal. Ni es el módulo core, ni es una ruta en forma de módulos, buscamos siguiendo la ruta, instalamos uno primero npm install art-template, seguido de los módulos de terceros art-template, por ejemplo:

Estructura del directorio: lo usamos en el archivo main.js let template = require('art-template');para cargar
Inserte la descripción de la imagen aquí

4.1 Regla Uno

Primero busque el directorio node_modules en el directorio donde pertenece el archivo actual (main.js)
Encontrarnode_modules/art-template
Busque el node_modules/art-template/package.jsonarchivo, busque el mainatributo en este archivo , el valor de main es el archivo de entrada del módulo. Por ejemplo art-template, el valor de main en package.json en el directorio es index.js. Si instalamos otro jquery, require('jquery')buscaremos node_modules/jquery/package.jsonel main cuando lo usemos y encontraremos que dist/jquery.jses el archivo de entrada del módulo jquery
Luego cargue y use este paquete de terceros, de hecho, se carga el archivo final

4.2 Regla dos

Según la situación mencionada anteriormente, la carga es relativamente suave. Pero, ¿qué pasa si el archivo package.json no existe o el archivo de entrada especificado por main no existe?

La respuesta es: el nodo buscará index.js en este directorio, lo que significa que index.js se utilizará como una alternativa de archivo de entrada predeterminada.

Probémoslo: cree una nueva carpeta aaa en el directorio node_modules como módulo y cree nuevos archivos foo.js, index.js y package.json en la carpeta aaa. Luego cargue el módulo aaa de referencia en el archivo main.js. El código de cada archivo se muestra en la figura:

Inserte la descripción de la imagen aquí
Ejecución main.js, node main.jsla salida foo.js被加载了es:. La razón es que el valor de main que especificamos en el archivo package.json es foo.js. Cuando se carga el módulo aaa, el nodo buscará foo.js.

A continuación, configuramos el atributo principal en el archivo package.json en vacío, como se muestra en la figura.
Inserte la descripción de la imagen aquí
Ejecute main.js nuevamente. Creo que todos tienen claro el resultado index.js被加载了esta vez . El resultado es , porque en este caso el nodo buscará el directorio Index.js.

4.3 Regla Tres

Si alguna de las condiciones anteriores no es verdadera y no se encuentra en el directorio node_modules en el directorio actual, ingresará al directorio de nivel superior de node_modules para buscar, y las reglas específicas para encontrar módulos son las mismas que las anteriores (reglas 1 y 2).
Si el nivel superior aún no está allí, continúe hasta el nivel superior para encontrar el directorio raíz del disco. Si no se encuentra en el directorio raíz del disco, se informará un errorCannot find module xxx

para resumir

//bolg目录下有两个子目录，a目录和 b目录
blog目录

  -a目录
    -node_modules目录
    -foo.js文件

  -b目录
    -test.js
      ①在b目录中的test.js文件中想要加载a目录中的foo.js需要通过相对路径 require('../a/foo');
      ②在b目录中的test.js目录中是无法直接通过模块名加载a目录中的node_modules目录下的模块的,
      但是依然可以通过相对路径来加载 require('../a/node_modules/xxx')
      
      写这么一长串的路径很难受，因此node就搞出了上边总结的那些规则来简化代码的编写

Sin embargo, nuevamente, uno de nuestros proyectos solo tendrá un node_modules, que se ubicará en el directorio raíz del proyecto (quien no tenga nada que ver con múltiples directorios de node_modules), y el código en todos los subdirectorios del proyecto se puede cargar en El módulo correspondiente.

¡Pero tenemos que conocer las reglas para saberlas incluso saber por qué!

Otras lecturas

https://blog.csdn.net/weixin_43974265/category_10692693.html