How to avoid using global variables in Nodejs? - node.js

Question

I have /bin/www that I execute and websocketServer.js that needs the httpServer object from /bin/www to initialize the websocket server. How can I pass httpServer to websocketServer.js without using a global variable?
websocketServer.js:
let WebSocket = require('ws')
let wss = new WebSocket.Server({ server: global.httpServer })
wss.on('connection', (connection, req) =>
...
/bin/www:
let app = require('../app')
let http = require('http')
...
global.httpServer = http.createServer(app)
httpServer.listen(port)
...
I have foo.js and bar.js that both handle user information that is only persistent at runtime (no need to store in database). How can these 2 files work with the same users? I can only think of using a shared variable aka global. Is there any way to avoid using a global variable in this situation? Should I even bother avoiding using global variables if it makes total sense to use them in my mind?
Besides, I came to this situation of needing runtime global variables because so far I've been using a database which is essentially a provider of global variables. Except now my project requires variables that need to be global but don't have to be stored in a database.
foo.js:
...
function getsCalledWhenUserLogsIn(username)
{
global.users[username] = { timer: new Timer(), websocketConnection: null, ... }
// initializing the user below
...
}
...
bar.js:
...
websocketServer.on('connection', (connection, req) =>
{
...
connection.on('message', (message) =>
{
let user = global.users[JSON.parse(message).username]
if (user)
{
user.websocketConnection = connection
...
}
...
}
...
}
...
This is not my code per se but at least it gives you some idea
I want to be able to structure my files in a way that I won't have to use global variables.

Answer 1

Example with global variables:
global.bar = 'hello world';
function foo1() {
console.log(bar);
}
function foo2() {
console.log(bar);
}
foo1();
foo2();
Example without global variables:
var bar = 'hello world';
function foo1(bar) {
console.log(bar);
}
function foo2(bar) {
console.log(bar);
}
foo1(bar);
foo2(bar);
This is overly simplistic, but the main point is: if you want 2 distinct things to have access to the same object without being aware of each other, you need a 'third thing' to pass this object to the first two things.
Also see: dependency injection.
As for the question if you should always do this... I would argue that avoiding globals is something you should always strive for, unless you have a good reason not to. Best practices are a good default, but break them if common sense dictates that you shouldn't apply it for specific cases.
However, I don't think that you have a valid enough case for it here. You just have to learn functions and arguments a bit better.

Answer 2

To avoid global variables you could use XMLHttpRequest and just GET/POST to yourself. Not the most efficient thing but it would still work.
var xhr2 = new XMLHttpRequest();
xhr2.open('GET', "http://yourserver", true);
xhr2.onreadystatechange = function() {
if (this.status == 200 && this.readyState == 4) {
if(this.responseText == '') { return;}
//your code here
}//
};//end onreadystate
xhr2.send();
You could also have global arrays that have objects and just go through them. Then you have one array. It just depends how you want to go about it.