Les variables Excel VBA

Les variables et constantes sont les fondations de tout code VBA : elles permettent de stocker, manipuler et réutiliser des données tout au long de l’exécution de vos macros.

Tuto Excel VBA de 2026

Qu’est-ce qu’une variable en VBA ?

Une variable est un espace mémoire qui permet de stocker une valeur temporaire pendant l’exécution de votre code : un nombre, un texte, une date, ou même une référence vers un objet Excel.

Chaque variable possède un nom, que vous choisissez librement (en respectant quelques règles de nommage), et un type, qui détermine la nature des données qu’elle peut contenir et l’espace mémoire qui lui sera réservé.

Vous verrez juste après les types de variable possible.

Déclarer une variable

Pour créer une variable, on utilise le mot-clé Dim suivi de son nom, puis As et de son type :

Dim nom As String

Dim prenom As String' chaque variable est bien typée String

Déclarer plusieurs variables sur une seule ligne

Dim nom As String, prenom As String

Déclarer une variable sans type

Dim nom

⚠️ Dans cette deuxième ligne, sans type la variable nom devient automatiquement de type Variant (le type par défaut quand aucun n’est précisé).

Cela ne génère pas d’erreur visible, mais peut créer des comportements inattendus plus loin dans votre code. Pour être sûr de typer correctement toutes vos variables, le plus sûr reste de les déclarer une par ligne, ou de répéter As pour chacune.

💡 Bonne pratique : ajoutez l’instruction Option Explicit tout en haut de chaque module. Elle oblige à déclarer toutes vos variables avant de les utiliser, ce qui permet à VBA de détecter automatiquement vos fautes de frappe sur les noms de variables – sans cette instruction, une faute de frappe crée silencieusement une nouvelle variable vide, ce qui peut provoquer des bugs très difficiles à repérer.

Types de variable vba

Ce tableau résume les types de données les plus utilisés en VBA, avec leur taille en mémoire, leur plage de valeurs admise, et les pièges ou limites à connaître avant de les choisir.

🔢 Types numériques entiers

Type	Taille	Plage de valeurs	Limite / piège
Byte	1 octet	0 à 255	Pas de nombres négatifs ni de décimales. Réservé aux très petits compteurs.
Integer	2 octets	-32 768 à 32 767	Insuffisant pour compter les lignes d’une grande feuille Excel (plus d’un million de lignes possibles).
Long	4 octets	-2 147 483 648 à 2 147 483 647	Type recommandé par défaut pour tous les entiers, même petits – évite de changer de type si la valeur grandit.
LongLong*	8 octets	± 9,2 × 10¹⁸ (environ)	*Disponible uniquement en VBA 64 bits. Rarement nécessaire en usage courant.

💰 Types numériques décimaux

Type	Taille	Plage de valeurs	Limite / piège
Single	4 octets	± 1,4×10⁻⁴⁵ à ± 3,4×10³⁸	Précision simple : peut accumuler de petites erreurs d’arrondi sur des calculs en chaîne.
Double	8 octets	± 4,9×10⁻³²⁴ à ± 1,8×10³°⁸	Précision double, très utilisé. Comme Single, reste sujet aux arrondis binaires (éviter pour des montants exacts en euros).
Currency	8 octets	± 922 337 203 685 477,5807	4 décimales fixes maximum, mais aucun arrondi imprévu – idéal pour les calculs financiers.
Decimal*	14 octets	jusqu’à 28 décimales	*N’existe pas comme type direct : nécessite de déclarer la variable en Variant puis d’utiliser CDec().

📝 Autres types courants

Type	Taille	Plage de valeurs	Limite / piège
String	1 ou 2 octets/car.	0 à ~2 milliards de caractères (longueur variable)	Une chaîne à longueur fixe (String * N) tronque silencieusement tout texte dépassant N caractères, sans erreur.
Boolean	2 octets	True ou False	Aucune valeur intermédiaire possible. Converti en 0 (False) ou -1 (True) si manipulé comme un nombre.
Date	8 octets	1ᵉʳ janvier 100 à 31 déc. 9999	Stockée en interne comme un nombre à virgule (jours depuis le 31/12/1899). Le séparateur décimal VBA est toujours le point.
Object	4 ou 8 octets (pointeur)	Référence vers un objet (Range, Worksheet…)	Liaison tardive : VBA ne connaît le type exact qu’à l’exécution, ce qui désactive l’auto-complétion et ralentit légèrement le code.
Variant	16 à 22+ octets	Tout type (texte, nombre, date, erreur…)	Type par défaut si non précisé. Désactive la détection d’erreurs de VBA et consomme le plus de mémoire – à éviter par défaut.

✅ Comment choisir rapidement ?

• Un nombre entier (compteur, index, année) → Long

• Un nombre à virgule courant (moyenne, mesure, pourcentage) → Double

