手册   游戏   WEB   字典   单词   在线工具  

在 Node.js 中看 JavaScript 的引用

早期学习 Node.js 的时候 (2011-2012), 有挺多是从 PHP 转过来的, 当时有部分人对于 Node.js 编辑完代码需要重启一下表示麻烦(PHP 不需要这个过程), 于是社区里的朋友就开始提倡使用 node-supervisor 这个模块来启动项目, 可以编辑完代码之后自动重启. 不过相对于 PHP 而言依旧不够方便, 因为 Node.js 在重启以后, 之前的上下文都丢失了.

虽然可以通过将 session 数据保存在数据库或者缓存中来减少重启过程中的数据丢失, 不过如果是在生产的情况下, 更新代码的重启间隙是没法处理请求的(PHP 可以, 另外那个时候 Node.js 还没有 cluster). 由于这方面的问题, 加上本人是从 PHP 转到 Node.js 的, 于是从那时开始思考, 有没有办法可以在不重启的情况下热更新 Node.js 的代码.

最开始把目光瞄向了 require 这个模块. 想法很简单, 因为 Node.js 中引入一个模块都是通过 require 这个方法加载的. 于是就开始思考 require 能不能在更新代码之后再次 require 一下. 尝试如下:

a.js

  1. var express = require('express');
  2. var b = require('./b.js');
  3. var app = express();
  4. app.get('/', function (req, res) {
  5.   b = require('./b.js');
  6.   res.send(b.num);
  7. });
  8. app.listen(3000);

b.js

exports.num = 1024;

两个 JS 文件写好之后, 从 a.js 启动, 刷新页面会输出 b.js 中的 1024, 然后修改 b.js 文件中导出的值, 例如修改为 2048. 再次刷新页面依旧是原本的 1024.

再次执行一次 require 并没有刷新代码. require 在执行的过程中加载完代码之后会把模块导出的数据放在 require.cache 中. require.cache 是一个 { } 对象, 以模块的绝对路径为 key, 该模块的详细数据为 value. 于是便开始做如下尝试:

a.js

  1. var path = require('path');
  2. var express = require('express');
  3. var b = require('./b.js');
  4. var app = express();
  5. app.get('/',
  6. function(req, res) {
  7.     if (true) { // 检查文件是否修改
  8.         flush();
  9.     }
  10.     res.send(b.num);
  11. });
  12. function flush() {
  13.     delete require.cache[path.join(__dirname, './b.js')];
  14.     b = require('./b.js');
  15. }
  16. app.listen(3000);

再次 require 之前, 将 require 之上关于该模块的 cache 清理掉后, 用之前的方法再次测试. 结果发现, 可以成功的刷新 b.js 的代码, 输出新修改的值.

了解到这个点后, 就想通过该原理实现一个无重启热更新版本的 node-supervisor. 在封装模块的过程中, 出于情怀的原因, 考虑提供一个类似 PHP 中 include 的函数来代替 require 去引入一个模块. 实际内部依旧是使用 require 去加载. 以 b.js 为例, 原本的写法改为 var b = include('./b'), 在文件 b.js 更新之后 include 内部可以自动刷新, 让外面拿到最新的代码.

但是实际的开发过程中, 这样很快就碰到了问题. 我们希望的代码可能是这样:

  1. web.js
  2. var include = require('./include');
  3. var express = require('express');
  4. var b = include('./b.js');
  5. var app = express();
  6. app.get('/', function (req, res) {
  7.   res.send(b.num);
  8. });
  9. app.listen(3000);

但按照这个目标封装 include 的时候, 我们发现了问题. 无论我们在 include.js 内部中如何实现, 都不能像开始那样拿到新的 b.num.

对比开始的代码, 我们发现问题出在少了 b = xx. 也就是说这样写才可以:

  1. web.js
  2. var include = require('./include');
  3. var express = require('express');
  4. var app = express();
  5. app.get('/', function (req, res) {
  6.   var b = include('./b.js');
  7.   res.send(b.num);
  8. });
  9. app.listen(3000);

修改成这样, 就可以保证每次能可以正确的刷新到最新的代码, 并且不用重启实例了. 读者有兴趣的可以研究这个 include 是怎么实现的, 本文就不深入讨论了, 因为这个技巧使用度不高, 写起起来不是很优雅[1], 反而这其中有一个更重要的问题 --JavaScript 的引用.

