i

PROGRAMMATION VBA EXCEL

 1

Chapitre 1

Introduction

1.1 Mise en garde

Je ne suis en aucun cas un programmeur professionnel. Tout ce que je « sais », je
l’ai appris par essais successifs, échecs, réflexion et lecture de code écrit par d’autres.
Mes façons de faire ne sont donc probablement pas très académiques mais, je l’es-
père, peuvent vous montrer que même si l’on ne sait pas faire, en prenant le temps
et en étant motivé, tout le monde peut y arriver.
La version d’Excel utilisée lors de la rédaction de ce document est la version Excel
2002 SP3 française utilisée sur Windows XP Professionel SP1.

1.2 Qu’est-ce que la programmation dans Excel ?

Lorsque l’on effectue des manipulations répétitives dans Excel, il est interressant
de faire en sorte de les automatiser. La première étape consiste à créer ces propre
macros à l’aide de l’enregistreur de macro.
– On met en marche l’enregistreur → Outils , Macro , Nouvelle macro ,
– On effectue les manipulations,
– On arrête l’enregistreur → Outils , Macro , Arrêter l’enregistrement ,
– On peut maintenant ré-exécuter les mêmes manipulations en exécutant la
macro enregistrée → Outils , Macro , Macros , choisir la macro voulue,
Exécuter .
Sans le savoir, on vient de créer un programme dans Excel. L’enregistreur de macro
a converti nos actions à la souris ou au clavier en un langage qui peut être relu par
Excel. Le langage utilisé est le VBA.

1.3 Pourquoi programmer dans Excel en utilisant VBA ?

On a créé ces petites macros, mais rapidement, on se rend compte que si le
nombre de lignes change, que la colonne a été déplacée, . . ., tout est à refaire. C’est
là que va intervenir la programmation en VBA. En ayant un minimum de connais-
sances en VBA, on va pouvoir rendre générique quelque chose qui, à priori, ne l’était
pas. On va apprendre au programme à trouver le nombre de lignes, à quelle place ce
trouve la colonne qui nous interresse, . . .Nos petites macros vont ainsi pouvoir être
2 1.4 Comment voir, modifier le programme ?

réutilisables, y compris dans d’autres classeurs. On pourra ainsi se constituer petit à

petit une bibliothèque de macros et de fonctions que l’on aura testé, peaufinées et
que l’on pourra réutiliser, sans pour autant réinventer la roue à chaque fois.

1.4 Comment voir, modifier le programme ?

Lorsque Excel est ouvert, on affiche l’éditeur VBA par ALT+F11 ou en passant
par Outils , Macro , Visual Basic Editor . Affichez :
– l’explorateur de projet → Affichage , Explorateur de projets ,
– la fenêtre de propriété → Affichage , Fenêtre Propriétés .
Lorsque l’on double clique sur une feuille, ThisWorkbook ou un module, le texte du
programme correspondant s’affiche dans la partie droite de l’écran. Dans la suite de
ce document, nous continuerons à utiliser le mot programme pour parler du texte
constituant nos macros et fonctions.

F IG . 1.1 – Editeur VBA

1.5 Comment enregistrer le programme ?

Lorsque vous êtes dans l’éditeur VBA, Fichier , Enregistrer . Vous pouvez aussi
sauvegarder votre programme, simplement en enregistrant votre classeur.

1.6 Comment exécuter un programme (une macro) ?

Dans Excel, Outils , Macro , Macros , choisir la macro voulue, Exécuter .
On verra par la suite comment ne rendre visible que les macros souhaitées (en fait
en cachant les autres).
1.7 Comment importer, exporter, supprimer un module ? 3

1.7 Comment importer, exporter, supprimer un module ?

1.7.1 Importer
Importer un module va permettre de rajouter des fonctions et macros déjà tes-
tées et fonctionnelles dans notre classeur. Elles seront ensuite utilisable comme n’im-
porte qu’elle autres fonctions ou macros que l’on aurait écrite dans le classeur. Lorsque
vous êtes dans l’éditeur VBA, faites un clic droit dans l’explorateur de projet, →
Importer un fichier . . . , choisir le fichier (module) à importer.

1.7.2 Exporter
Exporter un module va permettre d’enregistrer dans un fichier un groupe de
fonctions et de macros que l’on a testé et qui peuvent nous être utiles dans d’autres
projets. Lorsque vous êtes dans l’éditeur VBA, faites un clic droit sur le module
que vous voulez exporter, → Exporter un fichier . . . , donnez un nom au fichier qui
contiendra votre module. Un certain nombre des modules que j’ai créé pour mes
besoins personnels sont disponibles sur http ://[Link] sous licence GPL (cf.
annexe A).

1.7.3 Supprimer
Toutes les macros que vous ferez avec l’enregistreur de macro afin de voir com-
ment programmer certaines actions seront placées dans des modules (module1,
module2, . . .). Lorsque celle-ci ne seront plus utiles, pensez à les supprimer du clas-
seur, il s’allègera d’autant. Lorsque vous êtes dans l’éditeur VBA, faites un clic droit
sur le module que vous voulez supprimer, → Supprimer nom_du_module , ré-
pondre à la question. Attention, il faut la lire avant de cliquer, elle ne correspond
pas à ce que vous supposez !