• Un montant financier (prix, facture, TVA) → Currency

• Du texte (nom, adresse, commentaire) → String

• Une date ou une heure → Date

• Un indicateur vrai/faux → Boolean

• Une référence à un objet Excel (feuille, plage, classeur) → le type d’objet précis (Worksheet, Range…) plutôt qu’Object générique

⚠️ Dans tous les cas, évitez Variant sauf nécessité réelle : c’est le type le plus gourmand en mémoire et le moins sûr, puisqu’il accepte silencieusement n’importe quelle valeur sans vérification.

💡 Conseil pratique : avec les ordinateurs modernes, l’optimisation extrême de la mémoire n’est plus l’enjeu qu’elle était il y a vingt ans. Beaucoup de développeurs simplifient en utilisant Long pour tous leurs entiers et Double pour tous leurs décimaux, plutôt que de jongler finement entre Byte, Integer et Single. L’essentiel est surtout d’éviter Variant par défaut, et de na choisir un type entier (comme Integer) que pour des valeurs réellement entières.

Les constantes : des valeurs qui ne changent jamais

Une constante est une valeur fixe, qui ne changera jamais pendant l’exécution du programme 🔒. Contrairement à une variable déclarée avec Dim, une constante se déclare avec le mot-clé Const, et sa déclaration inclut directement sa valeur – il n’y a pas d’étape d’affectation séparée.

Const AGE_MAJORITE As Integer = 18

Une constante peut aussi être rendue accessible à tout le projet en ajoutant Public avant Const, ou rester limitée à son module avec Private. Par convention, les constantes s’écrivent en MAJUSCULES, ce qui les distingue visuellement des variables « classiques » dans le code.

❌ Toute tentative de modifier une constante après sa déclaration génère une erreur de compilation :

Const AGE_MAJORITE As Integer = 18

AGE_MAJORITE = 19  ' Erreur de compilation !

Les constantes sont particulièrement utiles pour les valeurs qui reviennent souvent dans votre code (un taux de TVA, un nombre maximal de lignes, un nom de feuille de référence) : en centralisant leur valeur à un seul endroit, vous évitez d’avoir à les modifier à plusieurs reprises dans votre code si elles changent.

5 exemples concrets d’utilisation des variables en VBA

Les types de données restent abstraits tant qu’on ne les voit pas à l’œuvre. Voici cinq exemples progressifs, du plus simple au plus avancé, qui montrent comment les variables s’utilisent réellement dans des macros Excel du quotidien.

Exemple 1 : Calculer et afficher un résultat

Le cas le plus simple : stocker deux valeurs, effectuer un calcul, puis afficher le résultat dans une boîte de dialogue.

Sub CalculerTotal()

Dim prixUnitaire As Currency

Dim quantite As Long

Dim total As Currency

prixUnitaire = 12.5

quantite = 8

total = prixUnitaire * quantite

MsgBox "Le total est de " & total & " €"

End Sub

👉 Ici, prixUnitaire et total sont en Currency pour éviter tout arrondi imprévu sur un montant financier, tandis que quantite est en Long puisqu’il s’agit d’un nombre entier.

Exemple 2 : Lire des cellules et concaténer du texte

Un usage très courant : récupérer le contenu de plusieurs cellules dans des variables, puis les assembler pour produire un message personnalisé.

Sub SaluerClient()

Dim nom As String

Dim prenom As String

Dim age As Long

nom = Cells(2, 1)    ' lit la cellule A2

prenom = Cells(2, 2) ' lit la cellule B2

age = Cells(2, 3)    ' lit la cellule C2

MsgBox "Bonjour " & prenom & " " & nom & ", " & age & " ans"

End Sub

👉 L’objet Cells(ligne, colonne) permet de désigner une cellule par ses coordonnées numériques, pratique pour automatiser la lecture. L’opérateur & sert ensuite à concaténer (assembler) le texte et les valeurs des variables.

Exemple 3 : Utiliser une variable comme compteur dans une boucle

Les variables sont indispensables pour piloter des boucles, qui répètent une action sur plusieurs cellules.

Sub RemplirSerie()

Dim i As Long

For i = 1 To 10

    Cells(i, 1).Value = i * 10

Next i

End Sub

👉 La variable i joue ici le rôle de compteur : elle prend successivement les valeurs 1, 2, 3… jusqu’à 10, et sert à la fois à désigner la ligne (via Cells(i, 1)) et à calculer la valeur à y inscrire (i * 10). Résultat : les cellules A1 à A10 sont remplies avec 10, 20, 30… jusqu’à 100.

Exemple 4 :Accumuler une somme au fil d’une boucle

Un scénario très fréquent en entreprise : créer un compteur en VBA.

Aussi vous allez parcourir une colonne de valeurs pour en calculer le total, sans connaître à l’avance le nombre de lignes.

