Parametrizza i metodi rispetto alle variabili globali

Ho una domanda molto semplice che mi perseguita da un po 'quando il mio codice inizia a crescere.

I parametri dovrebbero essere sostituiti da variabili globali quando attraversano lunghe rotte di chiamate di funzione nidificate?

Capisco che l'ambiente globale può rendere imprevedibile lo stato di un programma perché molte funzioni possono modificare le variabili condivise, ma lo spazio globale rende le cose così facili.

Mi spiego:

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.
}

Sostituito da:

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

Penso che il secondo modo offra tanta libertà di programmazione perché i parametri possono accumularsi facilmente e possono anche essere molto restrittivi a volte quando il codice deve essere riutilizzato, ma allo stesso tempo sento che la funzione perderà la sua modularità quando è correlata a una variabile nell'ambiente globale, perdendo anche riusabilità quando, ad esempio, voglio operare finallyDoSomethingWithXcon un'altra variabile diversa da quella globalX.

Penso che questo mi stia succedendo perché in realtà non sto usando modelli di progettazione perché sto programmando in Javascript, che per me sembra un linguaggio a script unico per tutti i progetti di medie dimensioni.

Qualche consiglio? modelli? Posso essere più specifico se necessario.

Non usare variabili globali.

Inoltre, non passare i parametri in catene di funzioni!

È difficile perché non usi un esempio reale. Ma normalmente ci sarà un approccio migliore.

Diciamo che abbiamo una variabile password che dobbiamo usare per chiamare le API che inturn sono usate da varie funzioni di basso livello.

Approccio globale (codice psudo)

var pass;

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

Approccio di passaggio dei parametri

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

Approccio agli oggetti

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

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

Evita i globi come la peste.

Qualsiasi codice può modificare un globale. Quindi se avessi una catena A (x) -> B (x) -> C (x) -> ... -> Z (x), e memorizzi x in una X globale e ora hai una catena A- > B-> C -> ...-> Z, quindi ad ogni singolo passaggio di quella lunga catena, o in codice completamente indipendente, qualcuno potrebbe cambiare X. E il valore che Z usa potrebbe essere completamente diverso da quello che A iniziato con.

È un incubo se mai vuoi essere sicuro che il tuo codice fa quello che dovrebbe fare, o che fa quello che pensi che faccia.