1.8 Premier programme

En utilisant les explications ci-dessus, saisissez l’exemple ci-dessous dans This-
Workbook puis exécutez-le.

 Listing 1.1 – Premier programme 

Option E x p l i c i t

Sub NumeroteLignes ( )
Dim N As Long

For N = 1 To 20
C e l l s (N, 1) = " Ligne " & N
Next N

 
End Sub

Vous venez de créer votre premier programme. si vous l’exécutez, vous verrez
qu’il se contente d’afficher dans chaque cellule le numéro de ligne correspondant.
Nous verrons au cours des explications qui suivent, à quoi correspondent chacun
des termes utilisés.
4 1.9 Recommandations

1.9 Recommandations
1.9.1 Découpez
Avant de commencer un programme, prenez un papier, un crayon et listez toutes
les étapes de ce que vous voulez réalisez. Détaillez au maximum afin que chaque
tâche soit aussi simple que possible. Réalisez une à une les macros correspondant à
ces tâches. Après chaque réalisation de macro, testez la et corrigez la. Vous verrez, il
n’est pas rare que cela ne fonctionne pas du premier coup comme on l’espérait.

1.9.2 Enregistrez
Lorsque vous travaillez sur un programme, à chaque fois que vous avez écrit une
portion qui fonctionne correctement, enregistrez votre travail sous un autre nom.
Terminez le nom du fichier par un numéro que vous incrémentez par exemple. En
procédant de la sorte, vous pourrez toujours revenir à une étape antérieure et serez
assuré que le fonctionnement de votre programme n’est pas dépendant du nom du
fichier qui le contient. C’est toujours très désagréable d’avoir un joli fichier qui ne
fonctionne plus car un de vos collègue n’a rien trouvé de mieux que de le renommer,
toujours pour une excellente raison !

1.9.3 Commentez
Commentez, commentez, commentez . . .. N’hésitez pas à mettre des commen-
taires qui vous permettront de retrouver à quoi sert telle ou telle portion du pro-
gramme quelques temps plus tard. Pensez aussi aux personnes qui vous remplace-
ront un jour et qui auront besoin de découvrir comment cela fonctionne.

1.9.4 Indentez
Afin de permettre une meilleure lisibilité, il est préférable d’indenter le texte.
Cela consiste à décaler à l’aide d’une tabulation les portions de codes représen-
tant un sous-ensemble. Si on reprend notre premier programme, on se rend compte
qu’avec une indentation correcte, on voit plus facilement que la ligne « Cells(N, 1) =
"Ligne " & N » est répétée par la boucle For. Les deux exemples ci-dessous font la
même chose mais l’un est plus facile à lire que l’autre.
Tout au long de ce document, les exemples de code seront indentés à ma façon.
Inspirez-vous en.

 Listing 1.2 – Sans indentation 

Option E x p l i c i t

Sub NumeroteLignes ( )
Dim N As Long

For N = 1 To 20
C e l l s (N, 1) = " Ligne " & N
Next N

 
End Sub
1.9 Recommandations 5

 Listing 1.3 – Avec indentation 

Option E x p l i c i t

Sub NumeroteLignes ( )
Dim N As Long

For N = 1 To 20
C e l l s (N, 1) = " Ligne " & N
Next N

 
End Sub

1.9.5 Déclarez
Déclarez de façon explicite toutes vos variables. Cela clarifie le code du pro-
gramme. En tête de chaque module , spécifiez Option Explicit afin d’obtenir
un message d’erreur si vous tentez d’utiliser une variable non déclarée. Pour éviter
de l’oublier, on peut configurer Excel pour que ce soit le fonctionnement par défaut.
Dans l’éditeur VBA, Outils , Options , Editeur . Dans les paramètres du code,
cochez Déclaration des variables obligatoire .

1.9.6 Structurez
Structurez votre programme. Définissez toujours une fonction ou une macro
avant de l’utiliser, ainsi, lorsque vous la recherchez, vous savez qu’elle se trouve
avant son utilisation. Cela vous évitera de chercher en aveugle où peut bien être
cette ... de fonction ou macro lorsqu’il s’agira de la corriger ou de l’améliorer. Que ce
soit dans un programme, un module, une fonction ou une macro, gardez toujours
l’ordre déclaration (des variables, des fonctions, des macros) puis utilisation, quant
bien même la déclaration dans le cours du programme fonctionne. Tout au long de
ce document, les exemples de code respectent cette façon de faire. Inspirez-vous en.
6 1.9 Recommandations

Option Explicit

Sub NumeroteLignes()

Déclaration Dim N As Long

For N = 1 To 20
Utilisation
Cells(N, 1) = "Ligne " \& N
Next N

End Sub

TAB. 1.1 – Structure

 7

Chapitre 2

Notions de base

2.1 Constantes et variables

Tout au long du programme, on va devoir stocker des informations que l’on vou-
dra réutiliser plus tard. Cela se fera dans des constantes ou des variables.