Sub SommerColonne()

Dim total As Double

Dim ligne As Long

total = 0  ' initialisation indispensable avant la boucle

ligne = 1

Do While Cells(ligne, 1).Value <> ""

    total = total + Cells(ligne, 1).Value

    ligne = ligne + 1

Loop

MsgBox "Total : " & total

End Sub

👉 La variable total s’accumule à chaque passage de boucle : on lui ajoute la valeur de la cellule courante, puis on avance à la ligne suivante via ligne = ligne + 1. La boucle Do While s’arrête d’elle-même dès qu’elle rencontre une cellule vide – inutile de connaître à l’avance le nombre de lignes à traiter.

Exemple 5 : Une variable objet pour manipuler une feuille

Les variables ne stockent pas que du texte ou des nombres : elles peuvent aussi référencer un objet Excel, comme une feuille de calcul. On utilise alors le mot-clé Set plutôt qu’un simple =.

Sub CreerFeuilleMensuelle()

Dim feuille As Worksheet

Set feuille = ThisWorkbook.Worksheets("Janvier")

feuille.Name = "Février"        ' renomme la feuille

feuille.Range("A1").Value = "Rapport Février"

feuille.Tab.Color = RGB(0, 153, 51)  ' onglet vert

End Sub

👉 La variable feuille, de type Worksheet, évite de répéter à chaque ligne ThisWorkbook.Worksheets("Janvier") – on écrit le chemin complet une seule fois, lors de l’affectation avec Set, puis on réutilise simplement feuille ensuite. Le code est plus court, plus lisible, et plus facile à maintenir si le nom de la feuille venait à changer.

⚠️ À retenir : toute variable qui référence un objet (Worksheet, Range, Workbook…) doit être affectée avec le mot-clé Set, contrairement aux variables « simples » (nombre, texte, date) qui utilisent uniquement =. Oublier Set devant une affectation d’objet déclenche l’erreur « Erreur d’exécution 91 », très fréquente chez les débutants.

Le symbole = en VBA : affectation ou test d’égalité ?

Le signe = apparaît partout en VBA – et pourtant, il ne signifie pas toujours la même chose 🤔 ! Selon le contexte, il sert tantôt à affecter une valeur à une variable, tantôt à tester une égalité entre deux valeurs. Cette double casquette déroute souvent les débutants, alors détaillons les deux usages.

✍️ L’affectation : écriture = lecture

Quand = sert à affecter une valeur, il ne s’agit pas d’une égalité mathématique mais d’une relation d’affectation : le côté gauche du = est l’ÉCRITURE (la variable qui reçoit la valeur), et le côté droit est la LECTURE (l’expression évaluée pour produire cette valeur).

Dim i As Byte

i = 10   ' on évalue 10 (lecture), puis on l’affecte à i (écriture)

i = i + 1 ' on évalue i+1, soit 10+1=11, puis on l’affecte à i

✅ Résultat : la variable i vaut désormais 11. VBA a d’abord lu et calculé la valeur à droite, puis seulement ensuite l’a écrite dans la variable à gauche – c’est cet ordre d’évaluation qui justifie l’expression « écriture = lecture ».

Le test d’égalité : quand = compare deux valeurs

Dans une structure conditionnelle comme If, le même symbole = change complètement de rôle : il compare deux valeurs et renvoie True ou False, sans rien modifier en mémoire.

If i = 10 Then

    MsgBox "i vaut bien 10"

End If

Ici, VBA ne stocke rien : il compare la valeur de i à 10, et exécute le bloc Then uniquement si la comparaison est vraie. Cette logique s’applique aussi dans les boucles conditionnelles comme Do While ou les structures Select Case.

📋 Règle simple pour s’y retrouver d’un coup d’œil : si le = se trouve seul sur une ligne (sans If, ElseIf ni Case avant lui), c’est une affectation ✨. S’il apparaît à l’intérieur d’une condition, c’est un test d’égalité.

Le piège classique : les types numériques tronqués

Un bug particulièrement frustrant pour les débutants vient du type choisi lors de la déclaration. Regardez cet exemple :

Dim n As Integer

n = 1.2545

If n = 1.2545 Then

    MsgBox "n est bien égal à 1.2545"

End If

🚨 Surprise : la MsgBox ne s’affiche jamais ! En effet, n a été déclaré en Integer, un type qui ne stocke que des nombres entiers. Lors de l’affectation, VBA a silencieusement tronqué la partie décimale : n vaut en réalité 1, pas 1,2545. Le test d’égalité échoue donc systématiquement, sans le moindre message d’erreur – c’est exactement le genre de bug invisible le plus difficile à repérer en relecture de code.

✅ La solution : choisissez toujours un type adapté à la nature réelle de vos valeurs. Pour des nombres à virgule, utilisez Single ou Double plutôt que Integer, Long ou Byte.