Initiation au VBA Office

L'"Enregistreur de Macro" est un outil fourni avec Word pour vous permettre d'utiliser le VBA sans pour autant connaître le langage. Nous allons utiliser l'enregistreur pour ensuite visualiser le code qui aura été enregistré.

Pour activer l'enregistreur de macro, nous avons au moins deux possibilités. La première est de passer par l'onglet développeur et la seconde par la barre d'état de Word.
Il en existe une troisième par l'Onglet Affichage et dans le groupe Macro.

Si l'onglet developpeur n'est pas visible, pour l'afficher : Bouton Office -> Options Word -> Standard -> Afficher l'onglet développeur dans le Ruban.

Le résultat reste le même et ne dépend pas du choix fait.

Si vous travaillez sous Word 2003, vous avez accès aux macros par le menu Outils -> Macro et Enregistreur de Macro. La suite ne change pas.

Nous allons commencer par changer le nom donné par défaut "Macro1" par "MaPremiereMacro". Même si pour VBA ça n'a aucune importance, je vous conseille d'éviter les espaces et les accents dans les noms que vous allez donner à vos macros. Pour les espaces, Word vous enverra sur les roses.

Si vous voulez avoir plus de clarté dans les noms, utilisez des majuscule en début de mot vos nom seront plus lisibles, que ce soit pour une variable, une macro ou tout autre nom. MaPremiereMacro est plus lisible que mapremieremacro.

Cette boîte de dialogue vous propose de mettre la macro dans le normal.dotm, ça ne pose pas de problème, mais pour le début, nous allons utiliser le document vierge que nous recevons lors de l'ouverture de Word. Si un autre document est ouvert, vous aurez un choix supplémentaire.

Dès que vous avez cliqué sur OK, l'enregistreur commence sont travail, toutes les actions que vous allez effectuer seront enregistrées.
Vous allez écrire un texte dans votre document.
Ma première macro.
Lorsque vous avez terminé, n'oubliez pas d'arrêter l'enregistrement.

Supprimez la ligne que vous venez d'écrire dans votre document et cliquez sur le bouton Macro.

Vous ouvrez alors une boîte de dialogue contenant le nom de votre Macro.

Exécutez la macro.
Le texte que vous venez de supprimer est à nouveau présent sur le document, vous pouvez répéter cette manipulation autant de fois que vous le souhaitez.

Comme pour Word, Excel est fourni avec un enregistreur de macro. Pour activer l'enregistreur, vous avez trois possibilités.
Via l'onglet Développeur et le bouton Enregistrer une macro, via la barre d'état et le bouton des macros.

Et finalement, via l'onglet Affichage et le déroulant relatif aux Macros.

Si l'onglet développeur n'est pas visible, pour l'afficher, Bouton Office => Standard => Afficher le bouton développeur dans le ruban.

Si vous travaillez aec Excel 2003, vous trouverez l'enregistreur de macro dans Outils => Macro.

Vous ouvrez une boîte de dialogue vous permettant de renseigner quelques informations.
La première est le nom de la macro, vous allez saisir "MaPremiereMacro" dans ce nom, vous ne pouvez pas avoir d'espace, les accents sont autorisé, mais par facilité, je vous coinseille vivement de ne pas les utiliser.

Si vous voulez avoir plus de clarté dans les noms, utilisez des majuscule en début de mot vos nom seront plus lisibles, que ce soit pour une variable, une macro ou tout autre nom. MaPremiereMacro est plus lisible que mapremieremacro.

Cette boîte de dialogue vous propose de mettre votre macro dans le classeur actif, dans le Classeur de macros personnelles ou dans un nouveau classeur. Si vous mettez votre macro dans le Classeur de macros personnelles, elle sera disponible pour tous vos classeurs. Nous allons la mettre dans le classeur actif "Ce classeur".

Dès que vous avez cliqué sur Ok, votre macro est en cours d'enregistrement, toutes les actions que vous allez faire seront enregistrées. Pour cette première macro, je vous invite à écrire dans la première cellule (A1) de votre feuille : "Ma première macro". Quittez la cellule et arrêtez l'enregistrement de votre macro.

Supprimez le texte que vous venez d'écrire dans la cellule. Lancez la macro que vous venez de faire :

Choisissez votre macro :