2.1.1 Nom
Afin de pouvoir les identifier et réutiliser, chaque constante ou variable aura un
nom. Celui-ci est constitué de lettres et chiffres mais ne contient pas d’espace. Pour
éviter tout problème, n’utilisez pas de caractères exotiques, utilisez A..Z, a..z, 0..9 et
_. Personnellement, je nomme tout en anglais, ce qui élimine le risque d’avoir mis un
accent par inadvertance. Dans ce document, j’ai essayé de mettre des noms en fran-
çais afin de les différencier plus facilement des mots utilisés par le langage. Les noms
sont libres, sous réserve de ne pas utiliser un mot réservé du langage. Vous pouvez
mélanger majuscules et minuscules de façon à faciliter leur lisibilité. Par exemple,
CompteurLigne est plus lisible que compteurligne, même si d’un point de vue pure-
ment programmation cela ne change rien.

2.1.2 Constantes
Une constante est quelque chose qui est fixe et qui ne changera pas tout au long
du programme. On va les utiliser pour des choses qui ne doivent pas évoluer au
cours du programme mais que l’on souhaite pouvoir adapter facilement. Lors de
leur définition, elles sont précédées du mot clé Const.
Exemple:
On va créer une feuille « ma super feuille » dans un classeur puis y faire appel
plusieurs fois dans le programme. Si l’on écrit le nom de la feuille à chaque fois que
l’on l’utilise dans le programme et que notre chef de service décide que son inti-
tulé n’est pas bon, il va falloir tout relire et remplacer à chaque fois l’ancien nom
par le nouveau nom. Si on a pris la précaution de définir le nom de la feuille dans
une constante et d’utiliser cette constante tout au long du programme, il suffit de
changer la valeur de la constante pour que tout le programme soit à jour.
Syntaxe:
Const TitrePage = "ma super f e u i l l e "
Le fait d’écrire Const suivi de son nom et de son contenu s’appel déclarer une
constante.
8 2.2 Commentaires

2.1.3 Variables
Une variable est quelque chose qui va évoluer et changer de valeur tout au long
du programme. On utilisera des variables pour ce qui change tel qu’un numéro de
ligne ou colonne, le contenu d’une cellule que l’on veut modifier, . . . Lors de leur dé-
finition, elles sont précédées du mot clé Dim, Private ou Public (c.f. Visibilité
page 11).
Exemple:
On veut remplir des cellules qui se suivent avec un texte donné. Au lieu d’écrire
autant de ligne que nécessaire, on va utiliser une variable pour effectuer une boucle
qui se répétera le nombre de fois désiré.

 Listing 2.1 – Variables 

Option E x p l i c i t

Sub MaSuperMacro ( )
Dim I As Integer

For I = 1 to 100
c e l l s ( 1 , I +3)= "mon super t e x t e "
Next I

 
End Sub

Le fait d’écrire Dim suivi d’un identifiant (nom) et d’un type s’appel déclarer une
variable.

2.2 Commentaires
Très rapidement, le nombre de ligne de notre programme croît. Si l’on veut être
capable de le relire et de comprendre ce qu’il fait deux ans plus tard, pour le modifier
par exemple, il va être judicieux d’y mettre des commentaires. Il s’agit de texte libre
où l’on peut mettre ce que l’on veut. Il est précédé d’une apostrophe.
Exemple:
On veut se souvenir du format à donner pour une date.
Syntaxe:
Dim DateDeDebut as String ’ d o i t ê t r e sous la forme aaaammjj

2.3 Regroupement
2.3.1 Noms de macros, fonctions, modules
Les noms de macros, de fonctions ou de modules suivent les même régles que
les constantes et variables (cf. 2.1.1 page 7).

2.3.2 Macros
Chaque macro réalise une suite d’opération. En exécutant une macro, ou en l’ap-
pelant dans un programme plus vaste, on va lui faire effectuer chacune des instruc-
tions qu’elle contient.
2.3 Regroupement 9

Exemple:
On veut ajuster les largeurs et hauteurs de toutes les cellules de la feuille.

 Listing 2.2 – Macro 

Option E x p l i c i t

Dim PosY As Long

Sub Ajuste ( NomDeLaFeuille As String )

’ a j u s t e la largeur e t hauteur des c e l l u l e s
Sheets ( NomDeLaFeuille ) . Select
C e l l s . Select
C e l l s . EntireColumn . AutoFit
C e l l s . EntireRow . AutoFit
Range ( "A1" ) . Select
End Sub

Sub TstSub ( )
’ Nomme la f e u i l l e
ActiveSheet .Name = " Test "

PosY = PosY + 1
C e l l s ( PosY , 1) = "Sub"
PosY = PosY + 1
C e l l s ( PosY , 1) = " C a l l Ajuste ( " " Test " " ) "
Call AutoAdjust ( " Test " ) "
PosY = PosY + 1

 
End Sub

2.3.3 Fonctions
Une fonction réalise une suite d’opération et retourne une valeur.
Exemple:
On veut, à partir du nom complet d’un fichier (chemin + nom de fichier), récupé-
rer le seul nom du fichier. On va donc écrire une macro qui fait cela. Elle commence
par Function suivi d’un nom et, de façon facultative, de paramètres et se termine
par End Function.

 Listing 2.3 – Fonction 

Option E x p l i c i t

Function ExtraitNomFichier ( unFichier As String ) As String

