问题背景 #

你已经在index.js中初始化了Socket.io，希望把io对象传递给路由模块routes.js，同时对Node.js的模块工作机制还有些困惑。先看看你现有的代码：

index.js #

const express = require('express'); 
const app = express(); 
var bodyParser = require('body-parser'); 
var mongoose = require('mongoose'); 
var MongoClient = require('mongodb').MongoClient; 
var server = require('http').Server(app); 
var io = require('socket.io')(server); 
var routes = require('./routes/routes')(io); 
const dbb = mongoose.connect("mongodb://xxx:xxx@ds137600.mlab.com:37600/tasksdb"); 
var db = mongoose.connection; 
db.on('error', console.error.bind(console, 'connection error:')); 
app.use('/', routes); 
var server= app.listen(3000, function () { 
  console.log('Example app listening on port 3000!') 
})

routes.js #

var express = require("express"); 
var taskSchema = require("../models/taskModel"); 
var mongoose = require("mongoose"); 
var router = express.Router(); 

router.route("/tasks")
.post(function (req, res, next) { 
  // 这里需要访问io对象
}); 

router.route("/tasks")
.get(function (req, res) { 
  // 这里需要访问io对象
}); 

module.exports = router;

下面我会给出几种可行的传递方法，顺便帮你理清Node.js模块的工作逻辑。

实现Socket.io对象传递的几种方法 #

方法1：把路由模块改成接受参数的函数（你已经踩对了方向） #

你的index.js里已经写了var routes = require('./routes/routes')(io);，但routes.js还没对应调整。只需要把路由的导出改成一个接受io参数的函数，在内部创建router并使用io：

修改后的routes.js：

var express = require("express"); 
var taskSchema = require("../models/taskModel"); 
var mongoose = require("mongoose"); 

// 将模块导出为函数，接收io参数
module.exports = function(io) {
  var router = express.Router(); 

  router.route("/tasks")
  .post(function (req, res, next) { 
    // 直接使用io对象，比如发送实时消息
    io.emit('taskCreated', req.body);
    res.status(201).send('任务已创建');
  }); 

  router.route("/tasks")
  .get(function (req, res) { 
    // 同样可以访问io做其他操作
    res.send('任务列表');
  }); 

  return router;
};

这样当你在index.js里调用require('./routes/routes')(io)时，就会把io传递到路由内部，路由里的接口就能直接使用了。

方法2：把io挂载到Express的app对象上 #

如果不想修改路由的导出方式，可以在index.js里把io挂载到app的全局设置中：

// index.js初始化io之后
app.set('io', io);

然后在routes.js的接口处理函数里，通过req.app.get('io')获取io对象：

router.route("/tasks")
.post(function (req, res, next) { 
  const io = req.app.get('io');
  io.emit('taskCreated', req.body);
  res.status(201).send('任务已创建');
}); 

这种方法更灵活，不需要调整模块结构，适合快速改造现有代码。

方法3：用共享模块存储io对象（适合多模块复用场景） #

如果你的项目里有多个路由或模块都需要访问io，可以单独创建一个模块来管理io实例：

新建socket.js文件：

let io;

module.exports = {
  // 初始化io
  init: function(server) {
    io = require('socket.io')(server);
    return io;
  },
  // 获取io实例
  get: function() {
    if (!io) {
      throw new Error('Socket.io还未初始化！');
    }
    return io;
  }
};

然后在index.js里初始化：

const server = require('http').Server(app); 
const socketManager = require('./socket');
const io = socketManager.init(server);

在routes.js里直接获取：

const socketManager = require('../socket');
const io = socketManager.get();

router.route("/tasks")
.post(function (req, res, next) { 
  io.emit('taskCreated', req.body);
  res.status(201).send('任务已创建');
}); 

这种方式可以避免在多个模块之间传递io参数，统一管理实例，适合中大型项目。

关于Node.js模块工作机制的通俗解释 #

Node.js的模块系统基于CommonJS规范，核心逻辑可以总结为几点：

• 每个文件都是独立作用域：模块内的变量、函数默认只在当前文件有效，不会污染全局空间。
• require()是加载入口：调用require('./xxx')时，Node会执行目标文件的代码，然后返回该文件module.exports导出的内容。
• 模块会被缓存：同一个模块被多次require时，只会执行一次代码，后续调用直接返回缓存的module.exports结果。
• 导出的是值还是引用？：如果导出的是对象、数组这类引用类型，所有require的地方共享同一个实例；如果导出的是函数，每次调用函数都会生成新的实例（比如方法1里的router）。

举个简单例子：
如果模块a.js写的是module.exports = {name: '小明'}，那么在b.js和c.js里require('./a')拿到的是同一个对象，修改b.js里的name，c.js里的name也会变。但如果a.js导出的是module.exports = function() { return {name: '小明'} }，那么b.js和c.js调用这个函数后会得到两个完全独立的对象，互相不影响。

内容的提问来源于stack exchange，提问作者Hamza Haddad