JavaScript 的引用与传统引用的区别

要讨论这个问题, 我们首先要了解 JavaScript 的引用于其他语言中的一个区别, 在 C++ 中引用可以直接修改外部的值:

  1. #include <iostream>
  2. using namespace std;
  3. void test(int &p) // 引用传递
  4. {
  5.     p = 2048;
  6. }
  7. int main()
  8. {
  9.     int a = 1024;
  10.     int &p = a; // 设置引用 p 指向 a
  11.     test(p); // 调用函数
  12.     cout <<"p:" << p << endl; // 2048
  13.     cout << "a:" << a << endl; // 2048
  14.     return 0;
  15. }

而在 JavaScript 中:

  1. var obj = { name: 'Alan' };
  2. function test1(obj) {
  3.   obj = { hello: 'world' }; // 试图修改外部 obj
  4. }
  5. test1(obj);
  6. console.log(obj); // { name: 'Alan' } // 并没有修改
  7. function test2(obj) {
  8.   obj.name = 'world'; // 根据该对象修改其上的属性
  9. }
  10. test2(obj);
  11. console.log(obj); // { name: 'world' } // 修改成功

我们发现与 C++ 不同, 根据上面代码 可知 JavaScript 中并没有传递一个引用, 而是拷贝了一个新的变量, 即值传递. 根据 可知拷贝的这个变量是一个可以访问到对象属性的 "引用"(与传统的 C++ 的引用不同, 下文中提到的 JavaScript 的引用都是这种特别的引用). 这里需要总结一个绕口的结论: Javascript 中均是值传递, 对象在传递的过程中是拷贝了一份新的引用.

为了理解这个比较拗口的结论, 让我们来看一段代码:

  1. var obj = {
  2.     data: {}
  3. };
  4. // data 指向 obj.data
  5. var data = obj.data;
  6. console.log(data === obj.data); // true-->data 所操作的就是 obj.data
  7. data.name = 'Alan';
  8. data.test = function() {
  9.     console.log('hi')
  10. };
  11. // 通过 data 可以直接修改到 data 的值
  12. console.log(obj) // { data: { name: 'Alan', test: [Function] } }
  13. data = {
  14.     name: 'Bob',
  15.     add: function(a, b) {
  16.         return a + b;
  17.     }
  18. };
  19. // data 是一个引用, 直接赋值给它, 只是让这个变量等于另外一个引用, 并不会修改到 obj 本身
  20. console.log(data); // { name: 'Bob', add: [Function] }
  21. console.log(obj); // { data: { name: 'Alan', test: [Function] } }
  22. obj.data = {
  23.     name: 'Bob',
  24.     add: function(a, b) {
  25.         return a + b;
  26.     }
  27. };
  28. // 而通过 obj.data 才能真正修改到 data 本身
  29. console.log(obj); // { data: { name: 'Bob', add: [Function] } }

通过这个例子我们可以看到, data 虽然像一个引用一样指向了 obj.data, 并且通过 data 可以访问到 obj.data 上的属性. 但是由于 JavaScript 值传递的特性直接修改 data = xxx 并不会使得 obj.data = xxx.

打个比方最初设置 var data = obj.data 的时候, 内存中的情况大概是:

| Addr | 内容 |

|----------|--------

| obj.data | 内存 1 |

| data | 内存 1 |

所以通过 data.xx 可以修改 obj.data 的内存 1.

然后设置 data = xxx, 由于 data 是拷贝的一个新的值, 只是这个值是一个引用 (指向内存 1) 罢了. 让它等于另外一个对象就好比:

| Addr | 内容 |

|----------|--------

| obj.data | 内存 1 |

| data | 内存 2 |

让 data 指向了新的一块内存 2.

如果是传统的引用(如上文中提到的 C++ 的引用), 那么 obj.data 本身会变成新的内存 2, 但 JavaScript 中均是值传递, 对象在传递的过程中拷贝了一份新的引用. 所以这个新拷贝的变量被改变并不影响原本的对象.

Node.js 中的 module.exports 与 exports

