Question 190

Comment et pourquoi faut-il déclarer les variables d'un programme ?

Bien que Visual basic ne l'exige pas de façon formelle, il est possible et même fortement recommandé de déclarer toute variable préalablement à son utilisation. L'instruction Option Explicit permet d'ailleurs de rendre obligatoire les déclarations de variables.

Pourquoi déclarer les variables

La possibilité en VB de ne pas déclarer les variables est un archaïsme, une survivance des toutes premières versions du dialecte BASIC. La déclaration des variables présente de nombreux avantages; On ne conçoit pas aujourd'hui de réellement programmer en VB sans utiliser la déclaration des variables.

Les avantages de la déclaration des variables sont les suivants :

• Augmenter la lisibilité : La déclaration explicite des variables est d'une grande aide lors de la lecture de code. En effet, le lecteur peut ainsi connaître les entités qui vont être manipulées, ainsi que leurs types. C'est autant une aide lors de la lecture que lors de l'écriture.
• Permettre l'écriture de code sémantiquement correct : En déclarant des variables bien typées, on rend compte dans le programme de la réalité sous-jacente des entités que l'on manipule. Ainsi, une "date de début", un "revenu mensuel brut", un "prénom", l'état "marche/arrêt" d'un moteur sont autant de réalités physiques différentes, autant de concepts sémantiques. Un bon programme qui manipule ces entités doit tenir compte de cette réalité et utiliser pour leurs représentations le type le plus en adéquation avec le "monde réel".
• Ecrire du code structuré : Des variables déclarées sont un prérequis pour la définition de procédures et fonctions paramétrées.
• Eviter les erreurs : Les erreurs pouvant survenir dans un programme où les variables ne seraient pas déclarées sont innombrables! On peut citer (liste non exhaustive) : faute de frappe dans le nom de la variable conduisant à la création non désirée de nouvelles variables non initialisées, effets de bords non maîtrisés (toutes les variables sont globales), perte d'information par typage incorrect, etc.
• Améliorer les performances : En l'absence de déclaration explicite, VB crée automatiquement une variable de type Variant. Ce type est gourmand en mémoire et son utilisation peu performante.
• Aider "au portage" : Il est courant de devoir traduire ("porter") une portion de code (algorithme, fonction, etc.) dans un autre langage. En partant de code comportant des déclarations explicites pour toutes les variables, le travail de portage est grandement facilité; Le programmeur devant réaliser ce travail doit juste transformer le type du langage source en le type approprié dans le langage cible.

Comment (bien!) déclarer les variables

La déclaration des variables se fait en VB avec l'instruction Dim. La syntaxe détaillée de cette instruction est disponible dans l'aide de VB (voir section "Pour aller plus loin".

Voici quelques règles pour la déclaration des variables :

• Déclarer TOUTES les variables (Utiliser Option Explicit !)
• Utiliser des conventions de nommage pertinentes et consistantes :
  • Ne pas utiliser de caractères accentués dans les noms de variables (tous les claviers ne disposent pas de ces caractères)
  • Ne pas nommer une variable en utilisant uniquement des caractères majuscule. Ceci est réservé par usage pour les constantes.
  • Donner des noms explicites aux variables ("InteretCumule", "SommeDistance", "Score", "TVA", "RevenuNet", etc.). Une bonne utilisation de cette règle à l'intérêt de produire du code auto-documenté.
  • Respecter les conventions usuelles : "i" est toujours une variable d'indice de boucle For .. Next, etc.
  • Appliquer les mêmes règles de nommage pour toutes les variables, par exemple : Toutes les premières lettres en majuscule ("SommeDesRevenus", "ValeurAjoutee"), ou un underscore entre chaque mot ("somme_des_revenus", "valeur_ajoutee"). Une fois une convention choisie, on gardera cette convention pour toutes les variables.
  • Ne pas mélanger les langues (français/anglais) : "SquareRoot", "ExchangeRate", "CompletionCode", "ValeurMaximum", "TauxInteret" sont bien nommées, alors que "SommeRates", "isFini" ou "MustSortir" sont à éviter absolument.
• Restreindre au maximum la portée des variables : on préférera dans tous les cas l'utilisation d'une variable à la portée la plus réduite possible. l'utilisation de fonctions avec paramètres permet dans la plupart des cas d'éviter l'emploi de variables publiques ou globales.
• Si on doit utiliser une variable globale, on veillera à lui donner un nom indiquant clairement sa nature "globale". On peut par exemple préfixer systématiquement les globales par "G_", par exemple : G_NombreJoueurs
• Protéger les variables dans les fonctions : L'utilisation de Byval et Byref permet de ne rendre modifiable que ce qui est nécessaire.
• Choisir le type le plus approprié : Il est important de choisir un type qui corresponde à la nature de l'information portée par la variable. Un Taux d'intérêt est un nombre réel, avec quelques chiffres significatifs derrière la virgule; les type Single ou Currency seront très probablement appropriés ici, au contraire de long, Date ou String. Le nom d'une personne est une chaîne de caractères, un type String sera le meilleur choix.
• N'utiliser le type String qu'à bon escient : Ce type est à réserver pour stocker des entités qui sont "réellement" des chaînes de caractères. Un nom, un prénom, une désignation sont typiquement des chaînes de caractères. A l'inverse, les coordonnées d'un point, une vitesse, un montant sont "physiquement" des nombres. Pour ces derniers, le type String n'est PAS approprié.
• Séparer l'interface et le code : C'est une mauvaise pratique que d'utiliser un contrôle graphique (par exemple un Label) simplement pour stocker une variable. Dans l'immense majorité des cas, déclarer une vraie variable est préférable.

Remarques

Une erreur très fréquemment commise est une mauvaise déclaration de plusieurs variables dans la même instruction Dim. On peut utiliser un seul Dim pour déclarer 2 ou plusieurs variables, mais il faut alors répéter le type. Dans l'exemple qui suit, la deuxième déclaration (incorrecte!) va créer la variable "a" de type variant, et seul "b" sera effectivement un Integer. Cette erreur de déclaration est la cause d'erreurs très difficiles à détecter.

    ' Declaration correcte de 2 entiers
    Dim a As Integer, b As Integer
    
    ' Declaration INCORRECTE ET FAUSSE
    Dim a, b As Integer

Visual Basic permet de déclarer des constantes, typiquement pour assigner à un nom symbolique une valeur ne changeant jamais. On utilisera une constante plutôt qu'une variable partout où cela est pertinent. Par exemple :

    Const PI As Double = 3.141592653
    Const G  As Double = 9.81

    Const MAX_JOUEURS As Long = 10

Pour aller plus loin

• MSDN - Documentation de l'instruction Dim
• MSDN - Documentation de l'instruction Redim
• MSDN - Documentation de l'instruction Option Explicit
• MSDN - Documentation de l'instruction Type (définition de Types de Données Utilisateur)
• MSDN - Visual Basic Coding Conventions
• MSDN - Types de données de Visual Basic
• Wikipédia - Typage des données (typage fort)

Voir aussi :

• Quelle est la différence entre les mots-clés "ByVal" et "ByRef" ?
• Que siginifie "Option Explicit" et pourquoi l'employer ?
• Comment passer le contenu d'une variable entre deux forms ?