’ retourne l e nom de f i c h i e r contenu dans nomFichier
’ exemple : ExtraitNomFichier ( " c : \ windows\ notepad . exe " )
’ renverra " notepad . exe "
Dim x As Variant
x = S p l i t ( unFichier , Application . PathSeparator )
ExtraitNomFichier = x (UBound( x ) )
End Function
10 2.3 Regroupement

Sub TstFonction
Dim monFichier as String

monFichier ="c : \mon\chemin\ super \ long \ l e _ f i c h i e r . t x t "

C e l l s ( 1 , 1 ) = ExtraitNomFichier ( monFichier )

 
End Sub

2.3.4 Modules
Rapidement, on va se construire une bibliothèque de macros et de fonctions.
Il devient donc intéressant de les regrouper en fonction de leurs points commun
(macros et fonctions qui agissent sur les feuilles de classeur, macros et fonctions qui
travaillent sur les chaînes de caractères, . . .). On va donc les rassembler au sein d’un
module.
Exemple:
On peut créer le module FileFct qui contiendra toutes les fonctions que l’on va
créer et qui auront un lien avec les fichiers.

 Listing 2.4 – Module 

’ +−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−+
’ | Routines pour f i c h i e r s e t d o s s i e r s |
’ +−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−+
Option E x p l i c i t

Function CheminClasseur ( ) As String

’ retourne l e chemin du c l a s s e u r courant
CheminClasseur = ThisWorkbook . Path & Application . PathSeparator
End Function

Function NomClasseur ( ) As String

’ retourne l e nom du c l a s s e u r courant
NomClasseur = ThisWorkbook .Name
End Function

Function ExtraitChemin ( unFichier As String ) As String

’ retourne l e chemin de unFichier
’ exemple : ExtraitChemin ( " c : \ windows\ notepad . exe " )
’ retournera " c : \ windows \ "
Dim x As Variant
x = S p l i t ( unFichier , Application . PathSeparator )
ReDim Preserve x (0 To UBound( x ) − 1)
ExtraitChemin = Join ( x , Application . PathSeparator )
ExtraitChemin = ExtraitChemin & Application . PathSeparator
End Function

Function ExtraitNom ( unFichier As String ) As String

’ retourne l e nom de unFichier
’ exemple : ExtraitNom ( " c : \ windows\ notepad . exe " )
2.4 Visibilité 11

’ retournera " notepad . exe "

Dim x As Variant
x = S p l i t ( unFichier , Application . PathSeparator )
ExtraitNom = x (UBound( x ) )
End Function

Function F i c h i e r E x i s t e ( unFichier As String ) As Boolean

’ retourne true s i l e f i c h i e r e x i s t e
’ exemple : F i c h i e r E x i s t e ( " c : \ windows\ notepad . exe " )
F i c h i e r E x i s t e = Dir ( unFichier ) <> " "
End Function

Function DossierExiste (unChemin As String ) As Boolean

’ retourne true s i l e d o s s i e r e x i s t e
’ exemple : D o s s i e r E x i s t e ( " c : \ windows \ " )
Dim x As String
unChemin = ExtraitChemin (unChemin)
On Error Resume Next
x = GetAttr (unChemin) And 0
I f Err = 0 Then
DossierExiste = True
Else
DossierExiste = False
End I f

 
End Function

2.4 Visibilité
Suivant la façon d’on nous avons déclaré une variable, une macro ou une fonc-
tion, elle sera pas utilisable partout. On parle aussi de portée des déclarations.

2.4.1 Structure d’un programme

Un programme est constitué de plusieurs éléments :
– ThisWorkBook, qui contient ce qui est propre au classeur,
– autant de modules que nécessaire qui contiennent les macros et fonctions
dont nous avons besoin.
Chacuns de ces éléments est constitué d’un en-tête , qui contient les déclara-
tions qui vont être valables pour tout l’élément, et d’un corps, qui contient les ma-
cros et fonctions.

2.4.2 Déclarations
Les déclarations de variables peuvent être implicites ou explicites.
Une déclaration implicite est réalisée lorsque l’on utilise une variable que l’on
n’a pas déclarée précédement dans le programme. Excel défini alors lui-même le
type de la variable le plus approprié. Cela semble facile mais se révéle très dange-
reux plus le programme devient important. Une faute de frappe et l’on a créé une
nouvelle variable au lieu de réutiliser celle que l’on voulait.
12 2.4 Visibilité

 Listing 2.5 – Déclaration implicite 

Sub DeclarationImplicite
For I = 1 to 100
c e l l s ( 1 , I +3)= "mon super t e x t e "
Next I

 
End Sub

Une déclaration explicite est réalisée lorsque l’on va, avant utilisation, définir le
type d’une variable.

 Listing 2.6 – Déclaration explicite 

Sub D e c l a r a t i o n E x p l i c i t e
Dim I As Integer

For I = 1 to 100
c e l l s ( 1 , I +3)= "mon super t e x t e "
Next I

 
End Sub

Afin de limiter le risque d’erreur, il est préférable de spécifier Option Explicit

en en-tête de chaque module. Cela impose à Excel de vérifier que les variables ont
été déclarées avant utilisation. Si jamais il trouve une variable non déclaré, il émet
un message d’erreur. Pour éviter d’oublier de rajouter cette option, on peut confi-
gurer Excel pour qu’il soit systématiquement dans ce mode → Outils , Options ,
Editeur , cocher Déclaration de variable obligatoire

