Une bonne utilisation de ces notions est PRIMORDIALE pour tout programme
digne de ce nom. Une formation au développement, que ce soit en Visual-basic ou
dans un autre langage ne peut donc les passer sous silence.
Sachez que la règle (et plus particulièrement en POO) est "l'encapsulation
maximum", c'est à dire que chaque élément doit être le plus LOCAL et le
plus PRIVE possible ... explication :
Les constantes
L'utilisation de constantes pour désigner des valeurs (numériques ou non)
fixes dans le programme améliore la lisibilité et la facilité
de maintenance de votre code source.
Le mot clé à utiliser est le mot : Const
Par exemple :
Const gNoteMaxi = 20
Const gNom = "Enigme"
Il sera ensuite bien plus lisible de dire :
If MaNote = gNoteMaxi then MsgBox "Félicitations"
De plus, si la note maxi vient à changer, la modification de la seule
déclaration de la constante permettra la mise à jour instantanée de
l'ensemble du programme plutôt que d'avoir à rechercher toutes les occurrences
du chiffre 20 !!
Les constantes peuvent être déclarées à 3 niveaux (cela s'appelle la 'portée' ou 'scope' d'une constante) :
-
Globales : Elles sont accessibles par n'importe quelle ligne de votre code
source, dans n'importe quel module ou procédure.
-
Modules : Elles sont accessibles par les procédures du module dans lequel elles sont déclarées.
-
Locales : Elles ne sont accessibles que dans la procédure dans laquelle elles sont déclarées.
NB : ici le terme "procédure" désigne aussi bien une "Sub"
qu'une "Function" !
Constantes globales
Pour être accessible depuis l'ensemble de votre projet, une
constante doit être déclarée "Public Const" dans l'entête
d'un module 'de base' (.Bas). Les modules 'de base' sont les seuls à être
publics. Tous les autres modules sont privés (module d'un formulaire, module de
classe ...).
Public const gMaxPlanetes = 9
Public const Pi = 3.14159265
Ce sont 2 constantes globales si elles sont déclarées dans l'entête
(général/déclaration) d'un module 'de base' (sous les options).
Constantes modules
Les constantes de niveau module sont accessibles par les procédures du module dans lequel elles sont
déclarées avec les mots clés "Private Const" que ce soit
dans un module public (.Bas) ou privé (.frm, .cls ... ...).
Private Const mNombreLignes = 70
Constantes locales
Les constantes locales sont celles définies à l'intérieur d'une procédure
(ou fonction) à l'aide du seul mot clé "Const".
Elles ne sont accessibles que dans la procédure dans laquelle elles sont
déclarées.
'-------------------------------------------------
Private sub JusteUnExemple()
'-------------------------------------------------
Const NbrLignes = 10
Const NbrCols = 5
For i = 1 to NbrLignes
Print "--> Ligne " & i
For j = 1 to NbrCols
Print "
Colone " & i
Next j
Next i
End Sub
Les variables
Comme les constantes, les variables peuvent être déclarées à 3 niveaux
(cela s'appelle la 'portée' ou 'scope' d'une variable) :
-
Globales : Elles sont accessibles par n'importe quelle ligne de votre code
source, dans n'importe quel module ou procédure.
-
Modules : Elles sont accessibles par les procédures du module dans lequel elles sont déclarées.
-
Locales : Elles ne sont accessibles que dans la procédure dans laquelle elles sont déclarées.
NB : ici le terme "procédure" désigne aussi bien une "Sub"
qu'une "Function" !
En général, les développeurs professionnels préfèrent que le langage les
oblige à déclarer leurs variables, cela évite de nombreuses erreurs !! VB
vous permet de faire en sorte qu'un message d'erreur à la compilation soit
généré si une variable est utilisée sans avoir été déclarée. Pour cela
il faut que le module commence par la ligne :
Option Explicit
C'est, en général, la première ligne de TOUS les modules. On peut faire en
sorte que VB la génère automatiquement à la création du module
(Outils/Options/Onglet général/Déclaration des variables obligatoire).
Il est fortement conseillé de TOUJOURS préciser si une variable est
"Public" ou "Private" et de ne pas compter sur leur portée
'par défaut' : "Public" dans un module 'de base' (.bas) et "Private"
dans tous les autres types de modules (.frm, .cls ... ... ).
Une autre règle est de TOUJOURS typeR ses variables. En effet, vu
leur rôle de conteneur elles sont amenées à stocker différentes valeurs qui
correspondent en général à un type précis. (Téléchargez et lisez les conventions
de codage à propos des noms de variables en fonction de leurs porté et
type). Les types sont, par exemple, Integer (-32768 à +32767), Long
(-2*10E9 à +2*10E9), String (chaînes de caractères), etc ... etc
...
Variables globales
Pour être accessible depuis l'ensemble de votre projet, une variable doit être déclarée
"Public" dans l'entête
d'un module 'de base' (.Bas). Les modules 'de base' sont les seuls à être
publics. Tous les autres modules sont privés (module d'un formulaire, module de
classe ...).
Public gdb as Database
Public gblnModeDebug as Boolean
Ce sont 2 constantes globales si elles sont déclarées dans l'entête
(général/déclaration) d'un module 'de base' (sous les options).
NB : Il est d'usage de minimiser les déclarations globales en POO
(règle d'encapsulation maximum, le + local et le + privé possible). Dans le
meilleur des mondes, un programme très bien structuré ne comporterait AUCUNE
déclaration de variable globale .... Dans la réalité, par souci de
productivité et de simplification, on s'autorise de temps en temps une déclaration
globale. Toutefois, cela doit conserver un aspect exceptionnel.
Variables modules
Elles sont accessibles par les procédures du module dans lequel elles sont
déclarées (général/déclarations) et UNIQUEMENT DANS CE MODULE !!! En général on les trouve juste après
les éventuelles constantes, sous la ligne "Option
Explicit" (voir ci-dessus).
Private mint_NbrNotes As Integer
Private mstr_NomEleve As String
Cas des variables 'publiées' d'un module
Elles sont souvent appelées 'propriétés' par un défaut de langage, en
effet, une propriété est une procédure (procedure Property) et non une simple déclaration !
Elles diffèrent uniquement des variables modules 'normales' par le fait
qu'elles sont déclarées "Public" et, du coup, deviennent accessibles
depuis l'extérieur du module ! Elles ne sont toutefois pas globales et, si une
procédure d'un autre module a besoin d'y faire référence, elle devra faire
précéder le nom de la variable du nom du module (d'où la confusion avec une
propriété).
Par exemple si dans un module de formulaire "frmFicheClient" on a
déclaré, dans l'entête du module :
Public mlng_CodCli As long
Toutes les procédures du formulaire "frmFicheClient"
pourront utiliser cette variable mais le formulaire "frmFicheCommande"
(ou tout autre module) pourra également faire référence à cette variable à condition
d'écrire :
If frmFicheClient.mlng_CodCli <>
0 then ... ... ...
Et à condition, bien sûr, que le formulaire soit chargé (ou, au moins,
instancié !). On remarque que la syntaxe est effectivement tout à fait
semblable à l'utilisation d'une propriété ... C'est pourquoi on utilise
souvent le mot 'propriété' en lieu et place de 'variable publiée' !
Variables locales
Elles ne sont accessibles que dans la procédure dans laquelle elles sont
déclarées à l'aide du mot clé "Dim".
Cas des variables locales "static"
C'est un cas particulier, leur portée est locale mais leur durée de vie est
celle du programme. Elles ne sont pas ré-initialisées à chaque appel de la
procédure.
Elles doivent être déclarées avec le mot clé "Static"
en lieu et place de "Dim"