Javascript 在文件之间从socket.io共享服务器_Javascript_Node.js_Websocket_Socket.io

Javascript 在文件之间从socket.io共享服务器

javascript node.js websocket socket.io

Javascript 在文件之间从socket.io共享服务器,javascript,node.js,websocket,socket.io,Javascript,Node.js,Websocket,Socket.io,我正在尝试从其他文件调用io。关键是当用户被放入房间，或者调用io.sockets等时，它不会更新 server.js var options = { key: fs.readFileSync('./certs/file.key'), cert: fs.readFileSync('./certs/file.crt'), requestCert: false }; var app = express(); var server = require('https').createServ

我正在尝试从其他文件调用io。关键是当用户被放入房间，或者调用

io.sockets

等时，它不会更新

server.js

var options = {
  key: fs.readFileSync('./certs/file.key'),
  cert: fs.readFileSync('./certs/file.crt'),
  requestCert: false
};
var app = express();
var server = require('https').createServer(options, app);
var io = require('socket.io').listen(server); io.origins('*:*');
global.io = io;

io.on('connection', function(socket) {  .. }

const options = {
  key: fs.readFileSync('./certs/file.key'),
  cert: fs.readFileSync('./certs/file.crt'),
  requestCert: false
};
const app = express();
const server = require('https').createServer(options, app);
const io = require('./socket.js').init(server);

io.on('connection', function(socket) {  .. }

let io;
module.exports = {
    init: function(server) {
        // start socket.io server and cache io value
        io = require('socket.io').listen(server); io.origins('*:*');
        return io;
    }
    getio: function() {
        // return previously cached value
        if (!io) {
            throw new Error("must call .init(server) before you can call .getio()");
        }
        return io;
    }
}

const options = {
  key: fs.readFileSync('./certs/file.key'),
  cert: fs.readFileSync('./certs/file.crt'),
  requestCert: false
};
const app = express();
const server = require('https').createServer(options, app);
const io = require('socket.io').listen(server); io.origins('*:*');


io.on('connection', function(socket) {  .. }

// exports some things we want to share
module.exports  = {
  io: io,
  app: app
};

const options = {
  key: fs.readFileSync('./certs/file.key'),
  cert: fs.readFileSync('./certs/file.crt'),
  requestCert: false
};
const app = express();
const server = require('https').createServer(options, app);
const io = require('socket.io').listen(server); io.origins('*:*');


io.on('connection', function(socket) {  .. }

// load someotherfile.js and pass it the io variable
require('./someotherfile.js')(io);

我也试过

module.exports.io

然后从另一个文件

require('server.js').io

这也不起作用，我想在一个文件中运行我的服务器，即服务器js，我在这里处理每个传入的套接字等。这是我尝试过的两件事，但它们都会导致相同的问题。

有许多不同的方案用于与其他模块共享中心变量（如您的

io

变量）。这样做到底有什么意义取决于总体架构、您希望模块如何可恢复等等。。。但它们都使用导入和导出的某种组合来在模块之间共享数据，而不使用

global

在您的具体情况下，您可以做一些非常简单的事情：

server.js

var options = {
  key: fs.readFileSync('./certs/file.key'),
  cert: fs.readFileSync('./certs/file.crt'),
  requestCert: false
};
var app = express();
var server = require('https').createServer(options, app);
var io = require('socket.io').listen(server); io.origins('*:*');
global.io = io;

io.on('connection', function(socket) {  .. }

const options = {
  key: fs.readFileSync('./certs/file.key'),
  cert: fs.readFileSync('./certs/file.crt'),
  requestCert: false
};
const app = express();
const server = require('https').createServer(options, app);
const io = require('./socket.js').init(server);

io.on('connection', function(socket) {  .. }

let io;
module.exports = {
    init: function(server) {
        // start socket.io server and cache io value
        io = require('socket.io').listen(server); io.origins('*:*');
        return io;
    }
    getio: function() {
        // return previously cached value
        if (!io) {
            throw new Error("must call .init(server) before you can call .getio()");
        }
        return io;
    }
}

const options = {
  key: fs.readFileSync('./certs/file.key'),
  cert: fs.readFileSync('./certs/file.crt'),
  requestCert: false
};
const app = express();
const server = require('https').createServer(options, app);
const io = require('socket.io').listen(server); io.origins('*:*');


io.on('connection', function(socket) {  .. }

// exports some things we want to share
module.exports  = {
  io: io,
  app: app
};

const options = {
  key: fs.readFileSync('./certs/file.key'),
  cert: fs.readFileSync('./certs/file.crt'),
  requestCert: false
};
const app = express();
const server = require('https').createServer(options, app);
const io = require('socket.io').listen(server); io.origins('*:*');


io.on('connection', function(socket) {  .. }

// load someotherfile.js and pass it the io variable
require('./someotherfile.js')(io);

socket.js

var options = {
  key: fs.readFileSync('./certs/file.key'),
  cert: fs.readFileSync('./certs/file.crt'),
  requestCert: false
};
var app = express();
var server = require('https').createServer(options, app);
var io = require('socket.io').listen(server); io.origins('*:*');
global.io = io;

io.on('connection', function(socket) {  .. }

const options = {
  key: fs.readFileSync('./certs/file.key'),
  cert: fs.readFileSync('./certs/file.crt'),
  requestCert: false
};
const app = express();
const server = require('https').createServer(options, app);
const io = require('./socket.js').init(server);

io.on('connection', function(socket) {  .. }

let io;
module.exports = {
    init: function(server) {
        // start socket.io server and cache io value
        io = require('socket.io').listen(server); io.origins('*:*');
        return io;
    }
    getio: function() {
        // return previously cached value
        if (!io) {
            throw new Error("must call .init(server) before you can call .getio()");
        }
        return io;
    }
}

const options = {
  key: fs.readFileSync('./certs/file.key'),
  cert: fs.readFileSync('./certs/file.crt'),
  requestCert: false
};
const app = express();
const server = require('https').createServer(options, app);
const io = require('socket.io').listen(server); io.origins('*:*');


io.on('connection', function(socket) {  .. }

// exports some things we want to share
module.exports  = {
  io: io,
  app: app
};

const options = {
  key: fs.readFileSync('./certs/file.key'),
  cert: fs.readFileSync('./certs/file.crt'),
  requestCert: false
};
const app = express();
const server = require('https').createServer(options, app);
const io = require('socket.io').listen(server); io.origins('*:*');


io.on('connection', function(socket) {  .. }

// load someotherfile.js and pass it the io variable
require('./someotherfile.js')(io);

在需要访问io的其他模块中

const io = require('./socket.js').getio();

在这里不用说，您必须先调用

.init（server）

，然后才能调用

.getio（）

。这充分利用了node.js模块缓存系统，因此每次调用

require（'./socket.js'）

时，它都会将第一次加载的模块返回给您，因此您可以访问以前缓存的

io

实例

仅供参考，这被称为“拉动”模型，其中希望访问其他内容的模块使用

require（）

语句“拉动”它想要的变量

还有一个推送模块，模块的加载程序在加载模块后通过调用该模块中的函数将数据推送到该模块

以下是一些其他方法：

从app.js导出

var options = { key: fs.readFileSync('./certs/file.key'), cert: fs.readFileSync('./certs/file.crt'), requestCert: false }; var app = express(); var server = require('https').createServer(options, app); var io = require('socket.io').listen(server); io.origins('*:*'); global.io = io; io.on('connection', function(socket) { .. }

const options = { key: fs.readFileSync('./certs/file.key'), cert: fs.readFileSync('./certs/file.crt'), requestCert: false }; const app = express(); const server = require('https').createServer(options, app); const io = require('./socket.js').init(server); io.on('connection', function(socket) { .. }

let io; module.exports = { init: function(server) { // start socket.io server and cache io value io = require('socket.io').listen(server); io.origins('*:*'); return io; } getio: function() { // return previously cached value if (!io) { throw new Error("must call .init(server) before you can call .getio()"); } return io; } }

const options = { key: fs.readFileSync('./certs/file.key'), cert: fs.readFileSync('./certs/file.crt'), requestCert: false }; const app = express(); const server = require('https').createServer(options, app); const io = require('socket.io').listen(server); io.origins('*:*'); io.on('connection', function(socket) { .. } // exports some things we want to share module.exports = { io: io, app: app };

const options = { key: fs.readFileSync('./certs/file.key'), cert: fs.readFileSync('./certs/file.crt'), requestCert: false }; const app = express(); const server = require('https').createServer(options, app); const io = require('socket.io').listen(server); io.origins('*:*'); io.on('connection', function(socket) { .. } // load someotherfile.js and pass it the io variable require('./someotherfile.js')(io);
使用此方案时，您必须注意循环依赖关系，因为如果app.js确实
需要（'./a.js'）
，而
a.js
确实需要（'./app.js'）
，则您可以创建一个循环依赖关系，该依赖关系将失败。因此，该模型仅在
a.js
在模块加载后执行
require（'./app.js'）`时有效（如在模块构造函数中）
app.js

var options = { key: fs.readFileSync('./certs/file.key'), cert: fs.readFileSync('./certs/file.crt'), requestCert: false }; var app = express(); var server = require('https').createServer(options, app); var io = require('socket.io').listen(server); io.origins('*:*'); global.io = io; io.on('connection', function(socket) { .. }

const options = { key: fs.readFileSync('./certs/file.key'), cert: fs.readFileSync('./certs/file.crt'), requestCert: false }; const app = express(); const server = require('https').createServer(options, app); const io = require('./socket.js').init(server); io.on('connection', function(socket) { .. }

let io; module.exports = { init: function(server) { // start socket.io server and cache io value io = require('socket.io').listen(server); io.origins('*:*'); return io; } getio: function() { // return previously cached value if (!io) { throw new Error("must call .init(server) before you can call .getio()"); } return io; } }

const options = { key: fs.readFileSync('./certs/file.key'), cert: fs.readFileSync('./certs/file.crt'), requestCert: false }; const app = express(); const server = require('https').createServer(options, app); const io = require('socket.io').listen(server); io.origins('*:*'); io.on('connection', function(socket) { .. } // exports some things we want to share module.exports = { io: io, app: app };

const options = { key: fs.readFileSync('./certs/file.key'), cert: fs.readFileSync('./certs/file.crt'), requestCert: false }; const app = express(); const server = require('https').createServer(options, app); const io = require('socket.io').listen(server); io.origins('*:*'); io.on('connection', function(socket) { .. } // load someotherfile.js and pass it the io variable require('./someotherfile.js')(io);
其他一些需要访问io的文件

// module constructor modules.exports = function() { // can use io in here const io = require('./app.js').io; }

module.exports = function(io) { // put whatever code for your module here setInterval(function() { io.emit(...); }, 1000); }

推送模式
在该模块中，加载其他模块时，将
io
变量传递给需要它的任何其他模块
app.js

var options = { key: fs.readFileSync('./certs/file.key'), cert: fs.readFileSync('./certs/file.crt'), requestCert: false }; var app = express(); var server = require('https').createServer(options, app); var io = require('socket.io').listen(server); io.origins('*:*'); global.io = io; io.on('connection', function(socket) { .. }

const options = { key: fs.readFileSync('./certs/file.key'), cert: fs.readFileSync('./certs/file.crt'), requestCert: false }; const app = express(); const server = require('https').createServer(options, app); const io = require('./socket.js').init(server); io.on('connection', function(socket) { .. }

let io; module.exports = { init: function(server) { // start socket.io server and cache io value io = require('socket.io').listen(server); io.origins('*:*'); return io; } getio: function() { // return previously cached value if (!io) { throw new Error("must call .init(server) before you can call .getio()"); } return io; } }

const options = { key: fs.readFileSync('./certs/file.key'), cert: fs.readFileSync('./certs/file.crt'), requestCert: false }; const app = express(); const server = require('https').createServer(options, app); const io = require('socket.io').listen(server); io.origins('*:*'); io.on('connection', function(socket) { .. } // exports some things we want to share module.exports = { io: io, app: app };

const options = { key: fs.readFileSync('./certs/file.key'), cert: fs.readFileSync('./certs/file.crt'), requestCert: false }; const app = express(); const server = require('https').createServer(options, app); const io = require('socket.io').listen(server); io.origins('*:*'); io.on('connection', function(socket) { .. } // load someotherfile.js and pass it the io variable require('./someotherfile.js')(io);
其他一些需要访问io的文件

// module constructor modules.exports = function() { // can use io in here const io = require('./app.js').io; }

module.exports = function(io) { // put whatever code for your module here setInterval(function() { io.emit(...); }, 1000); }

这是一个一般性的“如何在模块之间共享数据”问题，完全不是socket.io所特有的。这个一般性问题在这里已经被问了几百次了。请搜索。我将尝试找到许多DUP中的一个。@jfriend00是的，但是导出在这里不起作用。嗯，导出可以很好地工作。全局性是一个坏主意，因为它们是模块化和可测试性的敌人（换句话说，糟糕的设计）。这里还有数百个其他问题/答案，数百个网站展示了如何使用导出在模块之间共享内容，因此我们没有理由提供关于这一事实的一般教程。如果您希望获得有关如何使导出在代码中工作的帮助，请提出一个新问题，准确显示您尝试了什么（代码的两个方面，导入和导出），并解释为什么它不工作。@jfriend00我需要等待90分钟lol@jfriend00我已经在谷歌上搜索了至少2个小时的anwser，但没有找到任何与我的问题相匹配的东西，我找到了一些，他们只是把所有的东西都放在模块中。导出，但我想处理这个文件中的所有东西，我不能去更改，我可以，但我不想花一周的时间更改所有东西，我至少要更改2000行。查看更新的anwser，因为它不包含太多新闻，但我尝试过的唯一两件事可能对我一直想要实现的目标有用。非常感谢，我回家后会尝试这一点，我不需要在server.js文件中更改任何其他内容？@VGOExclusive-server.js中不需要更改任何其他内容，因为
.init（）
返回存储在本地的
io
变量，以便像以前一样使用它。