2.4.3 Portée
En utilisant les mots clés Dim, Private, Static et Public, on va indiquer
qui pourra voir, utiliser la variable définie.
Une variable déclarée Dim, Private ou Static est une variable locale. Elle
ne sera utilisable et connue que de la partie de programme (module, macro, fonc-
tion) qui la défine. Private n’est pas utilisable dans une macro (sub) ou une fonc-
tion (function). Private ne peut être utilisé qu’en entête de module.
Une variable déclarée Dim ou Private est réinitialisée à chaque lecture de sa
déclaration. Une variable déclarée Static est initialisée seulement lors de la pre-
mière lecture de sa déclaration. Par la suite, sa valeur ne fait qu’évoluer.
Une variable déclarée Public est une variable globale. Elle pourra être utilisée
par n’importe qu’elle partie du programme. Afin d’éviter les risque de confusion, on
déclarera de préférence les variables globales dans l’en-tête du module considéré.

Mise en évidence

Afin de mettre cela en évidence, j’ai crée le classeur « Test_Visibilite.xls ». Ce clas-

seur, contient deux modules. Un certain nombre de variables sont définies et initia-
lisées dans Module1. Ces variables sont ensuite affichées depuis les différents élé-
ments du programme (macro principale, macro principale de Module1, boucle de
répétition de Module 1, macro principale de Module2, boucle de répétition de Mo-
dule2). On a bien évidement commenté l’option Explicit afin de ne pas générer d’er-
reur et de visualiser le contenu des variables non définies.
2.4 Visibilité 13

Code

 Listing 2.7 – Portée - macro de test 

’ Code de ThisWorkBook :
’ ********************

’ Option E x p l i c i t

Sub Process ( )
C e l l s . Select
Selec tion . Clear
Range ( "A1" ) . Select

Call ProcessModule1
Call ProcessModule2

Cells (1 , 7) = " Valeurs dans Process "

Cells (2 , 7) = " Constante1 = "
Cells (2 , 8) = Constante1
Cells (3 , 7) = " VariablePublique1 = "
Cells (3 , 8) = VariablePublique1
Cells (4 , 7) = " VariablePrivate1 = "
Cells (4 , 8) = VariablePrivate1
Cells (5 , 7) = " VariableDim1 = "
Cells (5 , 8) = VariableDim1

Cells (6 , 7) = " Constante2 = "

Cells (6 , 8) = Constante2
Cells (7 , 7) = " VariableDim2 = "
Cells (7 , 8) = VariableDim2
Cells (8 , 7) = " VariableStatic2 = "
Cells (8 , 8) = VariableStatic2

 
End Sub
14 2.4 Visibilité

 
Listing 2.8 – Portée - module1

’ Code de Module1 :
’ ***************

’ Option E x p l i c i t

Const Constante1 = " Constante 1"

Public VariablePublic1 As String
Private V a r i a b l e P r i v a t e 1 As String
Dim VariableDim1 As String

Sub RepeteModule1 ( Boucle As Integer )

Dim Decalage As Integer

Decalage = 10 * ( Boucle − 1)

Const Constante2 = " Constante 2"

Dim VariableDim2 As String
S t a t i c V a r i a b l e S t a t i c 2 As Integer

VariablePublic1 = " VariablePublic1 from Module1"

V a r i a b l e P r i v a t e 1 = " V a r i a b l e P r i v a t e 1 from Module1"
VariableDim1 = " VariableDim1 from Module1"

VariableDim2 = " VariableDim2 from Module2"

VariableStatic2 = VariableStatic2 + 1

C e l l s (1 + Decalage , 1) = " Valeurs dans RepeteModule1"

C e l l s (1 + Decalage , 2) = " Boucle " & Boucle
C e l l s (2 + Decalage , 1) = " Constante1 = "
C e l l s (2 + Decalage , 2) = Constante1
C e l l s (3 + Decalage , 1) = " VariablePublic1 = "
C e l l s (3 + Decalage , 2) = VariablePublic1
C e l l s (4 + Decalage , 1) = " VariablePrivate1 = "
C e l l s (4 + Decalage , 2) = VariablePrivate1
C e l l s (5 + Decalage , 1) = " VariableDim1 = "
C e l l s (5 + Decalage , 2) = VariableDim1

C e l l s (6 + Decalage , 1) = " Constante2 = "

C e l l s (6 + Decalage , 2) = Constante2
C e l l s (7 + Decalage , 1) = " VariableDim2 = "
C e l l s (7 + Decalage , 2) = VariableDim2
C e l l s (8 + Decalage , 1) = " VariableStatic2 = "
C e l l s (8 + Decalage , 2) = VariableStatic2

End Sub

Sub ProcessModule1 ( )
Dim I As Integer
2.4 Visibilité 15

For I = 1 To 5
RepeteModule1 ( I )
Next I

Cells (1 , 4) = " Valeurs dans ProcessModule1"

