Utilisation des variables tableaux en VBA
Page créée le : 11/11/2009
Introduction
L'utilisation de tableaux est surtout utile lorsque l'on manipule des plages très importantes.
La vitesse d'exécution est nettement améliorée.
Pour exemple, avec un tableau (similaire au second exemple) de 1120 lignes et 248 colonnes (277760 cellules)
dans lequel on veut remplacer le contenu de chaque cellule par son équivalent contenu dans un tableau
de correspondances:
A-Version avec une boucle de type For ... Each, le temps de traitement est de 4 minutes.
B-Version avec tableau, le temps de traitement passe à 7 secondes.
Les tableaux sont des variables VBA pouvant contenir plusieurs données (éléments).
Le tableau est déclaré en incluant des parenthèses après le nom de la variable.
Plan de la présentation
Représentation synoptique des tableaux à une et deux dimensions
Les tableaux de taille fixe
Les tableaux dynamiques
Les tableaux multidimensionnels
L'instruction ReDim
Le mot clé Preserve
Les fonctions LBound et Ubound
L'instruction Option Base
Quelques exemples à télécharger
Représentation synoptique de la structure d'un tableau à une dimension
Représentation synoptique de la structure d'un tableau à deux dimensions
Les tableaux de taille fixe
Un tableau est dit de taille fixe lorsque ses dimensions sont prédéfinies au moment de la
déclaration de la variable.
La ligne de code suivante montre comment déclarer un tableau fixe.
L'indice (5) spécifie la taille du tableau.
L'indice inférieur d'un tableau peut commencer à 0 ou à 1 en fonction de l'instruction Option Base.
As Integer définit le type de données.
Les tableaux se déclarent de la même façon que les autres variables.
Tous les types de variables peuvent être utilisés afin de déclarer un tableau.
Cela signifie que le tableau pourra contenir 5 éléments.
Dans l'exemple ci-dessous, 1 est le plus petit index du tableau, et 5 l'index le plus élevé,
car vous remarquerez que pour Option Base on a précisé: 1, donc le plus petit indice (index) du
tableau sera 1 et non pas 0.
Cette procédure simplifiée montre comment alimenter les éléments du tableau et comment boucler
sur ces mêmes éléments afin d'en lire le contenu.
| |
Sub
TableauFixe()
'Définit la taille du tableau et le type de données.
Dim
Note(
5
)
As Integer
Dim
i
As Integer
'Ecrit les éléments du tableau dans la variable Note
Note(
1
) =
12
: Note(
2
) =
14
: Note(
3
) =
15
: Note(
4
) =
16
: Note(
5
) =
18
'Boucle sur les éléments du tableau pour lire leur contenu (Note)
For
i =
1
To
5
MsgBox Note(i)
Next
i
End Sub
|
Les tableaux dynamiques
Si vous ne spécifiez pas la dimension au moment de la déclaration de la variable, le tableau est appelé dynamique.
Ce type de tableau est utilisé lorsque l'on ne connait pas à l'avance la taille et/ou les dimensions à attribuer.
Cela est notamment le cas lorsque l'on travaille sur des plages de cellules qui varient régulièrement.
Ces dimensions seront précisées en cours de procédure avec l'instruction ReDIm.
Vous pouvez ainsi changer aussi souvent que vous le souhaitez:
- Le nombre de dimensions (Voir la rubrique Les tableaux multidimensionnels).
- Le nombre d'éléments (Voir la rubrique Option Base).
- Les limites supérieures et inférieures de chaque dimension (Voir les rubriques Option Base, LBound et UBound).
Pour rendre un tableau dynamique, n'indiquer aucune valeur entre les parenthèses (contrairement aux tableaux fixes)
lorsque vous déclarez la variable.
L'exemple ci-dessous montre comment définir la taille du tableau à partir de la variable "J".
Vous remarquerez qu'Option Base est précisé: 1 est donc le plus petit indice (index) du tableau.
| |
Option Base
1
Sub
TableauDynamique()
'Définit le type de données pour le tableau.
Dim
Note()
As Integer
Dim
J
As Integer
' Définit la taille du tableau
ReDim
Note(J)
Note(
1
) =
12
: Note(
2
) =
14
: Note(
3
) =
15
: Note(
4
) =
15
: Note(
5
) =
18
' Alimente les éléments du tableau et restitue les notes de chaque élève
For
J =
1
To
UBound
(Note)
MsgBox
"Eleve "
& Chr
(
64
+ J)
&
"="
&
Note(J)
Next
J
End Sub
|
C'est ReDim qui attribue de l'espace mémoire aux tableaux dynamiques (voir l'aide).
Les tableaux multidimensionnels
Jusqu'à présent nous n'avons vu que des tableaux à une seule dimension.
On peut définir des tableaux jusqu'à soixante (60) dimensions mais dans notre cas nous nous
bornerons à simplement deux dimensions.
Les commandes suivantes déclarent des tableaux à deux dimensions:
Il suffit d'insérer des virgules pour séparer chaque dimension, quand vous déclarez le tableau.
Cet exemple déclare un tableau de 2 dimensions:
| |
Dim
Note(
10
,
20
)
As Integer
|
On peut aussi écrire:
| |
Dim
Note(
1
To
10
,
1
To
20
)
As Integer
|
Le nombre total d'éléments disponible est donc le produit des tailles de toutes les dimensions (ex.200).
Lorsque que l'on souhaite agrandir un tableau dynamique tout en conservant les données existantes, seule la
dernière dimension peut être redimensionnée (Voir l'aide ReDim Preserve pour plus de détails).
Utilisation de boucles imbriquées pour manipuler les tableaux à plusieurs dimensions.
| |
Sub
TableauMultiDimensionnel()
Dim
i
As Integer
, j
As Integer
'Définit le tableau à 2 dimensions ainsi que leur taille.
Dim
Note(
1
To
5
,
1
To
2
)
As Integer
For
i =
1
To
UBound
(Note,
1
)
'boucle sur la 1ere dimension
For
j =
1
To
UBound
(Note,
2
)
'boucle sur la 2eme dimension
'Alimente les éléments du tableaux
Note(i, j) = i
&
j
'Lit les éléments du tableau
Debug.Print Note(i, j)
Next
j
Next
i
End Sub
|
Dans cet exemple, Option Base n'est pas pris en compte car on définit nous même l'index le plus petit.
L'instruction ReDim
L'instruction ReDim est utilisée pour définir (ou redéfinir), en cours de procédure, l'espace mémoire alloué
à un tableau dynamique.
ReDim sert pour:
|
- Redéfinir le nombre d'éléments.
- Changer le nombre de dimensions.
- Etablir les limites supérieures et inférieures de chaque dimension.
|
| |
Sub
DoubleRedim()
'Déclare la variable tableau
Dim
Eleve()
As String
Dim
i
As Integer
'Redéfinit la taille du tableau à 2
ReDim
Eleve(
2
)
'Boucle sur les éléments du tableau pour le remplir avec les lettres des élèves
For
i =
0
To
UBound
(Eleve)
Eleve(i) =
Chr
(
65
+ i)
Next
i
'Redéfinit la taille du tableau à 4
ReDim
Eleve(
4
)
'Boucle sur les éléments du tableau pour le remplir
For
i =
0
To
UBound
(Eleve)
Eleve(i) =
Chr
(
65
+ i)
Debug.Print Eleve(i)
Next
i
End Sub
|
A chaque fois que vous modifiez la taille d'un tableau, le contenu des anciens éléments est effacé.
| |
Sub
ChangeRedim()
'Déclare la variable
Dim
Eleve()
As String
Dim
i
As Integer
'Définit la taille du tableau
ReDim
Eleve(
5
)
'Boucle sur les éléments du tableau pour le remplir
'avec les lettres des élèves: A,B,C,D,E et F
For
i =
0
To
UBound
(Eleve)
Eleve(i) =
Chr
(
65
+ i)
Next
i
'Renvoie la lettre de l'élève A
MsgBox
"Le premier élément du tableau est: "
&
Eleve(
0
)
'Redéfinit et réduit la taille du tableau.
ReDim
Eleve(
3
)
' Les anciens éléments ont été effacés car la taille du
' tableau a été redéfinie et la chaîne renvoyée est vide
MsgBox
"Le premier élément du tableau est: "
&
Eleve(
0
)
End Sub
|
Le mot clé Preserve
Nous avons vu plus haut que l'instruction ReDim modifie la taille des tableaux, mais efface les anciens éléments.
Si on ajoute le mot clé Preserve on peut redimensionner le tableau sans en perdre les données déjà existantes.
Si vous utilisez le mot clé Preserve, vous ne pouvez redimensionner que la dernière dimension du tableau. Vous ne
pouvez en aucun cas modifier le nombre de dimensions. Par exemple, si votre tableau n'a qu'une dimension, vous pouvez
la modifier puisqu'il s'agit de la dernière et seule dimension. Toutefois, si le tableau compte plusieurs dimensions,
seule la taille de la dernière dimension est modifiable si vous souhaitez préserver le contenu du tableau.
L'exemple suivant montre comment augmenter la taille de la dernière dimension d'un tableau dynamique sans effacer
les données qu'il contient :
| |
Sub
ExemplePreserve()
' Vos lignes de code ...
ReDim
Note(
10
,
10
)
' des lignes de code ....
ReDim
Preserve Note(
10
,
15
)
' des lignes de code ....
End Sub
|
De même, le mot clé Preserve ne permet de redimensionner un tableau qu'en modifiant la limite supérieure ; toute
modification de la limite inférieure provoque une erreur.
Les fonctions LBound et UBound
La fonction UBound est utilisée avec la fonction LBound pour déterminer la taille d'un tableau.
Utilisez la fonction LBound pour connaître la limite inférieure d'une dimension de tableau.
La fonction UBound renvoie les valeurs ci-dessous pour un tableau dont les dimensions sont les suivantes :
| |
Dim
Note(
1
To
10
,
1
To
5
)
|
UBound(Note,1) renvoie 10
UBound(Note,2) renvoie 5
Option Base
La limite inférieure des tableaux est définie par l'instruction Option Base.
La valeur peut être 0 ou 1.
Si l'instruction n'est pas spécifiée dans le module, la base par défaut est 0.
Option Base doit être placée tout en haut du module, avant toute procédure ou déclaration.
Celle ci est valable uniquement pour le module où elle est située.
Deux exemples avec Option Base 0 et Option Base 1
| |
Option Base
0
Sub
TesteOptionBase()
Dim
Eleve(
5
)
As Integer
MsgBox
"La limite inférieure est de : "
& LBound
(Eleve)
&
_
" et la limite supérieure est de : "
& UBound
(Eleve)
End Sub
|
Le code ci-dessus renvoie le message suivant ...
| |
Option Base
1
Sub
TesteOptionBase()
Dim
Eleve(
5
)
As Integer
MsgBox
"La limite inférieure est de : "
& LBound
(Eleve)
&
_
" et la limite supérieure est de : "
& UBound
(Eleve)
End Sub
|
Le code ci-dessus renvoie le message suivant ...
Quelques exemples à télécharger
Cet exemple convertit des codes décimaux en code caractères depuis un tableau de 32 cellules:
Le code utilise deux boucles imbriquées.
Télécharger le code de cet exemple.
Ce second exemple remplace des codes par leur équivalent issu d'une table de correspondance.
Le code utilise un tableau de stockage de l'équivalence des codes et deux boucles imbriquées.
Télécharger le code de cet exemple.