上述例子中的 obj.data 与 data 的关系, 就是 Node.js 中的 module.exports 与 exports 之间的关系. 让我们来看看 Node.js 中 require 一个文件时的实际结构:

  1. function require(...) {
  2.     var module = {
  3.         exports: {}
  4.     }; ((module, exports) =>{ // Node.js 中文件外部其实被包了一层自执行的函数
  5.         // 这中间是你模块内部的代码.
  6.         function some_func() {};
  7.         exports = some_func;
  8.         // 这样赋值, exports 便不再指向 module.exports
  9.         // 而 module.exports 依旧是{}
  10.         module.exports = some_func;
  11.         // 这样设置才能修改到原本的 exports
  12.     })(module, module.exports);
  13.     return module.exports;
  14. }

所以很自然的:

  1. console.log(module.exports === exports); // true
  2. // 所以 exports 所操作的就是 module.exports

Node.js 中的 exports 就是拷贝的一份 module.exports 的引用. 通过 exports 可以修改 Node.js 当前文件导出的属性, 但是不能修改当前模块本身. 通过 module.exports 才可以修改到其本身. 表现上来说:

  1. exports = 1; // 无效
  2. module.exports = 1; // 有效

这是二者表现上的区别, 其他方面用起来都没有差别. 所以你现在应该知道写 module.exports.xx = xxx; 的人其实是多写了一个 module..

更复杂的例子

为了再练习一下, 我们在来看一个比较复杂的例子:

  1. var a = {n: 1};
  2. var b = a;
  3. a.x = a = {n: 2};
  4. console.log(a.x);
  5. console.log(b.x);

按照开始的结论我们可以一步步的来看这个问题:

  1. var a = {n: 1};   // 引用 a 指向内存 1{n:1}
  2. var b = a;        // 引用 b => a => { n:1 }

内部结构:

| Addr | 内容 |

|---------|-------------|

| a | 内存 1 {n:1} |

| b | 内存 1 |

继续往下看:

a.x = a = {n: 2}; // (内存 1 而不是 a ).x = 引用 a = 内存 2 {n:2}

a 虽然是引用, 但是 JavaScript 是值传的这个引用, 所以被修改不影响原本的地方.

| Addr | 内容 |

|-----------|-----------------------|

| 1) a | 内存 2({n:2}) |

| 2) 内存 1.x | 内存 2({n:2}) |

| 3) b | 内存 1({n:1, x: 内存 2}) |

所以最后的结果

a.x 即(内存 2).x ==> {n: 2}.x ==> undefined

b.x 即(内存 1).x ==> 内存 2 ==> {n: 2}

总结

JavaScrip t 中没有引用传递, 只有值传递. 对象 (引用类型) 的传递只是拷贝一个新的引用, 这个新的引用可以访问原本对象上的属性, 但是这个新的引用本身是放在另外一个格子上的值, 直接往这个格子赋新的值, 并不会影响原本的对象. 本文开头所讨论的 Node.js 热更新时碰到的也是这个问题, 区别是对象本身改变了, 而原本拷贝出来的引用还指向旧的内存, 所以通过旧的引用调用不到新的方法.

Node.js 并没有对 JavaScript 施加黑魔法, 其中的引用问题依旧是 JavaScript 的内容. 如 module.exports 与 exports 这样隐藏了一些细节容易使人误会, 本质还是 JavaScript 的问题. 另外推荐一个关于 Node.js 的进阶教程 Node.js 面试 https://github.com/ElemeFE/node-interview .

注[1]:

老实说, 模块在函数内声明有点谭浩强的感觉.

把 b = include(xxx) 写在调用内部, 还可以通过设置成中间件绑定在公共地方来写.

除了写在调用内部, 也可以导出一个工厂函数, 每次使用时 b().num 一下调用也可以.

还可以通过中间件的形式绑定在框架的公用对象上(如: ctx.b = include(xxx)).

要实现这样的热更新必须在架构上就要严格避免旧代码被引用的可能性, 否则很容易写出内存泄漏的代码.

来源: http://www.codeceo.com/javascript-reference-in-node-js.html


与本文相关文章

  1. TCP,HTTP 和 Node.js 的那些事
  2. 从 Brain.js 到 Mind, 一文收录 11 个移动端 Javascript 机器学习库
  3. node.js 与 ThreadLocal
  4. javascript js 等待多少秒
  5. JavaScript 编程精解 中文第三版 二十, Node.js
  6. JavaScript 和 React,React 用了大量语法糖, 让 JS 编写更方便.
  7. Node.js child_process 模块解读
  8. node.js 与比特币 (typescript 实现)
暂无,快来抢沙发吧！
更多





黑ICP备17005318号-1