Cells (2 , 4) = " Constante1 = "
Cells (2 , 5) = Constante1
Cells (3 , 4) = " VariablePublic1 = "
Cells (3 , 5) = VariablePublic1
Cells (4 , 4) = " VariablePrivate1 = "
Cells (4 , 5) = VariablePrivate1
Cells (5 , 4) = " VariableDim1 = "
Cells (5 , 5) = VariableDim1

Cells (6 , 4) = " Constante2 = "

Cells (6 , 5) = Constante2
Cells (7 , 4) = " VariableDim2 = "
Cells (7 , 5) = VariableDim2
Cells (8 , 4) = " VariableStatic2 = "
Cells (8 , 5) = VariableStatic2

 
End Sub

 Listing 2.9 – Portée - module2 

’ Code de Module2 :
’ ***************

’ Option E x p l i c i t

Sub RepeteModule2 ( Boucle As Integer )

Dim Decalage As Integer

Decalage = 10 * ( Boucle − 1)

C e l l s (1 + Decalage , 11) = " Valeurs dans RepeteModule2"

C e l l s (1 + Decalage , 12) = " Boucle " & Boucle
C e l l s (2 + Decalage , 11) = " Constante1 = "
C e l l s (2 + Decalage , 12) = Constante1
C e l l s (3 + Decalage , 11) = " VariablePublic1 = "
C e l l s (3 + Decalage , 12) = VariablePublic1
C e l l s (4 + Decalage , 11) = " VariablePrivate1 = "
C e l l s (4 + Decalage , 12) = VariablePrivate1
C e l l s (5 + Decalage , 11) = " VariableDim1 = "
C e l l s (5 + Decalage , 12) = VariableDim1

C e l l s (6 + Decalage , 11) = " Constante2 = "

C e l l s (6 + Decalage , 12) = Constante2
C e l l s (7 + Decalage , 11) = " VariableDim2 = "
16 2.4 Visibilité

C e l l s (7 + Decalage , 12) = VariableDim2

C e l l s (8 + Decalage , 11) = " V a r i a b l e S t a t i c 2 = "
C e l l s (8 + Decalage , 12) = V a r i a b l e S t a t i c 2

End Sub

Sub ProcessModule2 ( )
Dim I As Integer

For I = 1 To 5
RepeteModule2 ( I )
Next I

Cells (1 , 14) = " Valeurs dans ProcessModule2"

Cells (2 , 14) = " Constante1 = "
Cells (2 , 15) = Constante1
Cells (3 , 14) = " VariablePublic1 = "
Cells (3 , 15) = VariablePublic1
Cells (4 , 14) = " VariablePrivate1 = "
Cells (4 , 15) = VariablePrivate1
Cells (5 , 14) = " VariableDim1 = "
Cells (5 , 15) = VariableDim1

Cells (6 , 14) = " Constante2 = "

Cells (6 , 15) = Constante2
Cells (7 , 14) = " VariableDim2 = "
Cells (7 , 15) = VariableDim2
Cells (8 , 14) = " VariableStatic2 = "
Cells (8 , 15) = VariableStatic2

 
End Sub
2.4 Visibilité 17

Résultats

F IG . 2.1 – Visibilité dans la macro principale

F IG . 2.2 – Visibilité dans la macro de module1

18 2.4 Visibilité

F IG . 2.3 – Visibilité dans la macro de module2

F IG . 2.4 – Visibilité dans la répétition de module1

2.4 Visibilité 19

F IG . 2.5 – Visibilité dans la répétition de module2

Conclusion

– Seule la variable VariablePublic1 définie dans l’en-tête de Module1 est visible

où que l’on soit dans le programme,
– Module2 ne voit que VariablePublic1. Tout le reste lui est inconnu,
– La macro principale de Module1 ne voit que les variables et constantes défi-
nies dans l’entête du module,
– La macro de répétition de Module1 elle, voit toutes les variables et constantes
définies au sein d’elle même ou en en-tête de module,
– La variable VariableStatic2 s’initialise lors de la première exécution de la boucle
puis garde sa valeur entre deux passages dans la boucle de répétition. ATTEN-
TION, si l’on relance une nouvelle fois la macro principale Process, VariableS-
tatic2 n’est pas remise à zéro, elle continue d’évoluer à chaque passage dans la
boucle.
20 2.4 Visibilité
 21

Chapitre 3

Types

3.1 Booléen
Il s’agit des valeurs vrai et faux. On les utilise beaucoup dans les tests. Lors de leur
définition, ils sont déclarés par Boolean. Ils peuvent prendre les valeurs False (0)
et True (toute valeur différente de 0)

 Listing 3.1 – Booléen 

Sub TstBooleen
Const I = 20
Const J = 30
Dim R e s u lt a t As Boolean

R e s u lt a t = I < J
I f R e s u lt a t
c e l l s (1 ,1)= " I est inférieur à J "
Else
c e l l s ( 1 , 1 ) = " I e s t supérieur ou égal à J "
End I f

 
End Sub

3.2 Nombres

Catégorie Mot réservé Plage de valeurs

Octet Byte 0 à 255
Entier Integer -32 768 à 32 767
Entier long Long -2 147 483 648 à 2 147 483 647
Réel simple Single -3,402823 E38 à 3,402823 E38
Réel double Double -1,79769313486231 E308 à 1,79769313486231 E308
Date Date 1er janvier 100 au 31 décembre 9999
Monnaie Currency -922 337 203 685 477,5808 à 922 337 203 685 477,5807