Lancez l'exécution et votre texte va réapparaître dans la cellule. Vous pouvez utiliser cette macro autant de fois que vous le souhaitez.

L'accès à l'enregistreur de macro n'est pas direct pour PowerPoint 2007. Cependant, il existe une compatibilité de commandes entre 2003 et 2007 ce qui nous permet de lancer en mode aveugle l'enregistreur de macro avec la combinaison de touches Alt O M E.

Malheureusement, ces deux logiciels ne possèdent pas d'enregistreur de Macro. Ces étapes ne pourrons pas être utilisées.

Ces trois lettres sont les abréviations Visual Basic Editor. Cette interface graphique vous permet de visualiser, éditer ou insérer du code. Pour y accéder, vous avez le choix, personnellement, j'utilise la combinaison de touches Alt + F11, ou utiliser le bouton du Ruban.

Lorsque vous ouvrez le VBE, vous obtenez ceci :

Pour l'instant, nous allons nous attarder sur deux parties de notre VBE.

La première partie (1) donne une arborescence avec le contenu de votre projet qui se compose de :
Microsoft Word Objets composé de ThisDocument
Module contenant un module NewMacros
Référence intégrant Référence à Normal.

Nous allons double cliquer sur le module NewMacros, c'est dans ce module que se trouve la macro que nous venons d'enregistrer. Lorsque nous double cliquons sur ce module, nous affichons son contenu dans la fenêtre d'édition.

La seconde partie (2) est la zone d'édition qui contient notre code.

Sub MaPremiereMacro()
'
' MaPremiereMacro Macro
'
'
    Selection.TypeText Text:="Ma première macro"
End Sub

Si nous détaillons ce code, nous avons quatre lignes.
La première et la dernière ligne vont de pair.

Sub MaPremiereMacro()
	....
	....
End Sub

La première constitue le début de notre procédure, elle contient le nom de notre macro.
La dernière est la fin de notre procédure, le code est contenu entre ces deux balises.

'
' MaPremiereMacro Macro
'
'

