CommonJS规范以及 node中exports和module.exports的区别

. . . . .

已于 2023-12-06 00:49:21 修改

阅读量480

点赞数 2

分类专栏： Node 文章标签： node.js

于 2022-01-03 18:55:20 首次发布

本文链接：https://blog.csdn.net/yexudengzhidao/article/details/122290891

版权

Node 专栏收录该内容

27 篇文章 0 订阅

订阅专栏

要想知道exports和module.exports的区别，我们先来看一下CommonJS规范。

1. 概述

Node 应用由模块组成，采用 CommonJS 模块规范。

每个文件就是一个模块，有自己的作用域。在一个文件里面定义的变量、函数、类，都是私有的，对其他文件不可见。

// example.js
var x = 5;
var addX = function (value) {
  return value + x;
};

上面代码中，变量x和函数addX，是当前文件example.js私有的，其他文件不可见。

如果想在多个文件分享变量，必须定义为global对象的属性。

global.warning = true;

上面代码的warning变量，可以被所有文件读取。当然，这种写法是不推荐的。

CommonJS规范规定，每个模块内部，module变量代表当前模块。这个变量是一个对象，它的exports属性（即module.exports）是对外的接口。加载某个模块，其实是加载该模块的module.exports属性。

var x = 5;
var addX = function (value) {
  return value + x;
};
module.exports.x = x;
module.exports.addX = addX;

上面代码通过module.exports输出变量x和函数addX。

require方法用于加载模块。

var example = require('./example.js');

console.log(example.x); // 5
console.log(example.addX(1)); // 6

CommonJS模块的特点如下：

所有代码都运行在模块作用域，不会污染全局作用域。
模块可以多次加载，但是只会在第一次加载时运行一次，然后运行结果就被缓存了，以后再加载，就直接读取缓存结果。要想让模块再次运行，必须清除缓存。
模块加载的顺序，按照其在代码中出现的顺序。

2. module对象

Node内部提供一个Module构建函数。所有模块都是Module的实例。

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

每个模块内部，都有一个module对象，代表当前模块。它有以下属性。

module.id 模块的识别符，通常是带有绝对路径的模块文件名。
module.filename 模块的文件名，带有绝对路径。
module.loaded 返回一个布尔值，表示模块是否已经完成加载。
module.parent 返回一个对象，表示调用该模块的模块。
module.children 返回一个数组，表示该模块要用到的其他模块。
module.exports 表示模块对外输出的值。

下面是一个示例文件，最后一行输出module变量。

// example.js
var jquery = require('jquery');
exports.$ = jquery;
console.log(module);

执行这个文件，命令行会输出如下信息。

{ id: '.',
  exports: { '$': [Function] },
  parent: null,
  filename: '/path/to/example.js',
  loaded: false,
  children:
   [ { id: '/path/to/node_modules/jquery/dist/jquery.js',
       exports: [Function],
       parent: [Circular],
       filename: '/path/to/node_modules/jquery/dist/jquery.js',
       loaded: true,
       children: [],
       paths: [Object] } ],
  paths:
   [ '/home/user/deleted/node_modules',
     '/home/user/node_modules',
     '/home/node_modules',
     '/node_modules' ]
}

如果在命令行下调用某个模块，比如node something.js，那么module.parent就是null。如果是在脚本之中调用，比如require('./something.js')，那么module.parent就是调用它的模块。利用这一点，可以判断当前模块是否为入口脚本。

if (!module.parent) {
    // ran with `node something.js`
    app.listen(8088, function() {
        console.log('app listening on port 8088');
    })
} else {
    // used with `require('/.something.js')`
    module.exports = app;
}

2.1 module.exports属性

module.exports属性表示当前模块对外输出的接口，其他文件加载该模块，实际上就是读取module.exports变量。

2.2 exports变量

为了方便，Node为每个模块提供一个exports变量，指向module.exports。这等同在每个模块头部，有一行这样的命令。

var exports = module.exports;

因此，在对外输出模块接口时，可以向exports对象添加方法。

exports.area = function (r) {
  return Math.PI * r * r;
};

exports.circumference = function (r) {
  return 2 * Math.PI * r;
};

注意，不能直接将exports变量指向一个值，因为这样等于切断了exports与module.exports的联系。

exports = function(x) {console.log(x)};

上面这样的写法是无效的，因为exports不再指向module.exports了。

下面的写法也是无效的。

exports.hello = function() {
  return 'hello';
};

module.exports = 'Hello world';

上面代码中，hello函数是无法对外输出的，因为module.exports被重新赋值了。

这意味着，如果一个模块的对外接口，就是一个单一的值，不能使用exports输出，只能使用module.exports输出，因为这样会切断了exports与module.exports的联系。

3. AMD、CommonJS和UMD都是用于在JavaScript中实现模块化的规范，它们的联系和区别如下：

联系：

都旨在解决JavaScript代码的模块化管理问题，使代码更易于维护、复用和扩展。
都支持将代码分割成独立的模块，并通过导入和导出来实现模块之间的依赖关系。

区别：

AMD（Asynchronous Module Definition）是一种异步加载模块的规范，主要用于浏览器环境。它使用define函数定义模块，并通过require函数异步加载依赖模块。
CommonJS是一种同步加载模块的规范，主要用于服务器端（如Node.js）环境。它使用module.exports导出模块，使用require函数同步加载依赖模块。
UMD（Universal Module Definition）是一种通用的模块定义规范，旨在兼容AMD和CommonJS规范，使得同一个模块可以在浏览器和服务器端都能够正常运行。UMD规范使用一定的代码结构和逻辑来判断当前环境，并选择合适的加载方式。

总结来说，AMD适用于浏览器环境、异步加载；CommonJS适用于服务器端环境、同步加载；而UMD则是一种通用的规范，可以在不同环境中使用。

UMD规范的语法可以通过以下示例来说明：

(function (root, factory) {
    if (typeof define === 'function' && define.amd) {
        // AMD环境
        define(['dependency'], factory);
    } else if (typeof module === 'object' && module.exports) {
        // CommonJS环境
        module.exports = factory(require('dependency'));
    } else {
        // 全局变量环境
        root.MyModule = factory(root.Dependency);
    }
}(typeof self !== 'undefined' ? self : this, function (Dependency) {
    // 模块的代码逻辑
    var MyModule = {};

    // ...

    return MyModule;
}));