TAB. 3.1 – Types de nombres

22 3.3 Chaînes de caractères

En cas de valeur dépassant la plage autorisée, une erreur de dépassement de

capacité est générée.
On peut avoir jusqu’à 65535 lignes et colonnes dans Excel, il faut donc utiliser le
type long pour tout ce qui à trait aux numéros de ligne ou colonne.

3.3 Chaînes de caractères

Lors de leur définition, elles sont déclarées par String.

 Listing 3.2 – Chaînes de caractères 

Sub TstChaines
Dim UneChaine As String

UneChaine = "Une chaine de c a r a c t e r e s "

UneChaine = UneChaine & " que l ’ on vient de prolonger "

 
End Sub

On peut figer leur longeur en faisant suivre String d’une * et du nombre de

caractères.
Syntaxe:
Dim UneChaineDe23Caracteres As String * 23

3.4 Variant
Ce type de variable peut avoir un contenu de n’importe quel type (booléen, en-
tier, réel, chaîne, . . .). Il est à éviter autant que faire se peut car il consomme beau-
coup de mémoire et ne permet pas de savoir le type de son contenu.

 Listing 3.3 – Variant 

Sub TstVariant
Dim UnVariant As Variant

UnVariant = "Une chaine de c a r a c t e r es "

UnVariant = True
UnVariant = 3.141592654

 
End Sub

3.5 Définies par l’utilisateur

On peut aussi définir ces propres types.

 Listing 3.4 – Défines par l’utilisateur 

Sub T s t U t i l i s a t e u r
Type T U t i l i s a t e u r
Nom As String
Prenom As String
3.6 Conversions 23

I d e n t i f i a n t As String
MotDePasse As String
End Type

Dim C l i e n t As T U t i l i s a t e u r
Dim Vendeur As T U t i l i s a t e u r

C l i e n t .Nom = "Doe"
C l i e n t . Prenom = "John"
C l i e n t . I d e n t i f i a n t = " jdoe "
C l i e n t . MotDePasse = "inconnu"

 
End Sub

3.6 Conversions
Pour effectuer des conversions entre types, on utilise :

Type d’origine Type final Fonction Remarques

Tous types Boolean CBool Toute valeur non nulle est convertie
en True, soit -1
Tous types Byte CByte
Tous types Integer CInt
Tous types Long CLng
Tous types Single CSng
Tous types Double CDbl
Tous types Date CDate Lors de la conversion d’une valeur nu-
mérique en date, la partie entiére cor-
respond à la date, la partie réelle cor-
respond à l’heure
Tous types Currency CCur Nombre à virgule fixe. 15 chiffres
avant la virgule, 4 après
Tous types String CStr

TAB. 3.2 – Conversions de chaînes

3.7 Tests
Afin de vérifier les plages et fonctionnement de chaque types, j’ai réalisé le clas-
seur « Test_Variable.xls ».
24 3.7 Tests
 25

Chapitre 4

Structures de contrôles

4.1 Boucles
4.1.1 Do . . . Loop Until
On utilisera une boucle Do . . .Loop Until lorsque l’on veut que la boucle soit
parcourue jusqu’à ce que la condition soit remplie.
Dans l’exemple ci-dessous, on exécute ce qui est entre Do et Loop Until jus-
qu’à ce que I devienne supérieur à 10.

 Listing 4.1 – Do . . . Loop Until 

Sub TstDoLoopUntil
Dim I As Long

I = 1
Do
C e l l s ( I + 1 , 1) = I
I = I + 1
Loop Until I > 10

 
End Sub

affichera les valeurs 1 à 10.

 Listing 4.2 – Do . . . Loop Until - Attention 

Sub TstDoLoopUntilAttention
Dim I As Long

I = 1
Do
C e l l s ( I + 1 , 2) = I
I = I + 1
Loop Until I > 0

 
End Sub

affichera 1. En effet, le test de condition n’est fait qu’en fin de boucle, elle est donc
au moins parcourue une fois.
26 4.1 Boucles

4.1.2 Do . . . Loop While

On utilisera une boucle Do . . .Loop While lorsque l’on veut que la boucle soit
parcourue tant que la condition est remplie.
Dans l’exemple ci-dessous, on exécute ce qui est entre Do et Loop While tant
que I est inférieur ou égal à 10.

 Listing 4.3 – Do . . . Loop While 

Sub TstDoLoopWhile
Dim I As Long

I = 1
Do
C e l l s ( I + 1 , 4) = I
I = I + 1
Loop While I <= 10

 
End Sub

affichera les valeurs 1 à 10.

 Listing 4.4 – Do . . . Loop While - Attention 

Sub TstDoLoopWhileAttention
Dim I As Long

I = 1
Do
C e l l s ( I + 1 , 4) = I
I = I + 1
Loop While I < 0

 
End Sub

affichera 1. En effet, le test de condition n’est fait qu’en fin de boucle, elle est donc
au moins parcourue une fois, même si la condition n’est pas remplie au départ.

4.1.3 While . . . Wend