Cette ligne constitue un commentaire. Les commentaires en VBA commencent toujours par une apostrophe ('). Les lignes qui suivent ce caractère sont ignorées lors de l'exécution du code.

Selection.TypeText Text:="Ma première macro"

Nous terminons par notre ligne de code. Dans cet exemple, elle est très simple. Nous utilisons un Objet et sa méthode et l'argument utilisé pour la méthode.

• Objet : Selection
• Méthode : TypeText
• Argument : Text:="Ma première macro"

Vous pouvez réutiliser ce code un très grand nombre de fois.
Vous venez de faire votre première Macro.

Cette partie est similaire à ce que nous venons de voir pour Word. Au lieu d'avoir des documents, nous avons des Classeurs contenant des feuilles. La macro que nous venons d'enregistrer se trouve dans le Module1 qui a été créé par Excel pour recevoir votre macro.

Sub MaPremiereMacro()
'
' MaPremiereMacro Macro
'

'
    ActiveCell.FormulaR1C1 = "Ma première macro"
    Range("A2").Select
    
End Sub

Dans notre code, nous avons cinq lignes.

Sub MaPremiereMacro()
...
...
End Sub

La première ligne constitue le début de notre procédure. La dernière, la fin de notre procédure, le code est toujours contenu entre ces deux lignes.

'
' MaPremiereMacro Macro
'

Cette ligne constitue un commentaire, les commentaires en VBA commencent toujours par une ', les lignes qui suivent seront ignorées lors de l'exécution du code.

    ActiveCell.FormulaR1C1 = "Ma première macro"
    Range("A2").Select

Nous terminons par nos deux lignes de code, la première va insérer le texte "Ma première macro" dans la cellule active et la seconde va activer la cellule A2.

Dim est l'attribut le plus fréquent pour la déclaration des variables. Lorsque Dim est utilisé à l'intérieur d'une procédure, la variable est disponible pour cette procédure et n'aura de temps de vie que pendant le déroulement de la procédure

Sub MaPremiereMacroAvecVariable()
'Nous allons déclarer une variable de type string
'Elle va recevoir du texte.
Dim strMaVar As String
'Affectation d'un valeur
strMaVar = InputBox("Entrez un texte !")
	MsgBox strMaVar
End Sub

Dans les lignes de code qui précèdent, c'est le cas, la variable n'existe plus lorsque que le code est terminé.
Nous allons faire un petit test en ajoutant sous ces lignes de code une seconde procédure mais sans déclarer la variable.

Sub TestDeVie()
MsgBox strMaVar
End Sub

Lancez l'exécution des deux procédures l'une après l'autre.
Lors du lancement de la seconde, vous recevrez un petit message : "Erreur de compilation : Variable non définie".
Notre variable n'existe plus.

Autre petite expérience, déplacez la déclaration de la variable hors de la procédure.

Option Explicit

'Nous allons déclarer une variable de type string
'Elle va recevoir du texte.
Dim strMaVar As String

Sub MaPremiereMacroAvecVariable()

'Affectation d'un valeur
strMaVar = InputBox("Entrez un texte !")
    MsgBox strMaVar
End Sub

Sub TestDeVie()
MsgBox strMaVar
End Sub

Lancez l'exécution des deux procédures l'une après l'autre.
Vous ne recevez plus de message d'erreur, mais en plus la variable ne perd pas sa valeur.
Essayons cette fois d'ajouter un module à notre projet.
Insertion -> Module
Pour accéder au module, dans l'explorateur de projet, vous avez maintenant un répertoire supplémentaire "Modules", dans ce répertoire, vous avez votre nouveau module. Double cliquez sur ce module pour pouvoir éditer le code qu'il contient ou ajouter du code s'il n'en contient pas. Dans ce module, collez la dernière procédure et ajoutez "_1" au nom de la procédure.

Sub TestDeVie_1()
MsgBox strMaVar
End Sub

Exécutez à nouveau le code de la procédure "MaPremiereMacroAvecVariable".
Changez de module et exécutez la procédure "TestDeVie1". Vous recevez un message désagréable : "Erreur de compilation : Variable non définie".

Résumé

Lorsqu'une variable est déclarée avec le mot Dim dans une procédure, elle est utilisable dans cette procédure. Lorsqu'elle est déclarée avec le mot Dim dans un module, elle n'est utilisable que par les procédures de ce module.

Nous avons vu que lorsqu'une variable est déclarée dans une procédure avec l'attribut Dim, la valeur contenue est supprimée à la fin de la procédure.
Si vous ne voulez pas déclarer la variable hors de votre procédure, vous pouvez utiliser l'attribut "Static" et la valeur contenue dans la variable sera conservée entre deux exécutions.

Sub MaPremiereMacroAvecVariable()
'Nous allons déclarer une variable de type entier

Static intMaVar As Integer
intMaVar = intMaVar + 1
MsgBox "Ma variable vaut : " & intMaVar

End Sub

Vous pouvez déclarer une variable avec l'attribut Private. La déclaration avec Private ne se fait qu'au niveau module. Une variable déclarée avec Private n'est utilisable que par les procédures contenues dans le module.

Vous ne pouvez pas utiliser Private dans une procédure.

Private objDoc As Document

Sub NouveauDocument()
Set objDoc = Application.Documents.Add
End Sub

Vous pouvez déclarer une variable avec l'attribut Public. La déclaration d'une variable avec Public ne peut se faire qu'au niveau du module et est utilisable par toutes les procédures de votre projet.

Public objDoc As Document

Sub NouveauDocument()
Set objDoc = Application.Documents.Add
End Sub

Une Sub est une procédure qui ne renvoie pas de résultat. Elle commence toujours par Sub et se termine par End Sub. Comme pour les variables, une procédure a une portée qui dépend de la manière dont elle est déclarée.

8-A-1. Portée d'une Sub▲

Sub MaProcedure()
...
...
End Sub

Public Sub MaProcedure()
...
...
End Sub

Private Sub MaProcedure()
...
...
End Sub

Static Sub MaProcedure()
...
...
End Sub

Sub MaProcedure()
    MsgBox "Vient de ma procédure !"
End Sub

Sub AppelProcedure()
    MaProcedure
End Sub

Private Sub MaProcedure()
    MsgBox "Vient de ma procedure !"
End Sub

Sub AppelProcedure()
    MaProcedure
End Sub

Les Function sont similaires aux Sub avec une différence de taille, non pas sur le code contenu, mais sur le résultat renvoyé. Une Function renvoie un résultat alors qu'une Sub non.

Pour imager ce principe de résultat, nous allons utiliser une fonction VBA assez simple : Len(), cette fonction compte le nombre de caractères contenus dans une chaîne.

Function LongueurDuMot() As Integer
LongueurDuMot = Len("LongueurDuMot")
End Function

Si vous utilisez cette fonction, la valeur retournée de LongueurDuMot est un entier qui vaut 13. Nous avons donc une valeur de type entier attribuée à LongueurDuMot (LongueurDuMot() As Integer). Nous verrons un peu loin dans l'appel des procédures ce que signifie exactement renvoyer un résultat.

8-B-1. Portée d'une Function▲

8-B-2. Valeur renvoyée par une fonction▲

'**********************************************************
Public Type MyVar
    IntA As Integer
    IntB As Integer
End Type
'**********************************************************
Sub MaProc()
'Déclaration des variables
Dim MyData01 As MyVar
Dim MyData02 As MyVar
'Affectation des données
With MyData01
    .IntA = 10
    .IntB = 20
End With
MyData02 = monCalcul(MyData01)
Debug.Print MyData02.IntA, MyData02.IntB

End Sub
'**********************************************************
Public Function monCalcul(MyDt As MyVar) As MyVar

monCalcul.IntA = MyDt.IntA * 2
monCalcul.IntB = MyDt.IntB / 4

End Function

Nous avons vu dans la portée d'un Sub l'appel d'une autre routine.

Sub AppelProcedure()
    MaProcedure
End Sub

Certains programmeurs ont pour habitude de faire précéder l'appel d'une fonction ou d'une procédure par le mot Call. Ce mot est pour reprendre le terme utilisé par Microsoft facultatif. Dans l'exemple, que vous utilisiez Call ou non ne change rien.

Sub AppelProcedure()
    MaProcedure
End Sub

Est identique à

Sub AppelProcedure()
    Call MaProcedure
End Sub

Lorsque vous faites appel à une procédure, vous pouvez lui passer des paramètres qui seront alors utilisés.

Reprenons notre exemple de départ.

Sub MaProcedure()
    MsgBox "Vient de ma procedure !"
End Sub


Sub AppelProcedure()
    MaProcedure
End Sub

Nous pourrions passer le texte de notre boîte de message à notre procédure.
Essayons :

Sub AppelProcedure()
    MaProcedure "De la première procédure !"
End Sub

Sub MaProcedure(strMessage As String)
    MsgBox strMessage
End Sub

Le texte affiché dans la boîte de dialogue correspond au texte contenu dans la première procédure.

Nous passons donc le texte "De la première procédure !" en argument pour l'appel de la seconde procédure et c'est ce texte qui est utilisé pour l'affichage de notre boîte de dialogue.

Nous allons faire un exercice avec une Function, lui passer des valeurs en arguments et récupérer le résultat. Nous allons utiliser une simple addition de nombres.

Sub AppelFonction()
'Déclaration des variables
Dim intA As Integer
Dim intB As Integer
Dim strQuestion As String
'Affectation des variables
strQuestion = "Entrez un nombre entier."
intA = InputBox( strQuestion)
intB = InputBox( strQuestion)

MsgBox Addition(intA, IntB)

End Sub

Function Addition( intX As Integer, intY As Integer) As Integer
    Addition = intX + intY
End Function

Le principe est le suivant, lors de l'appel, on passe deux nombres en argument et la fonction retourne un résultat.

Si tout s'est déroulé correctement, vous avez reçu une boîte de message contenant la somme des deux nombres préalablements introduits.

8-C-1. ByVal ou ByRef▲

'Déclaration d'une variable de type entier
Public intA As Integer

Sub TestOli()
'Affectation d'une valeur à la variable
intA = 10
'Deux MsgBox de Contrôle
MsgBox TestModInt(intA)
MsgBox "Valeur de intA : " & intA
End Sub

Function TestModInt(ByVal intB As Integer) As Integer
intB = intB / 2
TestModInt = 1
End Function

'Déclaration d'une variable de type entier
Public intA As Integer

Sub TestOli()
'Affectation d'une valeur à la variable
intA = 10
'Deux MsgBox de Contrôle
MsgBox TestModInt(intA)
MsgBox "Valeur de intA : " & intA
End Sub

Function TestModInt(ByRef intB As Integer) As Integer
intB = intB / 2
TestModInt = 1
End Function

8-C-2. Optional▲

Public Fonction MaSuperFonction( intA As Integer, intB As Integer, Optional IntC As Integer, Optional intD As Integer) As String
....
End Function

Public Fonction MaSuperFonction( intA As Integer, Optional  intB As Integer, IntC As Integer, Optional intD As Integer) As String
....
End Function

En VBA, les commentaires sont toujours précédés d'une apostrophe ('). Dès que l'éditeur rencontre ce caractère, il colore en Vert (couleur par défaut) le texte qui suit. Lors de la compilation de votre code, ce texte est ignoré. Mais ô combien utile lorsque vous devez vous relire ou passer votre travail à quelqu'un d'autre.

