使用require()方法加载模块&模块作用域&module对象

使用require()方法加载模块

// 加载内置模块
const fs = require('fs')

// 加载用户自定义模块
// const m1 = require('./06.m1.js')
// 使用require()方法加载自定义模块的时候，后缀名可以省略
const m1 = require('./06.m1')
console.log(m1);

// 加载第三方模块
const moment = require('moment')

模块作用域
在自定义模块中的方法，变量等，只能在当前模块内被访问，这种模块级别的访问限制，叫作模块作用域；

模块作用域的好处：防止全局变量污染的问题；

// 当前这个文件 就是用户自定义模块
console.log('加载了06这个用户自定义模块');
const niuniuname = '牛牛'

function sayHello(){
    console.log('大家好我是' + niuniuname);
}
sayHello()

//在另外一个test.js文件中调用
const m1 = require('./06.m1')
console.log(m1); //{} 返回空对象
sayHello()//也无法调用m1.js里面的函数 sayHello is not defined

module对象
每个.js自定义模块都会有module对象，里面存储了和当前相关的信息；

console.log(module);//返回module对象


Module {
  id: '.',
  path: 'F:\\前端\\Node.js基础\\files\\模块加载',
  exports: {},
  filename: 'F:\\前端\\Node.js基础\\files\\模块加载\\07.test.js',
  loaded: false,
  children: [
    Module {
      id: 'F:\\前端\\Node.js基础\\files\\模块加载\\06.m1.js',
      path: 'F:\\前端\\Node.js基础\\files\\模块加载',
      exports: {},
      filename: 'F:\\前端\\Node.js基础\\files\\模块加载\\06.m1.js',
      loaded: true,
      children: [],
      paths: [Array]
    }
  ],
  paths: [
    'F:\\前端\\Node.js基础\\files\\模块加载\\node_modules',
    'F:\\前端\\Node.js基础\\files\\node_modules',
    'F:\\前端\\Node.js基础\\node_modules',
    'F:\\前端\\node_modules',
    'F:\\node_modules'
  ]
}

module对象中的exports属性
在自定义模块中，可以通过module.exports对象，将模块内的成员共享出去，供外界使用。外界使用require()方法导入模块时，得到的就是module.exports所指向的对象；

// 向module.exports 对象上挂载了nounouname属性
module.exports.niuniuname = '牛牛'

// 向module.exports 对象上挂载了sayHello方法
module.exports.sayHello = function(){
    console.log('Hello!' );
}


const m1 = require('./06.m1')
console.log(m1);
//返回{ nounouname: '牛牛', sayHello: [Function (anonymous)] }

共享成员时，以module.exports指向的对象为准;

// 向module.exports 对象上挂载了nounouname属性
module.exports.niuniuname = '牛牛'

// 向module.exports 对象上挂载了sayHello方法
module.exports.sayHello = function(){
    console.log('Hello!' + niuniuname);
}

// 让module.exports指向一个全新的对象
module.exports = {
    nickname: '小黑',
    sayHi() {
        console.log('Hi!');
    }
}

const m1 = require('./06.m1')
console.log(m1);
//指向了最新的对象{ nickname: '小黑', sayHi: [Function: sayHi] }

因为module.exports写法复杂，node提供了exports对象，默认情况下module.exports和exports指同一对象；
但是最终都以module.exports指向的对象为准;

const nickname = '小白'
exports.nickname = nickname
exports.age = '1'
exports.sayHello = function(){
    console.log('大家好');
}


const m1 = require('./06.m1')
console.log(m1);//{ nickname: '小白', age: '1', sayHello: [Function (anonymous)] }

使用误区一：谨记，require()模块时，得到的永远是module.exports 指向的对象；

const nickname = '小白'
exports.nickname = nickname

module.exports = {
    gender: '男',
    age: 2
}

const m1 = require('./06.m1')
console.log(mi);//{ gender: '男', age: 2 }

const nickname = '小白'
module.exports.nickname = nickname

exports = {
    gender: '男',
    age: 2
}

const m1 = require('./06.m1')
console.log(m1);//{ nickname: '小白' }

// 两个都是属性，最后会输出{ nickname: '小黑狗', gender: '公' }的对象
exports.nickname = '小黑狗'
module.exports.gender = '公'

const m1 = require('./06.m1')
console.log(m1);//{ nickname: '小黑狗', gender: '公' }

exports = {
    nickname: '肥肥',
    gender: '公'
}

// 两个都是属性，最后会输出{ nickname: '小黑狗', gender: '公' }的对象
module.exports = exports
module.exports.age = '22'

const m1 = require('./06.m1')
console.log(m1);//{ nickname: '肥肥', gender: '公', age: '22' }