Lorsque l’on voudra répéter une portion de programme tant qu’une condition
est vrai, on utilisera une boucle While . . .Wend.
Dans l’exemple ci-dessous, tant que I est inférieur ou égal à 10, on exécute ce qui
se trouve entre While et Wend.

 Listing 4.5 – While . . . Wend 

Sub TstWhileWend
Dim I As Integer

I = 1
While I <= 10
c e l l s ( I + 1 , 4) = I
I = I + 1
Wend

 
End Sub

affichera les valeurs 1 à 10. La boucle ne sera parcourue que si la condition est rem-
plie au départ. A opposer à la boucle Do . . .Loop While.
4.1 Boucles 27

4.1.4 For . . . Next

Lorsque l’on voudra répéter un nombre fini de fois une portion de programme,
nous utiliserons une boucle For . . .Next. La boucle sera parcourue le nombre de
fois indiqué avec le pas specifié (écart entre chaque répétition) .

 Listing 4.6 – For . . . Next - 1 

Sub TstForNext1
Dim I As Long

For I = 1 to 10
c e l l s ( 1 , I )= I
Next I

 
End Sub

affichera les valeurs 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 dans des cellules successives.

 Listing 4.7 – For . . . Next - 2 

Sub TstForNext2
Dim I As Long

For I = 0 to 10 step 2
c e l l s ( 1 , I /2)= I
Next I

 
End Sub

affichera les valeurs 0, 2, 4, 6, 8, 10 dans des cellules successives.

 Listing 4.8 – For . . . Next - 3 

Sub TstForNext3
Dim I As Long

For I = 10 to 1 step −1
c e l l s (1 ,11 − I )= I
Next I

 
End Sub

affichera les valeurs 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 dans des cellules successives.

28 4.2 Conditions

4.1.5 For Each . . . Next

Lorsque l’on voudra parcourir un tableau, nous utiliserons une boucle For Each
. . .Next.

 Listing 4.9 – For Each . . . Next 

Sub TstForEachNext
Dim I As Long
Dim Tableau ( 4 ) As String
Dim V i l l e As Variant

Tableau ( 0 ) = " Lille "

Tableau ( 1 ) = "Roubaix"
Tableau ( 2 ) = " Paris "
Tableau ( 3 ) = "Lyon"
Tableau ( 4 ) = " M a rs eille "

C e l l s ( 1 3 , 4) = " For Each Next"

I = 1
For Each V i l l e In Tableau
C e l l s ( I + 13 , 4) = V i l l e
I = I + 1
Next

 
End Sub

La boucle est parcourue pour chacuns des éléments du tableau et affiche Lille, Rou-
baix, Paris, Lyon, Marseille.

4.1.6 Test
Les différents tests ont été réalisés dans le classeur « Test_Boucle.xls ».

4.2 Conditions
4.2.1 If . . .Then . . . Else . . . End If
Pour un test simple, on utilisera If . . .Then . . .End If.
 Listing 4.10 – If . . .Then . . . End If 
Sub TstIfThenEndIf
Dim I As Integer

For I = 1 To 10
C e l l s ( I + 1 , 1) = I
I f I = 5 Then
C e l l s ( I + 1 , 2) = " I = 5"
End I f
Next I

 
End Sub

affichera « I = 5 » lorsque I aura la valeur 5 et rien dans les autres cas.

4.2 Conditions 29

Si la test à besoin d’être plus évolué, on utilisera la forme compléte If . . .Then

. . .Else . . .End If.

 Listing 4.11 – If . . .Then . . . Else . . . End If 

Sub TstIfThenElseEndIf
For I = 1 To 10
C e l l s ( I + 1 , 4) = I
I f I < 5 Then
C e l l s ( I + 1 , 5) = " I < 5"
Else
I f I > 5 Then
C e l l s ( I + 1 , 5) = " I > 5"
Else
C e l l s ( I + 1 , 5) = " I = 5"
End I f
End I f
Next I

 
End Sub

affichera « I < 5 » lorsque I sera inférieur à 5 , « I = 5 » lorsque I aura la valeur 5, « I >

5 » lorsque I sera supérieur à 5 .

4.2.2 Select . . . Case

Lorsque l’on aura besoin de faire des tests multiples sur une variable, on utilisera
Select . . .Case.

 Listing 4.12 – Select . . . Case 

Sub TstSelectCase
Dim I As Integer

For I = 1 To 10
C e l l s ( I + 13 , 1) = I

Select Case I
Case 1
Cells ( I + 13 , 2) = " I à l a valeur 1"
Case 2
Cells ( I + 13 , 2) = " I à l a valeur 2"
Case 8 To 10
Cells ( I + 13 , 2) = " I e s t compris entre 8 et 10"
Case Else
Cells ( I + 13 , 2) = " I e s t supérieur à 2"
End Select
Next I

 
End Sub

affichera « I à la valeur 1 » lorsque I sera égal à 1 , « I à la valeur 2 » lorsque I aura la

valeur 2, « I est compris entre 8 et 10 » lorsque I aura les valeurs 8, 9 ou 10 et « I est
supérieur à 2 » dans tous les autres cas.
30 4.2 Conditions

4.2.3 Test
Les différents tests ont été réalisés dans le classeur « Test_Condition.xls ».