'Déclaration d'une variable de type entier
Public intA As Integer

Les commentaires peuvent se trouver n'importe où, mais placez les à des endroits judicieux.

Malheureusement, la taille des écrans est souvent beaucoup plus petite que ce dont nous avons besoin, surtout en largeur. Il est possible en VBA d'écrire une ligne de code sur plusieurs lignes consécutives. Pour y parvenir, il suffit d'utiliser un espace suivi d'un caractère de soulignement et la ligne de code se poursuit sur la ligne suivante.

Public Fonction MaSuperFonction( intA As Integer, intB As Integer, Optional IntC As Integer, Optional intD As Integer) As String
....
End Function

Peut aussi s'écrire :

Public Fonction MaSuperFonction( intA As Integer, intB As Integer, _
					Optional IntC As Integer, Optional intD As Integer) As String
....
End Function

En plus des commentaires et de l'écriture des lignes de code sur plusieurs lignes, il existe une règle simple pour faciliter la compréhension et la lecture mais pas obligatoire, l'indentation du code.

Sub TestOli()
'Affectation d'une valeur à la variable
intA = 10
'Deux MsgBox de Contrôle
MsgBox TestModInt(intA)
MsgBox "Valeur de intA : " & intA
End Sub

Dans le code qui précède, le nombre de lignes est très faible et l'indentation n'est pas nécessaire, mais pour servir d'exemple, nous allons indenter les lignes de code.

