美文网首页
nodejs笔记-模块机制

nodejs笔记-模块机制

作者: maikuraki | 来源:发表于2018-01-28 23:47 被阅读18次

    1.为什么要CommonJS规范

    javascript存在的缺点

    • 没有模块系统
    • 标准库比较少
    • 没有标准接口
    • 缺乏包管理系统

    CommonJS规范的提出,弥补了javascript没有标准的缺陷,以达到像Python、Ruby、Java具备的开发大型应用的基础能力,这样javascript不仅仅能在客户端应用还能开发以下应用:

    • 服务端应用
    • 命令行工具
    • 桌面图形界面应用
    • 混合应用

    2.CommonJS的模块规范

    1.模块引入

    使用require()来引入 ,接受一个模块标识。

    let math = require('math');
    

    2.定义模块

    上下文提供里exports对象用于导出模块或变量,并且是唯一导出出口。在模块中存在一个module对象,代表模块自身,exports是它的一个属性。在nodejs中一个文件就是一个模块,把方法挂在exports对象上作为属性即可定义导出

    //math.js
    exports.add = function(){
        let sum = 0,
            i = 0,
            args = arguments,
            l = args.length;
        while(i < l) {
            sum += args[i ++];
        }
        return sum;
    }
    

    在另一个文件require使用

    const math = require('./math');
    let res = math.add(1, 2, 3);
    console.log(res)
    //6
    

    3.模块标识

    模块标识为require()的参数必须是符合小驼峰命名的字符串,或以.、..开头的相对路径,或绝对路径,可以是没有.js后缀的js文件。
    模块中定义的全局变量只作用于该文件内部,不污染其他模块。

    4.Node模块实现

    Node中引入模块需经历以下步骤:

    1. 路径分析
    2. 文件定位
    3. 编译执行

    Node中模块分为两类: 1.Node提供的 "核心模块",2.用户编写的 "文件模块"
    核心模块Node源码编译时已经编译成二进制执行文件,Node启动时直接加载进内存中,不需要文件定位和编译执行两个步骤,且在路径分析中优先判断,加载速度最快。

    1.优先从缓存加载

    Node会对引入过的模块进行缓存,核心模块和文件模块相同的模块在二次加载时一律从缓存优先加载(第一优先级),核心模块缓存检测优先于文件模块缓存检测。

    2.路径分析文件定位

    1.模块标识符分析

    标识符分类:

    • 核心模块,如http、fs、path等
    • .或..开始的相对路径文件模块
    • 以/开头的绝对路径模块
    • 非路径形式的文件模块,如自定义的connect模块 一个文件或一个包
    2.自定义模块
    console.log(module.paths)
    //[ 'c:\\Users\\maikuraki\\Desktop\\nodejs\\node_modules',
      'c:\\Users\\maikuraki\\Desktop\\node_modules',
      'c:\\Users\\maikuraki\\node_modules',
      'c:\\Users\\node_modules',
      'c:\\node_modules' ]
    

    Node会逐个路径尝试知道找到目标文件,模块路径越深耗时越多。

    3.文件定位

    标识符可以不包含文件扩展,这种情况下Node会安装.js、.json、.node次序补全扩展名。
    如果是个包Node会检测里面的package.json文件Node通过JOSN.parse()解析出包的描述对象去除main属性指向的文件进行定位,如果没有该属性默认查找index.js、index.json、index.node。

    3.模块编译

    在Node中每个文件模块都是一个对象。
    编译和执行是引入文件模块的最后一个阶段,定位到一个文件后,Node会新建一个模块对象,然后根据路径载入并编译。不同扩展名载入方式:

    • .js 通过fs模块读取后编译执行
    • .node 这是C/C++编写的扩展文件,通过dlopen()方法加载最后编译生成文件
    • .json 通过fs模块读取文件使用JSON.parse()解析并返回
    • 其他扩展名文件 当做.js文件载入
    1.javascript模块的编译

    在编译过程中Node对获取的javascript文件进行的头尾包装

    (function(exports, require, module, __filename, __dirname) {
        exports.add = (x, y) => {
            return x + y;
        }
    })
    

    这样每个模块文件直接都进行了作用域隔离,这就是Node对CommonJS规范的实现。

    2.C/C++模块编译

    Node调用process.dlopen()来进行加载执行,windows和*nix平台下dlopen()通过不同方式实现,通过libuv兼容层进行封装。

    3.JSON文件编译

    Node使用fs模块读取json文件内容,使用JSON.parse()得到对象然后给他赋给模块对象的exports属性。

    4.核心模块

    核心模块分为C/C++编写和javascript编写,C/C++存放在Node项目的src文件下,javascript文件存在lib目录下。
    核心模块中有些模块核心部分使用C/C++完成其他使用javascript实现包装导出。由纯C/C++编写的部分称为内建模块,例:buffer、crypto、evals、fs、os等模块部分使用C/C++编写。

    依赖层关系: 内建模块(C/C++) ---> 核心模块(javascript)---> 文件模块

    核心模块的引入流程
    以os原生模块引入为例

    NODE_MODULE(node_os,reg_func) ---> get_builtin_module('node_os') ---> process.binding('os') ---> NativeModule.require('os') ---> require('os')

    5.C/C++扩展模块

    1.扩展模块在不同平台上编译和加载过程

    Windows
    C/C++源码 ---> VC++ --编译源码--> .dll文件 --生成.node文件--> 加载.dll文件 --dlopen()加载--> 导出给javascript使用
    *nix
    C/C++源码 ---> g++/gcc --编译源码--> .so文件 --生成.node文件--> 加载.so文件 --dlopen()加载--> 导出给javascript使用

    2.编译条件
    • node-gyp工具
    • V8引擎C++库
    • libuv库
    • Node内部库
    • 其他库
    3.C/C++扩展模块的加载

    require()引入.node文件过程

    javascript(require('./hello.node')) ---> 原生模块(process.dlopen('./hello.node',exports)) ---> libuv(uv_dlopen()/uv_dlsym()) ---> [{*nix: dlopen()/dlsym(), Windows : loadLibraryExW()/GetProcAddress()}]

    6.包与NPM

    包结构:

    • package.json 包描述文件
    • bin 存放可执行位二进制文件
    • lib 存放javascript文件
    • doc 存放文档
    • test 存放单元测试

    7.前后端公用模块

    1.AMD规范

    AMD规范是CommonJS规范的一个延伸,定义模块方法:

    define(id?, dependencies?, factory);
    
    define(function() {
        let exports = {};
        exports.sayHello = () => {
            console.log(`hello form module: ${module.id}`);
        }
        return exports;
    })
    
    2.CMD规范

    CMD与AMD规范的主要区别在于定义模块和依赖引入的部分。AMD需要在声明的时候指定所有依赖,通过形参传递依赖到模块中:

    define(['dep1', 'dep2'], function() {
        return function() {}
    })
    

    于AMD规范相比,CMD模块更接近与Node对CommonJS规范的定义:

    define(factory);
    

    在依赖部分,CMD支持动态引入:

    define(function(require, exports, module) {
        // module code
    })
    

    require,exports,module通过形参传递给模块,在需要依赖模块时随时调用require()引入。

    兼容多种模块规范

    ((name, definition) => {
        //检测是否为AMD或者CMD
        let hasDefine = typeof define === 'function',
            //检测是否为Node
            hasExports = typeof module !== 'undefined' && 'module.exports';
        if(hasDefine) {
            //AMD或CMD环境
            define(definition);
        }else if(hasExports) {
            //定义为普通Node模块
            module.exports = definition();
        }else {
            //将模块执行结果挂载在window对象下
            this[name] = definition;
        }
    })('hello', function() {
        let hello = () => {};
        return helllo;
    })
    

    相关文章

      网友评论

          本文标题:nodejs笔记-模块机制

          本文链接:https://www.haomeiwen.com/subject/bxstzxtx.html