Les variables globales, pourquoi certaines personnes ne les aiment pas ?

Variables globales : le mal absolu ?

La programmation nous met à disposition tous un tas d’instructions et d’outils qui permet de faire des logiciels. Mais il y en a un qui est pourtant si utile en apparence, est considérée comme une mauvaise pratique, ce sont les variables globales ! Voyons pourquoi les professeurs et autres développeurs expérimentés détestent ces types de variables, c’est parti !

C’est quoi une variable globale ?

Mais déjà, c’est quoi une variable globale ? Et bien, c’est comme une variable classique, avec la particularité que sa portée s’étend dans toute l’application ! En gros, ça veut dire que je peux accéder et modifier ma variable n’importe où, n’importe quand et généralement n’importe comment.

La portée d’une variable par défaut, dite locale, est limitée que dans la fonction où elle est défini. Elle n’existe pas ou plus pour les autres fonctions du programme. La variable globale quant à elle, est créée soit en mettant un mot-clé spécial, soit en étant définie en dehors de toute fonction et n’a pas de limite de portée.

Ça sert à quoi ? Cela permet justement d’accéder à une variable sans la passer en paramètre dans une fonction par exemple. Pratique non ?

Les problèmes

Mais alors, pourquoi les variables globales sont-elles considérées comme le mal absolu pour certaines personnes ?

Et bien, dans le cas d’un programme simple, il n’y a pas trop de problèmes, mais dès que le projet prend de l’ampleur et devient plus complexe, c’est là qu’ils deviennent gênants. Comme d’habitude, c’est une utilisation abusive qui cause des problèmes. Si le programme possède 50 variables globales, ce qui est énorme, il va forcément y avoir des soucis lorsqu’on en créera de nouvelles, globales ou non. Le nom de certaines variables peut être déjà prise ou pire, on peut modifier la variable globale sans s’en rendre compte ce qui peut créer de sacrés bugs invisibles, on appelle ça une collision.

Ensuite, un bloc de code qui a accès à un grand nombre de variables qui ne le concerne pas est tout simplement inutile. Lorsqu’on utilise le débugger ou l’autocomplétion, le fait d’avoir accès à une multitude de variables globales sans grand intérêt pollue littéralement le code où l’on travaille. Moins pratique sur ce coup-ci !

Imaginez votre fonction qui s’occupe d’une opération simple comme la multiplication de deux paramètres ait accès à tout ça ? Est-ce nécessaire ? Pire, je décide de créer une variable locale option, mais il existe déjà une variable globale du même nom, c’est une collision 🙁 ! Et en prime, on a une mauvaise lisibilité sur les variables qui concerne directement notre fonction.

De plus, le principe d’avoir une variable accessible à tous perturbe fortement le concept de l’encapsulation et du masquage des données. Une des raisons que les puristes n’aiment pas les variables globales !

Il faut aussi ajouter que dans une classe ou une fonction, une variable globale la rend dépendante de celle-ci, on parle de couplage fort sur ce cas-ci. Si par exemple on copie la fonction directement dans un autre programme, il y aura une erreur, car elle nécessite la variable globale pour fonctionner. Dans l’idéal, les fonctions doivent être considérées comme des modules indépendants utilisables n’importe où, peu importe l’environnement, c’est pour cette raison que les dépendances sont mal vu, et donc les variables globales.

Faut-il les bannir définitivement ?

Non pas forcément, c’est vrai qu’il y a pas mal d’inconvénients qui justifient cette haine, surtout en termes de maintenance et de lisibilité, mais on peut les utiliser temporairement pour mettre en place par exemple une nouvelle portion de code.

Quand le programme possède un objet unique utilisé un peu partout dans le code, cela peut aussi être une bonne raison d’avoir une portée globale. Le passer en paramètre sur toutes les fonctions qui l’utilisent risque d’être pénible surtout si le programme est conséquent. Là, l’utilisation d’un objet globale est légitime et simplifie grandement le code.

Et enfin, pour les très petits programmes, cela n’est pas gênant.

Une solution pour utiliser des variables globales en limitant les problèmes est de réunir toutes ces variables dans une seule structure ou un seul objet nommé du style globalVar. Pour pouvoir accéder aux variables globales, on passerait donc obligatoirement par globalVar ce qui permet de les regrouper et de bien identifier qu’on se sert d’une variable globale.

Pour conclure, si vous avez une bonne raison d’utiliser une variable globale, ne vous en privez pas ! Mais à consommer avec modération tout de même ! Les variables globales peuvent être utiles, mais aussi source d’erreur bien plus tard. Si l’aspect global pour une variable n’est pas si important dans le programme, considérez-la comme une variable temporaire.

Partager l’article :
  •  
  •  
  •  
  •  
  •  
  •  
  •  
  •  
  •  

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur comment les données de vos commentaires sont utilisées.