Sub TestOli()
'Affectation d'une valeur à la variable
	intA = 10
'Deux MsgBox de Contrôle
	MsgBox TestModInt(intA)
	MsgBox "Valeur de intA : " & intA
End Sub

C'est un peu plus lisible. Prenez l'habitude de systématiquement indenter votre code.

Nous avons déjà utilisé cet opérateur dans les articles précédents.

Il existe en VBA des opérateurs arithmétiques pour manipuler les données numériques. Le tableau ci-dessous reprend la liste des opérateurs disponibles.

En plus des opérations arithmétiques, vous serez amenés à faire des comparaisons de données, le tableau ci-dessous vous donne les principaux opérateurs de comparaison.

Il existe deux opérateurs de comparaison supplémentaires qui sont Is et Like. Le premier est applicable aux objets et le second pour les comparaisons de chaînes de caractères avec ou sans WildCard.

Il existe deux opérateurs de concaténation l'esperluette "&" et le plus "+".
Il est préférable d'utiliser le &, si vous concaténez avec l'opérateur + deux valeurs où l'une d'entre elles est Null, le résultat sera Null, alors que si vous utiliser le &, vous obtiendrez le résultat de la valeur non Null. Si vous avez d'autres types de données que des strings, l'opérateur + va faire une simple addition.

Finalement, nous allons traiter les principaux opérateurs logiques. Nous allons les découvrir un par un et sous forme de tableau pour plus de facilité. Nous ne traiterons que les résultats obtenus avec des booléens.

La structure est toujours la même, Expression Opérateur Expression => Résultat.

10-E-1. Or▲

10-E-2. And▲

10-E-3. XOR▲

10-E-4. NOT▲

C'est la plus simple des structures décisionnelles. On pose une condition, si elle est remplie, on effectue une action.

If Condition Then Instruction

En code utilisable, nous obtenons ceci :

Sub Vetements()
Dim dblTemperature As Double
dblTemperature = InputBox("Quelle température fait-il ?")
If dblTemperature < 5 Then MsgBox "Prends une écharpe, il fait froid !"
End Sub

Dans cette structure, pour les températures supérieures à 5°, il ne se produit rien.

La structure If Then peut être complétée par des clauses supplémentaires et cette structure sera écrite sur plusieurs lignes.

If Condition Then
	Instruction si Vrai
