Méthodes de paramétrage vs variables globales

J'ai une question très simple qui me hante depuis un moment lorsque mon code commence à grandir.

Les paramètres doivent-ils être remplacés par des variables globales lorsqu'ils passent par de longues routes d'appels de fonctions imbriquées?

Je comprends que l'environnement global peut rendre l'état d'un programme imprévisible car de nombreuses fonctions peuvent modifier des variables partagées, mais malgré tout, l'espace global rend les choses si faciles.

Je m'explique:

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

Remplacé par:

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

Je pense que la deuxième façon donne tellement de liberté pour programmer parce que les paramètres peuvent s'accumuler facilement et peuvent également être très restrictifs parfois lorsque le code doit être réutilisé, mais en même temps, j'ai l'impression que la fonction perdra sa modularité lorsqu'elle est liée à une variable dans l'environnement global, perdant également la réutilisabilité lorsque, par exemple, je veux fonctionner finallyDoSomethingWithXavec une autre variable différente tha globalX.

Je pense que cela m'arrive parce que je n'utilise pas réellement de modèles de conception parce que je programme en Javascript, ce qui pour moi ressemble à un langage à script unique pour tous les projets moyens.

Des conseils? motifs? Je peux être plus précis si besoin.

N'utilisez pas de variables globales.

De plus, ne transmettez pas de paramètres à des chaînes de fonctions!

C'est difficile parce que vous n'utilisez pas d'exemple réel. Mais normalement, il y aura une meilleure approche.

Disons que nous avons une variable de mot de passe que nous devons utiliser pour appeler des API qui à leur tour sont utilisées par diverses fonctions de bas niveau.

Approche globale (code psudo)

var pass;

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

Approche de passage de paramètres

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

Approche objet

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

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

Évitez les globaux comme la peste.

Tout code peut modifier un global. Donc, si vous aviez une chaîne A (x) -> B (x) -> C (x) -> ... -> Z (x), et vous stockez x dans un X global et maintenant vous avez une chaîne A- > B-> C -> ...-> Z, puis à chaque étape de cette longue chaîne, ou dans un code complètement indépendant, quelqu'un pourrait changer X. Et la valeur que Z utilise pourrait être complètement différente de celle que A a commencé avec.

C'est un cauchemar si jamais vous voulez être sûr que votre code fait ce qu'il est censé faire, ou qu'il fait ce que vous pensez qu'il fait.