Parametrize methods vs global variables

Question

I have a very simple question that has been haunting me for a while when my code starts growing.

Should parameters be replaced by global variables when they go through long routes of nested function calls?

I understand that global environment can make the state of a program unpredictable because many functions can modify shared variables, but still, global space makes things so easy.

Let me explain myself:

functionA(){
   x = something
   functionB(x)
}
functionB(x){
   functionC(x)
}
functionC(x){
   finallyDoSomethingWithX(x)
}
finallyDoSomethingWithX(x){
  x += 1 //Very dummy example ignoring pass by value, not reference.
}

Replaced by:

globalX;
functionA(){
   globalX = something
   functionB()
}
...
...
...
finallyDoSomethingWithX(){
   globalX += 1
}

I feel the second way gives so much freedom to program because parameters can accumulate easily and also can be very restricting sometimes when code must be reused, but at the same time I feel like the function will loose its modularity when it is related to a variable in the global environment, also loosing reusability when, for example, I want to operate finallyDoSomethingWithX with another variable different tha globalX.

I think this is happening to me because I'm not actually using design patterns because I'm programming in Javascript, which for me feels like a one-script-deals-with-all language for medium projects.

Any advices? patterns? I can be more specific if needed.

Answer 1

Don't use global variables.

Also, don't pass parameters down chains of functions!

Its difficult because you don't use an actual example. But normally there will be a better approach.

Lets say we have a password variable which we need to use to call apis which inturn are used by various low level functions.

Global approach (psudo code)

var pass;

function multiply(a,b) {
   return apiMultiply(pass,a,b);
}

Parameter passing approach

function multiply(a,b,pass) {
    return apiMultiply(pass,a,b);
}

Object approach

class math {
    var api;
    constructor(pass) {
        api = new api(pass);
    }

    function Multiply(a,b) {
        api.Multiply(a,b); //uses pass from constructor
    }
}

Answer 2

Avoid globals like the plague.

Any code can modify a global. So if you had a chain A(x) -> B(x) -> C(x) -> ... -> Z(x), and you store x into a global X and now you have a chain A->B->C->...->Z, then at every single step of that long chain, or in completely independent code, someone could change X. And the value that Z uses could be completely different from the one that A started with.

It's a nightmare if you ever want to be sure that your code does what it it is supposed to do, or that it does what you think it does.