Else
	Instruction si Faux
End If

En pratique on obtient ceci :

Sub Vetements()
' Déclaration des variables
Dim dblTemperature As Double
dblTemperature = InputBox("Quelle température fait-il ?")
'Structure décisionnelle
	If dblTemperature < 5 Then 
		MsgBox "Prends une écharpe, il fait froid !"
	Else
		MsgBox "Pas besoin d'écharpe aujourd'hui !"
	End If
End Sub

Dans cette structure, nous avons un résultat supplémentaire, si la température est supérieure à 5°, nous n'avons pas besoin d'écharpe.

Cette structure est extensible, on peut lui ajouter d'autres clauses.

Sub Vetements()
' Déclaration des variables
Dim dblTemperature As Double
dblTemperature = InputBox("Quelle température fait-il ?")
'Structure décisionnelle
	If dblTemperature < 5 Then 
		MsgBox "Prends une écharpe, il fait froid !"
	ElseIf dblTemperature > 20 Then
		MsgBox "Un T-shirt sera le bon choix !"
	Else
		MsgBox "Pas besoin d'écharpe aujourd'hui !"
	End If
End Sub

Ce code possède trois sorties, si la température est inférieure à 5°, si la température est comprise entre 5° et 20° et finalement si la température est supérieure à 20°. Ajouter une ou plusieurs clauses supplémentaires rendrait le code trop complexe.

La structure Select Case est très intuitive. Elle exécute un des blocs d'instructions indiqués, selon la valeur d'une expression. Un peu comme lorsque l'on cherche un bureau dans un couloir, on regarde ce qui est écrit sur la porte et si c'est la bonne porte nous entrons.
Nous allons reprendre le dernier exemple utilisé.

Sub Vetements()
' Déclaration des variables
Dim dblTemperature As Double
dblTemperature = InputBox("Quelle température fait-il ?")
'Structure décisionnelle
	Select Case dblTemperature 'Expression qui sera testée
		Case Is < 5 
			MsgBox "Prends une écharpe, il fait froid !"
		Case 5 To 20
			MsgBox "Pas besoin d'écharpe aujourd'hui !"
		Case Is > 20
			MsgBox "Un T-shirt sera le bon choix !"
		End Select
End Sub

Tout au long de la structure de test, on va comparer la valeur contenue dans notre expression aux valeurs de test. Si nous désirons ajouter des conditions supplémentaires, c'est assez simple.

Tant que la condition qui suit While est vraie, la boucle est exécutée, si la condition devient fausse, les instructions se trouvant dans la boucle ne sont plus exécutées et le code continue son déroulement.

Sub TestBoucle()
Dim intI As Integer
'initialisation de la variable
intI = 0
Do While intI < 10
    intI = intI + 1
    MsgBox intI
Loop
End Sub

La syntaxe de l'expression testée est très importante. Dans l'exemple donné, la boucle va s'arrêter sur intI = 10, si vous utilisez <= dans votre expression, la valeur de intI sera de 11, puisque la boucle vérifie la condition en début de cycle, et lorsque intI sera égal à 10, la boucle sera une dernière fois exécutée.

On pourrait traduire cette boucle par : Tant que

Cette boucle est identique à la précédente, seule la manière de l'écrire change.

Sub TestBoucle()
Dim intI As Integer
'initialisation de la variable
intI = 0
While intI < 10
    intI = intI + 1
    MsgBox intI
Wend
End Sub

Cette boucle est juste le contraire de la précédente, elle est exécutée tant que la condition qui suit Until est fausse, si cette condition devient vraie, les instructions de la boucle ne sont pas exécutées.

Sub TestBoucle()
Dim intI As Integer
'initialisation de la variable
intI = 0
Do Until intI > 10
    intI = intI + 1
    MsgBox intI
Loop
End Sub

Si vous essayez ce code, vous vous apercevrez que le résultat est sensiblement le même que pour la boucle précédente, seule la condition change.

On pourrait traduire cette boucle par : Jusqu'à ce que

À l'inverse des boucles précédentes où la condition est vérifiée à l'entrée de la boucle, dans les deux boucles suivantes, la condition est vérifiée à la sortie de la boucle.

Sub TestBoucle()
Dim intI As Integer
'initialisation de la variable
intI = 0
Do 
    intI = intI + 1
    MsgBox intI
