Focus sur les variables en VBA [#05 FORMATION EXCEL VBA COMPLETE]

Comme nous l’avons vu la semaine dernière, dès lors que nous souhaitons réaliser des opérations et des calculs, en VBA comme dans n’importe quel autre langage de programmation, nous allons devoir utiliser une variable. Voici dans ce chapitre une présentation des variables en VBA, ainsi qu’une description de leur fonctionnement.

Téléchargement

Vous pouvez obtenir le fichier d'exemple de cet article et découvrir la méthode d'apprentissage d'Excel pas-à-pas en cliquant sur le lien suivant :

Tutoriel Vidéo

Vidéo 1 : Focus sur les variables de VBA

Vous trouverez très régulièrement de nouvelles vidéos sur la chaîne, alors pensez à vous abonner pour ne manquer aucune astuce et devenir rapidement un pro d’Excel (cliquez-ici) !

Vidéo 2 : Benchmark des types de variables VBA

Vous trouverez très régulièrement de nouvelles vidéos sur la chaîne, alors pensez à vous abonner pour ne manquer aucune astuce et devenir rapidement un pro d’Excel (cliquez-ici) !

Vidéo 3 : Comprendre la portée des variables en variables VBA

Vous trouverez très régulièrement de nouvelles vidéos sur la chaîne, alors pensez à vous abonner pour ne manquer aucune astuce et devenir rapidement un pro d’Excel (cliquez-ici) !

Vidéo 4 : Manipuler tous les types de variables VBA

Vous trouverez très régulièrement de nouvelles vidéos sur la chaîne, alors pensez à vous abonner pour ne manquer aucune astuce et devenir rapidement un pro d’Excel (cliquez-ici) !

1. Qu’est-ce qu’une variable ?

Pour réaliser des calculs dans un programme, il est nécessaire d’enregistrer des informations directement dans la mémoire de l’ordinateur.

Ces informations sont enregistrées à un endroit bien précis et identifiées par un nom, ce qui permettra de les retrouver facilement par la suite.

Cet espace de stockage alloué et que l’on retrouve à partir de son nom est ce que l’on appelle une variable :

Sub lesVariables() 
    maVariable = 1 
End Sub

Ici, nous avons une variable qui porte le nom explicite de « maVariable » et à laquelle nous donnons pour valeur « 1 », grâce au signe égal « = ».

En VBA, les variables sont dites dynamiques, c’est-à-dire qu’elles peuvent changer de valeur à tout moment :

Sub lesVariables() 
    maVariable = 1
    maVariable = 2
End Sub 

Ici, cette même variable « maVariable », à laquelle nous avions affecté la valeur « 1 » prend juste après comme valeur « 2 ».

2. Déclarons nos variables !

   2.1. Comment déclarer une variable ?

Dans l’exemple vu dans au-dessus, nous ne nous sommes pas embêtés à instancier la variable, nous avons juste demandé à Excel de lui affecter une valeur.

En réalité, Excel s’est quand même occupé de cette tâche à notre place, mais sans se soucier de réellement optimiser le code VBA.

Indirectement, voici la ligne ajouté par Excel à notre code pour déclarer la variable :

Sub lesVariables()
 Dim maVariable As Variant
 maVariable = 1
 maVariable = 2
End Sub

Dans ce code, nous retrouvons :

• Dim : Instruction qui permet d’ajouter une variable dans la mémoire de l’application (nous verrons dans un chapitre bonus que nous pouvons également utiliser les instructions Public et Static)
• maVariable : il s’agit du nom de la variable que nous avons choisi nous-même d’utiliser
• As : Mot-clé qui permet de spécifier le type de la variable
• Variant : Type affecté par Excel à la variable. Nous verrons juste après dans la troisième partie de ce chapitre que le type Variant n’est absolument pas optimisé, il a pour vocation de prendre n’importe quel type de données

Aussi, plutôt de laisser Excel agir en électron libre, nous pouvons (et devons lorsque l’application commence à prendre de l’envergue) déclarer nous-même cette variable !

Pour cela, nous utilisons la même démarche qu’Excel, mais en choisissant un typage optimisé :

Sub lesVariables()
 Dim maVariable As Integer
 maVariable = 1
 maVariable = 2
End Sub

Nous verrons juste après à quoi correspond le type de variable Integer.

   2.2. Quand déclarer une variable ?

Quand créer une variable ? À cette question, nous retrouvons deux écoles :

• Soit créer la variable au moment où le besoin s’en fait sentir dans le déroulement de la procédure,
• Soit créer toutes les variables en début de procédure afin de les retrouvées listées toutes ensembles,

Sub declarationAuFilDeLaProcedure()
    Dim maVariable1 As Integer
    maVariable1 = 1
    Dim maVariable2 As Integer
    maVariable2 = maVariable1 + 1
End Sub
 
Sub declarationAuDebutDeLaProcedure()
    Dim maVariable1 As Integer
    Dim maVariable2 As Integer
    maVariable1 = 1
    maVariable2 = maVariable1 + 1
End Sub 

En réalité, il existe une troisième méthode, qui est finalement celle que j’utilise sans même m’en rendre compte et qui est un mélange des deux précédentes : sur le principe les variables sont déclarées en début de procédure, à l’exception des variables qui n’ont qu’une durée de vie limité (par exemple une variable utilisée dans une boucle).

3. Les types de variables

   3.1. Les principaux types

Le langage VBA est dit « typé ». C’est-à-dire que toutes les variables ne vont pas forcément avoir mêmes informations à traiter.

Certaines variables vont stocker du texte saisi entre guillemets ("ceci est un texte"), d’autres un nombre entier (12), d’autres un nombre décimal (12,48).

Voici une synthèse des principaux types de variables que nous allons utiliser dans nos application VBA :

Dans le cadre d’une optimisation des ressources allouées, l’objectif va alors être de choisir le type de données qui correspond le mieux à l’utilisation qui va être faite de la variable, tout en utilisant le moins de ressources mémoire possible.

Malgré ce tableau, vous ne savez pas quel type choisir ? Ou même si une variable peut être amenée à changer de type ? Pas de problème, le type Variant permet de remplacer tous les autres types.

C’est d’ailleurs le type par défaut qui sera affecté à une variable dont le type n’est pas précisé.

Mais évidemment, ce type de données occupe une place plus importante dans la mémoire et pourrait une cause de ralentissements sur de grosses applications composées de nombreuses variables de ce type.

Comparer les vitesses d’exécutions de chaque type de variables est un vaste sujet, que nous allons justement voir dès à présent avec la mise en place d'un benchmarking destiné à comparer les vitesses d'execution des différents types de variables.

   3.2. Mesurer les vitesses d'executions

Un outil de benchmarking permet d’effectuer des mesures qui permettent de comparer plusieurs éléments les uns avec les autres.

L’idée est donc d’effectuer plusieurs fois une même opération en modifiant un seul élément, afin de réaliser des mesures et d’en tirer des conclusions.

   3.3. Mesurer quoi ?

Dans cet article, ce qui va nous intéresser c’est de savoir s’il est vraiment nécessaire de déclarer les variables dans une macro VBA, ou si l’on peut laisser à Excel le soin de gérer les typages de variables par lui-même, sachant qu’il ne va pas s’embêter à optimiser le code, mais au contraire d’aller au plus simple en utilisant le type Variant.

Pour rappel, le type d’une variable permet de spécifier l’usage que nous allons faire de celle-ci, afin d’allouer les bonnes ressources. Le type Variant a faculté de ne pas être figé, et tel un caméléon peut évoluer au fil du temps afin de s’adapter à son environnement, et donc des usages fait de cette variable.

Une variable ainsi typée pourra ainsi permettre de manipuler du texte, des nombres entiers, des dates,… mais le revers de la médaille c’est que plus une variable est versatile, et plus celle-ci va demander de ressources pour être utilisée. Du moins en théorie, et c’est ce que nous allons tenter de démont(r)er.

   3.4. Mise en place

Évidemment, pour évaluer les temps de réalisation d’une opération en VBA, il est nécessaire de mettre en place une macro développée elle-même en… VBA !

Celle-ci va être simple, et va consister à utiliser des variables pour effectuer des opérations très simple… 100 millions de fois !

 Sub testTypeNonDeclare()
    Dim heureDebut As Single, duree As Single
    Dim i As Long
    
    ' Enregistrement de l'heure de début
    heureDebut = Timer
    
    For i = 1 To 100000000
        a = 1
        b = a + 1
        a = a + b
        b = a * b
    Next
    
    ' Inscription de l'heure de fin
    duree = Timer - heureDebut
    Sheets("05.1-Les variables").[b7].Value =
 duree End Sub 

Dans cet exemple, les variables a et b n’ont tout simplement pas été déclarées (pour rappel cela revient à les typer en tant que Variant).

Nous enregistrons en début de procédure l’heure exacte dans une variable qui porte le nom de heureDebut grâce à l’instruction Timer qui retourne le nombre de secondes écoulées depuis minuit (cette variable est déclarée, seules les deux variables utilisées dans le calcul vont voir leur type évoluer).

En fin de procédure, nous inscrivons dans la feuille de calcul le temps nécessaire pour réaliser les 100 millions de calculs en réalisant une simple soustraction du Timer actuel auquel nous retirons celui du début (variable heureDebut).

Note : suivant que vous soyez sous PC ou Macintosh, le résultat retourné par l’instruction Timer sera différent. Les tests de cet article sont effectués sous Windows 10

Enfin, nous allons dupliquer ce test, en déclarant cette fois-ci les variables en fonction des différents types possibles :

 …
Sub testTypeDouble()
    Dim heureDebut As Single, duree As Single
    Dim i As Long
    Dim a As Double, b As Double
    
    ' Enregistrement de l'heure de début
    heureDebut = Timer
    
    For i = 1 To 100000000
        a = 1
        b = a + 1
        a = a + b
        b = a * b
    Next
    
    ' Inscription de l'heure de fin
    duree = Timer - heureDebut
    Sheets("05.1-Les variables").[b8].Value =
 duree
End Sub 
…

   3.5. Tests de performance en fonction du type de variable

Voici une synthèse des résultats obtenus, dans laquelle nous retrouvons les délais requis pour réaliser 100 millions de fois la série de calculs que nous venons de voir :

Sur ces résultats, nous pouvons tirer un certain nombre de conclusions :

• Sans grande surprise, ne pas définir le type d’une variable (et donc laisser à Excel le soin de lui appliquer le type Variant) sera ce qui demande le plus de temps pour traiter l’information,
• Typer une variable en Double permet d’économiser à peu près 5% du temps, à vous de voir si le jeu en vaut la chandelle,
• En revanche, le type Long qui permet de stocker de grands nombres entiers permet d’économiser de nombreuses secondes ! Il peut donc être malin d’organiser les applications pour ne travailler qu’avec des nombres entiers (quitte à effectuer une division en toute fin de procédure si cela s’avère utile !)
• Beaucoup plus surprenant en revanche, le type Byte est beaucoup plus lent que le type Long ! À vous de savoir trouver le bon équilibre entre occupation de mémoire et vitesse d’exécution…

Enfin, il est évident que les résultats obtenus par ce test vont grandement variés d’un ordinateur à l’autre, en fonction de la configuration, des applications tournant en tâche de fond,…

Je serai d’ailleurs vraiment intéressé pour connaître vos résultats, alors n’hésitez pas à télécharger le support, pour partager vos propres résultats dans les commentaires.

   3.6. Alors on déclare ??

Bien souvent, à ce type de question, une réponse s’impose : ça dépend !

En effet, l’intérêt de déclarer ou non vos variables va surtout dépendre de votre projet.

Si les résultats du test permettent de diviser par 2,5 le temps nécessaire entre une procédure dans laquelle une variable est déclarée en tant qu’entier de type Long et une autre dans laquelle elle ne l’est tout simplement, n’oublions pas que pour encapsulons dans une boucle qui se répète 100 millions de fois !!

Pour le fun, voici une simulation dans laquelle la boucle n’est répétée « que » un million de fois :

Alors certes le rapport est toujours le même, par contre, il est absolument impossible de percevoir la différence entre un traitement qui va durée 0,07 secondes et un autre de 0,02 secondes !

En revanche, sachez que déclarer systématiquement vos variables peut amener d’autres avantages non négligeables, qui ne sont pas mesurés dans ce benchmark :

• Cela permet de gagner du temps, en utilisant le menu déroulant d’aide à la complétion des noms de variables (voir l’astuce que nous avions vue dans le chapitre principal consacré aux variables de cette formation VBA) :

• De plus, déclarer une variable en utilisant une majuscule permet de contrôler la bonne écriture de celle-ci, afin de se retrouver confronté à une erreur d’exécution (plantage de l’application qui ne retrouve pas la variable) En effet, lorsqu’Excel identifie une variable avec une majuscule, celui-ci l’ajoute automatiquement dans le nom de variable !

4. Comment nommer une variable ?

Au fur et à mesure que l’on avance dans le développement d’une application, le nombre de variables utilisé ne va faire que d’augmenter, si bien qu’il est important d’utiliser une méthodologie claire et facilement compréhensible dans la dénomination des variables.

Chaque développeur possède ces propres habitudes dans le choix des noms de variables, et le plus important est d’utiliser la méthode qui vous convient le mieux.

Je vais ici vous décrire ma propre méthode de dénomination des variables, libre à vous de l’utiliser où non.

Cette méthode est directement héritée de mes vieilles habitudes de développement en Objective C, qui était un langage de développement mise en place par Apple pour développer des applications sur ces machines :

• le nom d’une variable permet de la définir de manière précise, quitte à avoir des noms d’une certaines longueur (mais nous verrons juste après que cela ne pose aucun soucis !),
• il est saisi en minuscule, à l’exception de la première lettre de chaque mot qui est en majuscule (hormis la toute première lettre),
• au possible utiliser au moins une majuscule, et laisser le soin à Excel de l’insérer lorsqu’il a identifié la variable ce qui permet d’avoir un repère visuel de la bonne saisie du noms,
• certaines variables récurrentes dans tous les projet échappent à ces règles (« c » pour une cellule, « p » pour une plage, « i » pour un compteur, « tmp » pour une variable à la durée de vie très courte, « ws » pour une feuille de calcul…)

J’ajouterai également que s’il n’est pas indispensable d’utiliser des noms anglais ou français, l’important est de maintenir une cohérence au sein d’un même projet.

Pour séparer les mots dans les noms de variables, il est courant également d’utiliser le tiret (le « tiret bas », le signe moins étant interdit, comme nous le verrons juste après) : ma_variable, mon_autre_variable,…

Bref, vous l’avez bien compris à chacun ces propres règles !

En revanche il existe un certain nombre de règles qui s’impose par le langage VBA :

• Il est impossible d’utiliser des points et des espaces,
• Il est impossible d’utiliser les opérateurs mathématiques : */-+^
• Il est impossible d’utiliser les caractères réservés : &, $, @, #, et %
• Le premier caractère est forcément une lettre (minuscule ou majuscule),
• La limitation est de 255 caractères
• Il est impossible d’utiliser des mots réservés dans le cadre du langage VBA (Sub, For, Next, Function, Date, Time,…). Ces mots réservés sont nombreux, et le fait de coder en français peut aider à limiter le risque d’utiliser un terme interdit. Une autre solution est d’utiliser systématiquement un suffixe dans les noms de variables : myDate, myFunction,…

Dernière petite astuce forte utile lorsque l’on utilise des noms de variables longs :

• Commencez par saisir les premières lettre du nom de la variable,

• Puis utilisez le raccourci clavier [Ctrl]+[Espace] afin d’insérer instantanément la variable :

• Si plusieurs noms commencent de la même manière, une boîte de dialogue apparaît pour sélectionner directement la variable à l’aide du clavier :

5. Comprendre la portée des variables

   5.1. À quoi correspond la portée d’une variable

La portée d’une variable correspond à l’espace virtuel dans lequel celle-ci peut être utilisée.

Le plus souvent, et c’est notamment le cas de tous les exemples étudiés depuis le début de cette formation, nous déclarons une variable dans un module, afin que celle-ci soit utilisée par une ou plusieurs instructions insérées au sein de ce même module.

 Sub testDePortee()
    Dim maVariable As String
    maVariable = "Coucou"
    MsgBox maVariable
End Sub 

Ici nous déclarons simplement une nouvelle variable de type String en début de procédure, puis nous lui donnons une valeur et enfin, nous affichons un message avec ce texte :

En réalité, et sans nous en rendre compte, nous spécifions à VBA de déclarer une variable en spécifiant de limiter la portée à la procédure en cours.

Il existe trois types de portées :

• La portée limitée à la procédure,
• La portée limitée au module
• La portée illimitée

Attention, la portée de la variable est déterminée à la création de celle-ci, il ne sera évidemment plus possible de la modifié par la suite

   5.2. La portée limitée à la procédure

Dans l’exemple que nous venons de voir en préambule, nous spécifions que nous souhaitons créer une variable afin de l’utiliser uniquement au sein de la procédure en cours.

Lorsque la procédure arrivera à son terme, celle-ci sera détruite, ce qui implique :

• Qu’il ne sera pas possible de l’utiliser dans d’autres procédures,
• Que la mémoire dédiée pour cette variable va être libérée

Ainsi, si nous tentons d’accéder à cette variable en dehors des bornes de la procédure, cela entrainera obligatoirement une erreur :

 Sub testDePortee()
    Dim maVariable As String
    maVariable = "Coucou"
    MsgBox maVariable
    testDansUneAutreProcedure   ' Appel de la procédure
 testDansUneAutreProcedure()
End Sub
 
Sub testDansUneAutreProcedure()
    MsgBox maVariable
End Sub 

Dans cet exemple, l’exécution de la procédure testDansUneAutreProcedure() (directement depuis la première procédure testDePortee()) a pour effet d’afficher un message vide :

J’en profite pour faire un petit aparté : dans cet exemple, VBA se contente d’afficher un message d’erreur car la variable maVariable est inconnue de cette nouvelle procédure. Comme nous l’avons déjà abordé dans les chapitres précédents, lorsque nous demandons à VBA de travailler sur une nouvelle variable, celui-ci va en réalité déclarer de manière transparente cette variable à notre place. Pratique !? Oui et non ! C’est en effet pratique car cela permet de gagner quelques secondes lors de la rédaction de la procédure. En revanche cela peut être une source de bugs lorsque le développeur ne se rend pas compte que la variable qu’il souhaite manipuler n’existe pas dans la mémoire de la machine.

En effet, ici s’agissant d’un exemple volontairement simpliste, nous ne pouvons ignorer ce que nous faisons.

Mais maintenant imaginons que nous en soyons à plusieurs dizaines de lignes de code dans la procédure, et qu’au lieu de taper « maVariable », nous utilisions par erreur « maVarable »… À ce moment là Excel ne va pas nous alerter, mais au contraire il va créer une toute nouvelle variable pour nous, rendant par cette occasion caduque toutes les lignes située en amont…

Dans ce cas, il peut être intéressant d’exiger d’Excel de ne pas créer ces variables, et lorsque celui-ci se trouve confronté à une variable inconnue, il se contentera de nous présenter un message d’erreur.

Pour cela il suffit d’ajouter la ligne suivante au tout début du code (vraiment au tout début, directement sur la première ligne) :

 Option Explicit 

Et donc, si nous revenons sur notre exemple et que nous choisissons de relancer la procédure testDansUneAutreProcedure(), nous aurons alors l’erreur suivante « Erreur de compilation : Variable non définie » :

Cette erreur est très explicite et permettra d’éviter de nombreux bugs dans nos macros.

Nous reviendrons dans le détail sur la commande Option Explicit, mais commencer dès maintenant à prendre l’habitude de l’utiliser peut-être une très bonne idée !

À la fin de la procédure, la variable s’éteint et perd sa valeur. La période qui s’écoule entre la création de la variable et son extinction correspond à sa durée de vie.

   5.3. La portée étendue au module

Lorsque nous souhaitons utiliser une variable dans l’ensemble des procédures contenues dans un module, il est alors nécessaire d’étendre sa portée au niveau du module.

Pour cela, nous déclarons simplement la variable, non plus encapsulée dans une procédure, mais directement en haut du module (tout en haut si le module ne contient pas l’instruction Option Explicit, juste en dessous dans le cas contraire :

Option Explicit
Dim maVariable As String
 
Sub testDePortee()
    maVariable = "Coucou"
    MsgBox maVariable
    testDansUneAutreProcedure   ' Appel de la procédure
End Sub
 
Sub testDansUneAutreProcedure()
    MsgBox maVariable
End Sub 

Ici, nous avons juste déplacé la création de la variable, mais si nous exécutons la procédure testDePortee(), nous allons constater que deux messages successifs vont être affichés avec le même message :

Notez que pour déclarer une variable dont la portée doit être étendue au niveau du module, nous pourrions également utiliser le mot-clé Private, l’effet sera alors identique :

 Private maVariable As String 

Une variable dont la portée est étendue n’a pas de durée de vie, et ne s’éteint pas de manière automatique, contrairement à une variable dont la portée est limitée à une procédure. Une variable à la durée de vie illimité sera tout de même réinitialisée lorsque :

• L’exécution de la macro est interrompue suite à une erreur d’exécution non interceptée,
• Visual Basic est interrompue,
• À la fermeture de Microsoft Excel,
• Lorsque le code du module est modifié

Un dernier point important concernant ce type de portée étendue : il n’est pas possible d’affecter une valeur à une variable en dehors d’une procédure :

   5.4. La portée étendue à tout le projet

Enfin, il est également possible d’étendre la portée d’une variable à l’ensemble du projet.

Pour cela, nous déclarerons la variable en utilisant le mot-clé Public :

 Public maVariable As String 

Une variable ainsi déclarée pourra être utilisée dans l’ensemble du projet, quel que soit le module.

Comme nous venons de le voir pour une variable dont la portée est étendue au module, ici aussi, les variables ne voient pas leur vie s’éteindre automatiquement, et peuvent être utilisées n’importe quand.

En revanche, cela signifie que la mémoire allouée n’est jamais libérée, ces types de déclarations doivent donc rester exceptionnels.

L’autre inconvénient d’étendre ainsi la portée d’une variable est qu’il faut être très vigilent de ne pas créer plusieurs variables avec des noms identiques sous peine de provoquer un conflit !

   5.5. Les variables hybrides : Static

Il existe encore une autre possibilité quant à la déclaration d’une variable, dont la portée est limitée à la procédure, mais dont la durée de vie n’a pas de fin, et sera conservé entre les différents appels de la procédure il s’agit des variables Static :

 Sub maVariableStatic()
    Static compter As Long
    compter = compter + 1
    
    If compter < 5 Then
        MsgBox compter
        maVariableStatic
    End If
End Sub 

Ici, nous créons une variable Static (par défaut celle-ci prend pour valeur 0), puis nous incrémentons la valeur de celle-ci.

Si la valeur est inférieure à 5, alors nous affichons cette valeur, puis nous appelons à nouveau cette procédure.

Cette boucle va donc se répéter jusqu’à ce que la variable « compter » ait pour valeur 4 :

6. Manipuler les principaux types de variables 

Comme nous l’avons déjà vu dans les chapitres précédents, une variable permet de stocker, puis de manipuler des informations afin de les utiliser dans le programme VBA.

La manipulation d’une variable s’effectue en trois étapes :

• 1^ère étape : Déclaration de la variable : cette déclaration permet de définir le nom de la variable, lequel permet de l’appeler par la suite. Elle permet également de définir la portée de celle-ci et sa durée de vie. Cette déclaration peut être implicite, c’est-à-dire qu’elle peut ne pas être saisie et ajoutée indirectement par Excel. Si ces notions ne sont pas claires, je vous invite à consulter les points abordés juste au-dessus.

    
    …
    Dim heureDebut As Single, duree As Single
    Dim i As Long
    Dim a As Double, b As Double
    …
 

• 2^nd étape : Affectation d’une valeur à une variable afin de stocker une valeur à une variable. Cette affectation s’effectue en utilisant le symbole égal

    monNombre = 5
    monTexte = "Hello VBA !" 

• 3^ème étape : Utilisation de la variable, soit directement dans le code VBA, soit en tant qu’argument dans une procédure tierce

    ...
    If monNombre < 10 Then      ' Effectuer un test avec l'instruction If
        MsgBox monTexte         ' Afficher une notification avec MsgBox
    End If
    monNombre = monNombre + 1   ' Modifier la valeur d'une variable avec le symbole égal
    ... 

La première étape est identique pour tous les types de variables, et nous avons déjà abordé la déclaration des variables dans ce chapitre de la formation VBA.

Evidemment, le type de variable défini lors de la première étape doit être défini avec minutie, sous peine de générer des erreurs lors des deux étapes suivantes.

   6.1. Manipuler des valeurs numériques

Les types de variables les plus simples à manipuler sont les valeurs numériques, peu importe le type exact défini.

Il suffit en effet de bien déclarer cette variable (nombre entier ? nombre en virgule flottante ? …), puis de bien utiliser ce type (ne pas utiliser de virgule sur un type Integer par exemple).

    Dim monNombreEntier As Integer
    monNombreEntier = 10
    
    Dim monNombredecimal As Double
    monNombredecimal = 10.5 

Mais surtout pas :

    Dim monNombreEntier As Integer
    monNombreEntier = 10.5 

Ce qui n’engendre pas forcément d’erreur d’exécution, mais causera des anomalies dans le code.

En effet, un simple msgbox affiche le message suivant :

Il faut également respecter les contraintes liées à chaque type de variables, comme nous l’avons déjà vu dans un sous-chapitre précédent, sous peine cette fois-ci d’avoir une erreur d’exécution :

    Dim monNombreEntier As Integer
    monNombreEntier = 100000 

Va afficher le message d’erreur « Dépassement de capacité » que voici :

Attention, le langage VBA utilise le standard numérique américain. Nous utiliserons donc le séparateur de décimal correspondant, c’est-à-dire le point en lieu et place de la virgule.

   6.2. Manipuler des chaînes de caractères

Une chaîne de caractères est une suite de caractères (numériques, alphabétiques, symboles,…) saisis les uns à la suite des autres.

    Dim monTexte As String
    monTexte = "Bienvenue sur Excelformation"
 

Comme vous pouvez le constater dans cet exemple, une chaîne de caractère doit obligatoirement être saisie entre guillemet, afin qu’Excel puisse comprendre qu’il ne s’agit pas d’une variable ou d’une instruction qu’il devrait utiliser dans le déroulement du code.

En effet le code suivant va provoquer une erreur intercéptée directement par l’éditeur lors de la saisie :

    Dim monTexte As String
    monTexte = Bienvenue sur Excelformation 

Par défaut, une variable de type String peut contenir un très grand nombre de caractères (près de deux milliards).

En revanche, lorsque l’on connaît exactement le nombre de caractères à afficher, il est possible d’utiliser un type String dont la valeur est définie directement au moment de la déclaration de la variable :

Cela permet de gagner un peu d’occupation mémoire (dans ce cas, la variable occupe 1ko par caractère), mais tous les caractères dépassant cette taille fixe seront supprimés :

 Sub testTexte()
    Dim monTexte As String * 20
    monTexte = "Bienvenue sur Excelformation"
    MsgBox monTexte
End Sub 

Ici, la variable occupe seulement 20ko de mémoire, mais ne peut stocker que 20 caractères :

   6.3. Manipuler des dates

Si comme nous venons juste de le voir, les chaînes de caractères sont encadrées par des apostrophes, les dates sont quant à elles encadrées par des dièses :

 Sub testDate()
    Dim maDate As Date
    maDate = #1/1/2019#
    MsgBox maDate
End Sub 

Il en est évidemment de même pour l’utilisation des heures :

    Dim monHeure As Date
    monHeure = #8:00:00 PM#
    MsgBox monHeure 

   6.4. Manipuler les booléens

Pour manipuler une variable de type booléen, il suffit simplement de lui affecter pour valeur TRUE pour vrai, ou FALSE pour faux.

    Dim monBooleen As Boolean
    monBooleen = True
    MsgBox monBooleen 

Attention, s’agissant d’une valeur booléenne et non d’une chaîne de caractère, il ne faut surtout pas utiliser de guillemets

Vous noterez également que si dans le code, nous affectons une valeur en anglais au booleen, celui-ci sera bien affiché en français par Excel :

7. Les constantes

Pour finir ce chapitre, voyons un type de variable bien spécifique, puisque celui permet d’utiliser des variables… non variable !

Une constante permet en effet de stocker une donnée, qui n’a pas vocation à être modifiée !

À quoi peut bien servir une constante dans ce cas-là ? L’usage le plus courant que nous pouvons en avoir c’est de définir des réglages au niveau de l’application, que nous utiliserons ensuite à plusieurs reprises. De cette manière, il suffira de modifier la valeur à un seul endroit pour que l’effet se fasse partout où la constante est appelée.

On peut par exemple enregistrer le numéro de la version de l’application dans une constante : en effet, ce n’est pas l’application elle-même qui défini ce numéro, mais le développeur qui va le modifier manuellement :

 Const maVersion = "v.1.5" 

Une constante se déclare simplement avec l’instruction Const.

Évidemment, comme son nom l’indique, une constante ne doit pas être modifiée, sous peine de générer une erreur d’execution.

Le code suivant n’est donc pas bon

 Sub creerErreur()
     Const couleurFond = "bleu"
     couleurFond = "rouge"
End Sub 

De nombreuses constantes sont déjà définis par défaut dans VBA. Par exemple xlCalculationManual est une constante qui a pour valeur réelle -4135

Il est donc bien plus simple d’utiliser ces noms de constantes, plutôt que leur valeur, d’autant plus qu’Excel les conserve en mémoire :