Nodejs module.children 什么时候会有值？

Nodejs module.children 什么时候会有值？

var a = require(’./a’);
var b = require(’./b’);
var fs = require(‘fs’);


console.log(module.children);//[]

3 回复

Node.js module.children 什么时候会有值？

在 Node.js 中，module.children 是一个数组，它包含了当前模块（即正在执行的模块）所依赖的所有直接子模块。换句话说，如果你在一个模块中使用了 require() 来引入其他模块，那么这些被引入的模块就会出现在 module.children 数组中。

示例代码

假设我们有三个文件：

  • index.js
  • a.js
  • b.js

index.js 文件

// index.js
var a = require('./a');
var b = require('./b');
var fs = require('fs');

console.log(module.children);

a.js 文件

// a.js
module.exports = {
    name: 'Module A'
};

b.js 文件

// b.js
module.exports = {
    name: 'Module B'
};

在这个例子中，index.js 引入了 a.js 和 b.js，因此 module.children 应该包含这两个模块。

运行结果

当你运行 index.js 文件时，输出应该是：

[ <ref *1> Module {
    id: '/path/to/index.js',
    exports: [Circular],
    parent: undefined,
    filename: '/path/to/index.js',
    loaded: false,
    children: [
      <ref *2> Module {
        id: '/path/to/a.js',
        exports: { name: 'Module A' },
        parent: [Circular *1],
        filename: '/path/to/a.js',
        loaded: true,
        children: [],
        paths: [Array]
      },
      <ref *3> Module {
        id: '/path/to/b.js',
        exports: { name: 'Module B' },
        parent: [Circular *1],
        filename: '/path/to/b.js',
        loaded: true,
        children: [],
        paths: [Array]
      }
    ],
    paths: [ '/path/to/node_modules', ... ]
  } ]

可以看到，module.children 包含了 a.js 和 b.js 两个模块。

总结

module.children 会在你通过 require() 引入其他模块时有值。每个 require() 都会创建一个新的模块实例，并将其添加到当前模块的 children 属性中。因此，只要你在当前模块中使用了 require() 来引入其他模块，module.children 就会有相应的值。


exports.c = require('./c');
console.log(module.children); // output c

;)(;

module.children 是 Node.js 中的一个属性，它表示当前模块直接依赖的所有子模块。也就是说，当你使用 require 引入其他模块时，这些被引入的模块就会出现在 module.children 数组中。

在你的例子中，module.children 为空数组 [] 的原因是因为 module.children 只会在当前模块的执行上下文中被访问到时才可能包含值。如果你在同一个文件中打印 module.children，那么它可能不会包含任何值，因为此时还没有加载完所有的依赖。

示例代码

假设我们有以下三个文件：

index.js

var a = require('./a');
var b = require('./b');

console.log(module.children);

a.js

module.exports = {
    name: 'Module A'
};

b.js

module.exports = {
    name: 'Module B'
};

在这个例子中，当你运行 index.js 文件时，你会看到 module.children 包含了 a.js 和 b.js，因为这两个文件是通过 require 直接加载到 index.js 中的。

运行结果

$ node index.js
[ <ref *1> Module {
    id: '.',
    exports: [Circular],
    parent: null,
    filename: '/path/to/your/project/index.js',
    loaded: false,
    children: [
      <ref *2> Module {
        id: '/path/to/your/project/a.js',
        exports: { name: 'Module A' },
        parent: [Circular],
        filename: '/path/to/your/project/a.js',
        loaded: true,
        children: [],
        paths: [Array]
      },
      <ref *3> Module {
        id: '/path/to/your/project/b.js',
        exports: { name: 'Module B' },
        parent: [Circular],
        filename: '/path/to/your/project/b.js',
        loaded: true,
        children: [],
        paths: [Array]
      }
    ],
    paths: [ '/path/to/your/project/node_modules', ... ]
  }
]

可以看到，module.children 包含了两个子模块 a.js 和 b.js。

总结

module.children 会在当前模块的依赖被加载后才会有值，尤其是在当前模块的执行上下文中访问 module.children 时。

回到顶部