Loop While intI < 10
End Sub

Tant que la condition est vraie, la boucle est effectuée.

Comme pour la boucle précédente, la condition est vérifiée à la sortie de la boucle, mais la boucle est effectuée tant que la condition de test n'est pas vérifiée.

Sub TestBoucle()
Dim intI As Integer
'initialisation de la variable
intI = 0
Do 
    intI = intI + 1
    MsgBox intI
Loop Until intI > 10
End Sub

Jusqu'à ce que la condition soit vraie, la boucle est effectuée.

Il est possible de sortir de la boucle avec une instruction Exit Do.
Cette instruction est valable pour toutes les boucles Do

If Condition Then Exit Do

Cette boucle est basée sur un "compteur" numérique. La valeur d'incrémentation de ce compteur est donnée par l'instruction Step. Si cette instruction est omise, la valeur de Step est 1. Cette valeur peut être négative, dans ce cas, nous obtenons une décrémentation.

Sub TestBoucle()
Dim intI As Integer
'initialisation de la variable
intI = 0
For intI = 0 To 10 Step 1
	MsgBox intI
Next intI
End Sub

Avec cette boucle, tous les nombres entiers entre 0 et 10 sont affichés. Tentons la même expérience avec un Step de 2.

Sub TestBoucle()
Dim intI As Integer
'initialisation de la variable
intI = 0
For intI = 0 To 10 Step 2
	MsgBox intI
Next intI
End Sub

Nous n'obtenons que les nombres pairs de la suite.

Cette boucle est utilisée pour parcourir les éléments d'une collection, liste, tableau,...
L'exemple donné ne fonctionne pas, nous aurons l'occasion d'utiliser cette boucle dans les tutoriels suivants.

Sub TestBoucle()
Dim objElem As Element
For Each objElem In Collection.Elements
	....
Next objElem
End Sub

Il est possible de sortir de la boucle avant que la condition finale ne soit atteinte. Cette instruction est valable pour toutes les boucles For.

If Condition Then Exit For

13-A-1. Len▲

Sub LongueurChaine()
	MsgBox Len("www.Developpez.Com")
End Sub

Sub LongueurChaine()
	Dim strMaVar As String
	strMaVar = "www.Developpez.Com"
	MsgBox Len(strMaVar)
End Sub

13-A-2. UCase▲

Sub MiseEnMajuscules()
	MsgBox UCase("www.developpez.com")
End Sub

13-A-3. LCase▲

Sub MiseEnMinuscules()
	MsgBox LCase("www.Developpez.Com")
End Sub

13-A-4. Left▲

Sub FonctionLeft()
	MsgBox Left("www.developpez.com", 3)
End Sub

13-A-5. Right▲

Sub FonctionRight()
	MsgBox Right("www.developpez.com", 3)
End sub

13-A-6. Mid▲

Sub FonctionMid()
	MsgBox Mid("www.developpez.com", 4, 12)
End Sub

13-A-7. Chr▲

Sub FonctionChr()
	MsgBox Chr(65)
End Sub

13-A-8. Asc▲

Sub FonctionAsc()
	MsgBox Asc("A")
End sub

Sub DecomposerChaine()
'Déclaration des variables
Dim strMaCh As String
Dim intI As Integer
'Affectation des données aux variables
strMaCh = "www.developpez.com"
'une boucle qui va compter de la première à la dernière lettre de notre variable
For intI = 1 To Len(strMaCh)
	'Pour ne pas devoir cliquer sur OK pour toutes les lettres, j'ai préféré l'utilisation
	'du Debug.Print, le résultat apparaît dans la fenêtre exécution (Ctrl + G)
	'La première partie affiche la lettre et la seconde son code
    Debug.Print Mid(strMaCh, intI, 1) & " - " & Asc(Mid(strMaCh, intI, 1))
Next intI

End Sub

13-A-9. Trim - LTrim - RTrim▲

Sub FonctionTrim()
	Debug.Print Trim ("    Bonjour Monsieur ")
End sub

13-A-10. StrReverse▲

Sub DecomposerChaine()
Dim strMaCh As String

strMaCh = "www.developpez.com"

Debug.Print StrReverse(strMaCh)

End Sub

13-A-11. Replace▲

Sub FonctionReplace()
Dim strMyChar As String
Dim strMyRepl As String

strMyChar = "www.developpez.com"
strMyRepl = "heureuxoli"

Debug.Print "Avant remplacement : " & strMyChar
Debug.Print "Après remplacement : " & Replace(strMyChar, "www", strMyRepl)


End Sub

13-A-12. InStr▲

Sub FonctionInStr()
Dim strMyChar As String

strMyChar = "www.developpez.com"

Debug.Print InStr(1, strMyChar, "d")

End Sub

13-A-13. Split▲

Sub FonctionSplit()
'Déclaration des variables
Dim strMyChar As String
Dim strMyResult() As String
Dim inti As Integer
'Affectation des données aux variables
strMyChar = "www.developpez.com"
'Utilisation de la fonction
strMyResult = Split(strMyChar, ".")
'Boucle pour l'affichage du contenu de la table
For inti = 0 To 2
Debug.Print inti & " - " & strMyResult(inti)
Next inti

End Sub

Pour les fonctions de conversion, elles vont être données sous la forme d'un tableau et ne seront pas détaillées.

13-B-1. Str▲

Str(123) 'Renvoie " 123"

Si vous désirez avoir une description plus complète que celle de ce tutoriel, je vous conseille de lire cet article.

13-C-1. Date()▲

Sub FonctionDate()
Debug.Print Date()
End Sub

13-C-2. Now()▲

Sub FonctionNow()
Debug.Print Now()
End Sub

13-C-3. DateAdd▲

Sub FonctionDateAdd()
Debug.Print DateAdd("d", 5, #27/02/2008#)
End Sub

13-C-4. DateDiff▲

Sub FonctionDateDiff()

Debug.Print DateDiff("d", #19/10/1964#, Date)

End Sub

13-C-5. DatePart▲

Sub FonctionDatePart()
Debug.Print DatePart("m", Date)

End Sub

13-C-6. DateSerial▲

Sub FnctionDateSerial()
Debug.Print DateSerial(2008, 12, 15)
End Sub

Sub FonctionPremierJourMoisSuivant()
Debug.Print DateSerial(Year(Date), Month(Date) + 1, 1)
End Sub

13-C-7. DateValue▲

Sub FonctionDateValue()
Debug.Print DateValue("15 décembre 2008")
End Sub

13-D-1. Beep▲

Sub FonctionBeep()
Dim intI As Integer
Dim intJ As Long
For intI = 1 To 10
 	Beep
 	intJ = 0
	 	For intJ = 1 To 10000000
 	Next intJ
Next intI
End Sub

13-D-2. Environ▲

Sub FonctionEnviron()
Debug.Print Environ("UserName")
End Sub

13-D-3. DoEvents▲

DoEvents

13-D-4. CreateObject▲

Sub FonctionCreateObject()
Dim objMyObject As Object

Set objMyObject = CreateObject("Excel.Application")

objMyObject.Quit
Set objMyObject = Nothing
End Sub

13-D-5. GetObject▲

Sub FonctionGetObject()
Dim objMyObject As Object

Set objMyObject = GetObject("Excel.Application")


Set objMyObject = Nothing
End Sub

Vous avez déjà fait connaissance avec ces fonctions dans les tutoriels précédents. Pour la fonction InputBox, le résultat doit être affecté à une variable ou à une autre fonction.
La fonction MsgBox peut quant à elle être utilisée seule pour avertir l'utilisateur, mais elle peut aussi servir à recueillir une information par le biais d'un bouton de réponse.

Sub FonctionInputBox()
Dim strMyVar As String

strMyVar = InputBox("Entrez un texte !", "Votre Texte")
MsgBox "Votre texte comporte " & Len(strMyVar) & " caractères"
End Sub

Lorsque vous utilisez la fonction MsgBox pour obtenir des informations, vous devez affecter son résultat à une variable ou à une fonction.

Sub FonctionMsgBox()
Dim strMyResponse As Integer

strMyResponse = MsgBox("Êtes vous d'accord ?", vbOKCancel, "Votre choix") 
If strMyResponse = 1 Then
    MsgBox "Vous avez cliqué sur OK !", , "OK"
Else
    MsgBox "Vous avez cliqué sur Annuler !", , "Annuler"
End If
End Sub

Voilà un exemple avec les deux possibilités d'utilisation d'un MsgBox.

Si vous voulez explorer les boîtes de message, un peu de lecture.