- EN TRAVAUX -

INITIATION

A LA PROGRAMMATION EN

VISUAL BASIC POUR APPLICATION (VBA)

En partant de zéro…

par Us. ( http://fordom.free.fr/ )

/ SOMMAIRE /

§ INTRODUCTION

§ PREMIERE MACRO pour l'exemple...

Ø Faire une macro commande

Ø Illustrations

Ø Lancer une macro

Ø L’éditeur de Visual Basic

§ PREMIER PROGRAMME : "bonjour maître"

Ø Pas à pas

Ø Exécuter un programme

§ PREMIERE INSTRUCTION : MsgBox

Ø Premier survol

Ø Détaillons un peu… beaucoup…

§ NOTION DE VARIABLES

Ø Présentation

Ø Quelques opérations très simples sur les variables contenant du texte

Ø Les opérations avec les variables numériques

§ INSTRUCTION CONDITIONNELLE : IF… THEN

Ø A quoi cela sert-il ?

Ø Syntaxe courte

Ø Que se passe-t-il vraiment ?

Ø Syntaxe plus complète

Ø Syntaxe complète

Ø Opérateurs logiques

Ø Dernier complément sur MsgBox

§ INSTRUCTION CONDITIONNELLE : SELECT CASE

Ø A quoi cela sert-il ?

Ø Syntaxe

Ø Exemple

§ INSTRUCTION : INPUTBOX

Ø A quoi cela sert-il ?

Ø Syntaxe

Ø Exemple

Ø Syntaxe alternative

Ø Application.InputBox

Ø Point sur VB et VBA

§ REALISER UNE BOUCLE

Ø A quoi cela sert-il ?

Ø La boucle avec FOR… TO… NEXT

Ø La boucle avec DO… LOOP

Ø Les autres structures de boucle

§ DIMENSIONNEMENT DE TABLEAUX

Ø Présentation

Ø Syntaxe à une dimension

Ø Exemple

Ø Utilité dans une macro simple

§ FAIRE UNE MACRO SIMPLE ADAPTER A SES BESOINS

Ø Les choses sérieuses commencent…

Ø Quelques objets d’Excel

Ø Hiérarchisation des objets

Ø Instructions supplémentaires : WITH

§ CONCEVOIR LA PETITE MACRO…

Ø Comment concevoir une macro simplement ?

Ø Simplification et adaptation d’une macro simple

Ø L’objet Range

Ø Récupération d’informations essentielles

Ø Introduction aux événements

§ EXEMPLES DETAILLES

Ø Exemple 1

Ø Exemple 2

§ ANNEXE

Ø Listes des constantes intégrées dans les applications MS Office

INTRODUCTION

MON ambition dans ce tutorial, c'est de vous faire découvrir la programmation à travers le langage de programmation " Visual Basic pour Application" (VBA), d'ailleurs essentiellement à partir d'Excel. Compte tenu, de la grande similarité des différentes versions de Visual Basic, cette initiation peut également vous servir pour tous les VB. (VB6, VBSCRIPT,...) . Je m’adresse en priorité aux débutants, en détaillant de nombreux points, simple en apparence pour les personnes connaissant déjà un peu la programmation…

Le sommaire reflétera les rubriques déjà écrites, et le plan de ce que j’envisage d’écrire (donc en constante évolution)…

PREMIERE MACRO pour l'exemple...

BON, assez parler ! Vous possédez Excel ?

Oui ! Alors, nous allons découvrir ensemble, ce qu'on appelle "faire une macro"...

Faire une macrro commande

Comment faire ?

Simple... Suivre les étapes suivantes :

1. Lancer Excel...

2. Dans le menu "Affichage > Barre d'outils > Visual Basic" : sélectionner ce menu.

3. Dans le nouveau menu qui vient de s'afficher, vous voyez un bouton avec un rond bleu ? Alors cliquer dessus ! Une boite de dialogue s'affiche, cliquer sur "ok"... l'enregistrement de la macro commence... à partir de maintenant, toutes (ou presque) les actions que vous ferez dans Excel seront enregistrées...

4. Par exemple, mettez-vous dans une cellule et taper un nombre : 10,

5. Descendez d'une case, et taper un autre nombre : aller 20,

6. Puis dans une autre, taper une formule pour faire la somme des deux nombres ci-dessus, (=somme(A1:A2) )

7. Encadrer ce dernier résultat, (bordure grasse, par exemple)

8. Mettez encore cette cellule en fond Jaune,

9. etc... taper un texte, appliquer lui un petit formatage... insérer un graphique... etc... etc... enfin, n'en faites pas trop tout même, on va pas passer la soirée dessus...

10. ET enfin, arrêter la macro ! Ah... mais... mais ... on fait comment ? C'est simple ! Lorsque vous avez lancé l'enregistrement de la macro, le rond bleu, c'est transformé en carré. IL suffit de cliquer dessus pour arrêter la macro. En fait, c'est le même code de signe que sur votre chaîne hifi ! ou votre télécommande...

Voilà, vous avez fait votre première macro... pas trop dur ?!

Illustrations

Voici deux petites captures pour mieux vous guider...

Illustration du menu Visual Basic

(Noter qu’en laissant le pointeur au-dessus d’un bouton, on affiche l’info-bulle correspondante.)

la boite de dialogue où il faut cliquer "ok"

Lancer la macro

Bon et maintenant ? Comment utilise-t-on la macro ?

Avant de lancer la macro, il faut tout effacer. Pourquoi ? C'est tout simplement pour voir que la macro fonctionne bien. En effet, toutes les manipulations que vous avez effectuées, vont être refait à l'identique... donc pour voir, par exemple que Excel récrit bien 10 et 20, etc... il faut mieux que tout soit vide, sinon on ne peut pas s'apercevoir de la réécriture sur celle existante.

ET comment lance-t-on la macro maintenant ?

Simple ! Il suffit de cliquer sur le petit triangle bleu, sur le menu de Visual Basic. (à côté du bouton rond, voir illustration ci-dessus). Et normalement, toutes les opérations effectuées lors de l'enregistrement sont exécutées de nouveau, bien sur à une vitesse bien supérieure... Ah... c'est magique l'informatique !

L'Editeur de Visual Basic

Bon, maintenant voyons c'est quoi exactement qu'une macro !

Pour cela, on va ouvrir l'éditeur du code de Visual Basic. Toujours avec le même menu Visual Basic en illustration ci-dessus, cliquer sur le 3ième bouton en partant de la droite, qui représente une fenêtre Windows. Aussitôt une nouvelle fenêtre s'affiche : c'est l'éditeur (Voir illustration).

La fenêtre est partagée généralement en 3 zones (ou plus selon les options d'affichage). Dans la partie gauche en haut (en général) il y a la zone "Projet". Ici on trouve tous les classeurs ouverts dans Excel, où des classeurs avec des extensions XLA qui comprennent en général des programmes VB (macros complémentaires)...

Mais nous allons ici, nous intéresser uniquement à notre macro, qui se trouve dans le classeur où vous avez enregistré votre macro, par défaut “ Classeur1 ”. Puis dans le sous répertoire “ Modules ”. Positionnez-vous sur “ Module1 ” en double cliquant, et dans la zone à droite, un listing apparaît : C'est le code de votre macro.

Illustration de l'éditeur de VBA

Voilà, tout ce que vous voyez à droite, correspond aux instructions qui composent la macro. Très schématiquement, chaque ligne correspond à une commande... Le but, dans ce qui va suivre, sera d'apprendre des instructions VB qui permettront adapter la macro à vos besoins. Car, comme vous vous en êtes rendu compte, si faire une macro est simple, son intérêt est tout de même assez limité en l'état, car trop statique. Tout l'intérêt d'une programmation en VB sera justement de pouvoir rendre cette macro dynamique. Et par la même occasion vous pourrez également programmer une application indépendante.

PREMIER PROGRAMME : "bonjour maître"

Commençons par le plus classique apprentissage : faire apparaître un message… oui mais pas n’importe lequel … “ Bonjour maître ”, je vous prie…

Pas a Pas

Pour faire apparaître un message en Visual Basic, on utilise une fonction qui se nomme “ Message Box ” qu’on écrit en abrégé MsgBox. Bien sur, toutes les instructions sont en anglais… ici la traduction française est simple : “ Boite à message ”.

Cette fonction fait partie d’une multitude d’instructions clés reconnues par VB. On découvrira progressivement les fonctions de base les plus importantes qui permettent la construction d’une programmation élaborée. La connaissance de ces fonctions de base est indispensable. Ces instructions se présentent toutes par un mot clé abrégé accompagné ou pas de paramètres complémentaires obligatoires ou optionnels.

Bon, on le programme ce message ? Comment faut-il faire ?

Simple ! A partir de l’éditeur VB, placez-vous sous la dernière ligne de code (toujours dans Module1). La dernière instruction de la macro c’est  “ End Sub ”…

Mais avant, observons la construction du codage de la macro.

La première ligne était “ Sub Macro1() ”. On a l’instruction “ Sub ” suivi du nom de la macro, ici “ Macro1 ”. En fait, “ Sub ” indique le début d’un programme, qu’on nomme afin de pouvoir le reconnaître. Et “ End Sub ”, indique évidemment la fin.

Et bien, on va faire pareil ! On va définir un nom à notre premier programme… par exemple “ MyProgram ”. Donc après “ End Sub ” de la “ Macro1 ”, écrivez “ Sub MyProgram() ”.

Automatiquement, l’éditeur écrit la dernière ligne “ End Sub ”.

Puis taper la fonction clé : “ MsgBox ” suivi du message entre guillemets “ Bonjour Maître ” (voir capture). Remarquer encore, lors de la saisie une info-bulle d’aide s’affiche indiquant la syntaxe complète de l’instruction.

Le listing complet sera le suivant :

Sub MyProgram()

MsgBox "Bonjour Maître"

End Sub

Voilà, votre premier programme est fini !

Illustration montrant le programme “ MyProgram ”

Exécuter un Programme

Voilà ! Votre premier programme est fini ! Bon, et comment on le lance ?

Simple ! Encore… Placer le curseur n’importe où dans les lignes que vous venez de taper. Puis cliquer sur le bouton avec le petit triangle bleu (sous la barre des menus). Voilà !

Et vous voyez le résultat suivant :

… il faut répondre “ ok ”, vous n’avez pas le choix…

Une autre façon de lancer “ MyProgram ”, c’est à partir d’Excel. Placez-vous donc maintenant dans Excel, puis à partir du menu Visual Basic, appuyer de nouveau sur le triangle bleu. Cette fois une autre boite de dialoguer s’affiche, vous demandant quelle macro lancer. Vous retrouvez “ Macro1 ” et “ MyProgram ”. Choisissez bien sur, “ MyProgram ”.

Lancer MyProgram à partir d’Excel

IL existe encore bien d'autres façons d'appeler une macro que nous verrons plus tard, pour se concentrer sur la découverte de la programmation.

Bon, maintenant que vous avez fait vos premiers pas (J) on va poursuivre en étudiant cette première instruction très riche, ce qui vous familiarisera avec les syntaxes des instructions VB, et de plus, elle sera très utile pour la suite, pour comprendre rapidement le fonctionnement d’autres instructions, car on pourra afficher des résultats intermédiaires, et ainsi décortiquer le fonctionnement…

PREMIERE INSTRUCTION : MsgBox

La syntaxe complète de “ Message Box ” (MsgBox) est donc la suivante :

MsgBox ( prompt, [buttons] , [title] , [helpfile] , [context] )

Les paramètres qui sont entre crochet sont optionnels. Cette notation est générale dans l’info-bulle ou dans le fichier d’aide sur VB…

Premier Survol…

Prompt : représente le message à afficher.

Buttons : représente les boutons prédéfinis. Par défaut, il y a que le seul bouton “ OK ”. Ce paramètre vaut “ vbOKOnly ” comme on peut le voir sur la capture de l’info-bulle ci-dessous.

Title : représente le titre de la boite de dialogue. Par défaut c’est le nom de l’application.

Helpfile : représente le chemin et le nom du fichier d’aide qu’on peut associer à la boite de dialogue. Cette possibilité est très peu utilisée, voir pas du tout.

Context : est un repère dans le fichier d’aide ci-dessus, pour afficher qu’une rubrique spécifiée.

Détaillons un Peu… Beaucoup…

La description du fonctionnement de cette instruction, va nous permettre d’aborder quelques notions essentielles sur l’organisation du langage.

Ø Le Prompt

Le Prompt (le message) peut être de type numérique ou alphanumérique.

Que veut dire ces termes ?

Le type numérique représente tous les nombres avec lesquels on peut faire des calculs. Par exemple 123 ou –987,445.

Le type alphanumérique représente du texte, avec lequel on peut écrire. Par exemple “ BONJOUR ! Je vous reçois 5/5 ”. On peut cumuler des nombres avec du texte, mais ici ces nombres sont considérés comme n’importe quel caractère, et donc il n’est pas possible d’en faire ressortir le résultat d’un calcul…

Pour illustrer mes propos, je vous propose d’essayer ces quelques exemples, bien sur à copier dans l’éditeur VBA, comme précédemment.

Pour vous faciliter la vie, vous pouvez mettre le code en surbrillance puis le copier (CTRL+C), et dans l’éditeur le coller (CTRL+V).

Sub MesBoites()

MsgBox "Mon premier message est alphanumérique ! Comme le dernier !"

MsgBox 12345.6789

MsgBox 12345.6789 + 12345.6789

MsgBox "12345.6789 + 12345.6789"

End Sub

On notera que le troisième message affiche le résultat de l’addition, contrairement au dernier qui lui affiche l’opération en texte…

On retrouvera par la suite, la notion de type pour les variables. C’est donc qu’une première approche, facile à comprendre…

Ø Buttons

Détaillons l’option Buttons qui permet de mettre des boutons prédéfinis.

Comment fait-on pour définir d’autres boutons ?

Simple. Juste après le Prompt mettez une virgule. Aussitôt un petit bandeau déroulant s’affiche. Cette liste représente tous les paramètres possibles pour Buttons.

Illustration lors de la frappe du bandeau déroulant de sélection automatique

Dans l’immédiat, on va s’intéresser qu’à certaines options, ou plus précisément, à certaines constantes. Ces constantes commencent toutes par les initiales “ vb ” suivie par une description plus ou moins compréhensible.

Ces constantes en question sont les suivantes :

· VbOKOnly : Affiche le bouton OK uniquement.

· VbOKCancel : Affiche les boutons OK et Annuler.

· VbAbortRetryIgnore : Affiche le bouton Abandonner, Réessayer et Ignorer

· VbYesNoCancel : Affiche les boutons Oui, Non et Annuler.

· VbYesNo : Affiche les boutons Oui et Non.

· VbRetryCancel : Affiche les boutons Réessayer et Annuler.

Essayer donc un peu quelques exemples de “ Message Box ” avec ces différents paramètres…

Par exemple :

Sub MesBoites()

MsgBox "Tu veux ou tu ne veux pas ?", vbYesNo

End Sub

Qui affiche :

Illustration avec deux boutons

J’ai parlé de constante ! Pourquoi ?

En réalité, lorsqu’on écrit “ vbYesNo ”, VBA remplace en interne ce paramètre par un nombre. Ici c’est la valeur 4. Pour le voir, on peut utiliser la fonction “ MsgBox ” pour afficher la valeur numérique de “ vbYesNo ”. 

Par exemple essayer (et expérimenter par vous-même les autres constantes) :

Sub MesBoites()

MsgBox vbYesNo

End Sub

… qui affiche la valeur 4… comme pour l’exemple avec l’addition, VBA affiche directement le résultat… c’est donc bien une constante de type numérique…

Ainsi, l’exemple précédent pourrait aussi s’écrire :

Sub MesBoites()

MsgBox "Tu veux ou tu ne veux pas ?", 4

End Sub

Mais bon… c’est tout de suite moins clair… Savoir que la valeur 4 affichera deux boutons Oui et Non… ce n’est pas facile à retenir sous forme numérique… donc préférer la notation littérale vbYesNo.

L’utilisation de certaines constantes prédéfinis dans une instruction (qui en possède) est assez générale en VB. C’était un point intéressant de soulever… je vous avais dit que cette instruction était riche… et c’est pas fini…

J’ai dit qu’on s’intéressera qu’à certaines constantes dans l’immédiat, et les autres servent à quoi maintenant ?

Et bien… à plusieurs choses ! que je vais détailler…

Les constantes vbDefaultButton1 jusqu’à vbDefaultButton4, servent à mettre le focus (présélection) sur un des boutons, numérotés de 1 à 4. (Il est à noter qu’il n’existe pas de boite avec 4 boutons, donc vbDefaultButton4, est totalement inutile… c’est aussi un des charmes de VB J )

Et comment utiliser cette possibilité ?

Simple. IL suffit d’additionner les constantes.

Par exemple :

Sub MesBoites()

MsgBox "Mon focus sur le 2ième bouton", vbYesNo + vbDefaultButton2

End Sub

Donnera le focus sur Non, au lieu de Oui par défaut :

Illustration du focus sur NON

On peut également afficher une icône dans la boite de dialogue, grâce aux constantes :

· VbCritical : Affiche une croix blanche dans un cercle rouge

· VbExclamation : Affiche un point d’exclamation dans un triangle jaune

· VbInformation : Affiche un i bleu dans une bulle blanche

· VbQuestion : Affiche un ? bleu dans une bulle blanche

A titre d’exemple :

Sub MesBoites()

MsgBox "Vous comprenez ?", vbYesNo + vbQuestion

End Sub

Illustration de l’icône à gauche

IL existe d’autres constantes très peu utilisées, voir jamais, que je ne détaille pas pour passer à la suite…

Ø Title

L’option Title (Titre) définie donc le titre de la boite de dialogue. Rien de plus simple à paramétrer…

Exemple :

Sub MesBoites()

MsgBox "JE suis le Prompt", , "JE suis le Titre"

End Sub

Illustration du Titre

Voilà, j’arrête là les explications sur “ MsgBox ”, bien qu’il reste encore quelques détails…

Maintenant que nous savons dialoguer avec l’utilisateur, il faudrait aussi être capable de traiter la réponse de celui-ci, lorsqu’il clique sur un des boutons OUI ou NON par exemple… Ce qui va nous permettre d’aborder deux choses indispensables pour progresser, la notion de variables et une nouvelle instruction “ IF ”.

NOTION DE VARIABLES

Présentation

A quoi cela sert-il ?

Une variable sert à stocker une information, qui pourra faire l’objet d’un traitement.

Comment fabrique-t-on une variable ?

Simple ! IL n’y a rien à faire ! IL suffit juste de définir un nom et de lui affecter une information grâce au signe égale (“ = ”). C’est tout !

En fait procéder ainsi, déclare une variable de façon dite implicite, avec un type particulier qui lui permet de prendre indifféremment une valeur numérique ou du texte… ce type se nomme Variant.

Le nom de la variable doit tout même respecter certains critères. Le nom ne doit pas porter le nom d’une instruction… c’est assez normal car VB va plus s’y retrouver, et dans la majorité des cas, VB vous signalera une erreur dès l’écriture du code… Il ne doit pas comporter de caractère spécial, comme les ponctuations, et doit commencer obligatoirement par une lettre. Ensuite seulement on peut mettre des chiffres. Ainsi, “ 3Variable ” n’est pas valide, mais “ Variable3 ” est correcte.

Par exemple, on va créer une variable qu’on appellera “ MaVariable ” avec l’exemple suivant :

Sub MesVariables()

MaVariable = "Je suis une variable !"

End Sub

Bien sur, si vous exécutez le code ci-dessus, il ne se passe rien… enfin, plutôt on ne voit rien, mais la variable a bien été créée. Pour mieux s’en rendre compte, on va utiliser MsgBox pour afficher le contenu de MaVariable. Voici le code :

Sub MesVariables()

MaVariable = "Je suis une variable !"

MsgBox MaVariable

End Sub

Et on obtient l’affichage suivant :

Affichage du contenu d’une variable

On a donc remplacé l’affichage direct du Prompt par le contenu de la variable.

Pour définir une variable stockant un nombre, on procède de la même façon sauf qu’on lui affecte un nombre bien sur…

Par exemple :

Sub MesVariables()

MonNombre = 12345.6789

MsgBox MonNombre

End Sub

Les opérations sur les variables

Comme on vient de le voir dans cette présentation, les variables peuvent contenir soit du texte soit un nombre. On va opérer une séparation claire entre ces deux catégories pour présenter les opérations qu’on peut faire avec.

Quelques opérations très simples avec des variables contenant du texte

Commençons à préciser au fur et à mesure de la lecture, quelques termes utilisés en anglais. Par exemple, pour évoquer qu’une variable contient que du texte (donc des données alphanumériques), on nomme son type “ String ”.

Commençons par “ rabouter ” deux variables textes. Cette opération s’appelle une “ concaténation ”. Je suis d’accord avec vous, pour dire que c’est un terme bien barbare pour pas grand chose… On réalise cette opération grâce au “ et commercial ” représenté par le symbole “ & ”.

Voyons tout de suite un exemple, cela vaudra mieux qu’un grand discours…

Sub MesVariables()

V1 = "Je suis la première variable. "

V2 = "Je suis la deuxième variable. "

V3 = "Et Us nous a collées !"

MsgBox V1 & V2 & V3

End Sub

Dont voici le résultat :

Concaténation de texte

Donc chaque variable V1, V2 et V3, contient du texte, qu’on “ colle ” les uns à la suite des autres au moment de l’affichage.

Bien sur, il aurait été possible de le faire directement dans l’instruction MsgBox, sans passer par des variables. Par exemple avec :

Sub MesVariables()

MsgBox "Je suis la première variable. " & "Je suis la deuxième variable. " & "Et Us nous a collées !"

End Sub

Ou encore en utilisant un mixte des deux formes ci-dessus, avec une partie dans des variables et l’autre en direct :

Sub MesVariables()

V1 = "Je suis la première variable. "

V2 = "Je suis la deuxième variable. "

MsgBox V1 & V2 & "Et Us nous a collées !"

End Sub

Et rien ne nous empêche de définir une autre variable, par exemple qu’on nomme “ Message ”, contenant les autres variables.

Par exemple :

Sub MesVariables()

V1 = "Je suis la première variable. "

V2 = "Je suis la deuxième variable. "

Message = V1 & V2 & "Et Us nous a collées !"

MsgBox Message

End Sub

Voilà, tous ces exemples sont strictement équivalents, mais rebondissons sur ce dernier exemple pour voir comment on peut limiter le nombre de variables, à une seule… En effet, rien n’interdit d’affecter le contenu d’une variable à cette même variable augmenté d’un complément. Voyons cela :

Sub MesVariables()

Message = "Je suis le premier texte. "

Message = Message & "Je suis le deuxième texte. "

Message = Message & "Et Us nous a collés !"

MsgBox Message

End Sub

( J’ai changé un peu le texte J )

Si on décortique…

Après la première ligne :

Message contient “ Je suis le premier texte. ”

Après la deuxième ligne :

Message contient “ Je suis le premier texte. Je suis le deuxième texte. ”

C’est à dire, le premier contenu de Message auquel on lui rajoute le deuxième texte.

Après la troisième ligne :

Message contient “ Je suis le premier texte. Je suis le deuxième texte. Et Us nous a collés !”

C’est à dire le dernier contenu connu de Message auquel on lui rajoute le dernier texte.

Avec ce dernier exemple, je veux mettre l’accent sur le fonctionnement de l’égalité (=), qui, comme je l’ai précisé en introduction, mets une information dans une variable. Par la suite, le même principe sera utilisé, mais avec des nombres…

=

Poursuivons par quelques compléments, pour permettre un petit formatage du texte pour améliorer l’affichage avec MsgBox. Comme on le constate, le texte affiché par MsgBox, aussi long soit-il, tient que sur une ligne, au point même de pouvoir sortir de l’écran.

Comment peut-on donc faire un renvoi à la ligne suivante ?

Simple ! Grâce à des caractères spéciaux qui seront interprétés comme un retour de chariot et un saut de ligne… Cela peut paraître un peu mystérieux dit comme cela… Un retour chariot ? … Ben, comme cela n’a pas grande importance, je passe sous silence, et utilisons sans complexe encore les constantes intégrées à VB. Ici, il suffira de couper le texte par “ vbCrLf ”.

En reprenant le dernier exemple, on va faire un renvoi de chaque ligne :

Sub MesVariables()

Message = "Je suis le premier texte. " & vbCrLf

Message = Message & "Je suis le deuxième texte. " & vbCrLf

Message = Message & "Et Us nous a collés !"

MsgBox Message

End Sub

Dont voici une illustration :

Retour à la ligne

… Pour la petite histoire, à la place de vbCrLf, vous pouvez encore utiliser “ vbCr ” ou “ vbLf ”, qui auront ici le même effet… “ Cr ” est l’abréviation de “ Carriage Return ” (Retour Chariot), et “ Lf ” pour “ Line Feed ” (Retour à la ligne suivante) ce qui, dans les premiers gros systèmes des années 1960/65 consistait à faire exécuter sur les premières imprimantes (type machine à écrire), un retour chariot et une montée du papier d'une ligne. (Rq de Mikel39)

Et comme VB est riche en constante prédéfinis, il en existe une autre “ vbNewLine ” qui réalise exactement la même chose que “ vbCrLf ”. C’est donc un équivalent un peu plus explicite, après c’est une question de choix…

Comment faire une tabulation ?

Faire une tabulation avec MsgBox est assez peu employée, mais bon… comme c’est exactement le même principe… Il suffit d’utiliser le caractère spécial pour la tabulation ! Ah, oui… utilisons encore les constantes prédéfinies dans VB avec “ vbTab ”.

Exemple :

Sub MesVariables()

Message = "Je suis le premier texte. " & vbCrLf & vbTab

Message = Message & "Je suis le deuxième texte. " & vbCrLf & vbTab & vbTab

Message = Message & "Et Us nous a collés !"

MsgBox Message

End Sub

Donnant :

Tabulation

Voyons maintenant les variables de type numérique…

Quelques opérations sur des variables numériques

Qui dit nombre, dit calcul !

Voyons donc comment faire les quatre opérations arithmétiques élémentaires. Ces opérations sont effectuées classiquement avec les 4 signes + - * /

Ces signes sont tellement classiques que je pense qu’il est inutile d’en dire plus… Un exemple valant mieux qu’un grand discours…

Sub MesVariablesNumeriques()

x = 123.456

y = 1234.56

MsgBox "Addition = " & x + y

MsgBox "Soustraction = " & x - y

MsgBox "Multiplication = " & x * y

MsgBox "Division = " & x / y

MsgBox "l'Addition de " & x & " et de " & y & " vaut " & x + y

End Sub

Avec pour le premier renvoi :

Addition

La dernière ligne est intéressante à observer pour la concaténation…

=

Comme il est très facile de comprendre comment on réalise les opérations sur les nombres, j’en profite pour montrer les fonctions sur les nombres :

Sub MesVariablesNumeriques()

X = 0.5

MsgBox "Sinus = " & Sin(X)

MsgBox "Cosinus = " & Cos(X)

MsgBox "Tangente = " & Tan(X)

MsgBox "Arc tangente en radian = " & Atn(X)

MsgBox "Logarithme naturel = " & Log(X)

MsgBox "Exponentielle = " & Exp(X)

MsgBox "Racine carrée = " & Sqr(X)

MsgBox "Racine carrée avec ^ = " & X ^ 0.5

MsgBox "Le carré = " & X ^ 2

Msgbox "La valeur absolue = " & Abs(-X)

End Sub

Et pis, on a fait le tour ! (ou presque… J)

Vous avez remarquez qu’il n’y a pas d’ArcSinus ou d’Arccosinus ! En fait, il faut passer par un calcul avec l’Arctangente… On trouve dans l’aide de VB ces relations, et bien d’autres. Enfin, notons qu’on obtient facilement la constante Pi = 3,14… grâce à la formule 4*Atn(1).

Pour exemple, on a :

Sub MesVariablesNumeriques()

X = 0.5

MsgBox "Arc Sinus = " & Atn(X / Sqr(-X * X + 1))

MsgBox "Arc Cosinus = " & Atn(-X / Sqr(-X * X + 1)) + 2 * Atn(1)

MsgBox "Pi = " & 4 * Atn(1)

End Sub

=

Comme précédemment, le résultat d’un calcul d’une série de variable peut être mis dans une autre variable… De même, on peut “ incrémenter ” (c’est comme ça qu’on dit en programmation pour dire augmenter de X) une variable. Sur l’exemple suivant, on incrémente Z d’une unité à la dernière ligne, vous avez compris comment, je pense…

Exemple :

Sub MesVariablesNumeriques()

x = 0.5

y = 1.5

Z = x + y ^ x + Sin(x + y) * Exp(y)

Z = Z + 1

MsgBox Z

End Sub

Maintenant que nous savons affecter un contenu à une variable, on va voir une seconde instruction de base, cette instruction c’est IF.

INSTRUCTION CONDITIONNELLE : IF… THEN

L’instruction IF est assez multiforme. Voyons progressivement les différentes formes du plus simple au plus complet.

Mais déjà à quoi sert-elle ?

Cette instruction permet de faire une comparaison entre deux variables (au sens large), on peut aussi dire tester une “ condition ” pour ensuite se brancher sur telle ou telle partie du programme, selon que cette condition est vérifiée ou non.

La syntaxe courte :

IF (condition) THEN (instruction)

Expliquons ces termes…

IF se traduit en français par SI, et THEN par ALORS. Si la condition est remplie alors la suite après THEN sera exécutée.

Par exemple :

Sub TestIF()

X = 2

If X = 2 Then MsgBox "La condition X=2 est vraie"

End Sub

Si vous exécutez ce code, le message sera affiché puisque “ X = 2 ” est vraie. Si on y met une autre valeur, par exemple “ X = 1 ”, il n’y aura pas de message… et le programme passera à la suite, ici à End Sub qui fini l’exécution.

Lorsqu’on écrit une condition IF, que se passe-t-il vraiment ?

Si une condition est vraie ou vérifiée alors “ X = 2” renvoie à IF, la valeur VRAIE, qui trouve en programmation son équivalent TRUE… ou plus exactement la valeur numérique qui lui est attachée valant -1. Dans le cas contraire, la condition renvoie FALSE (= FAUX), ayant pour valeur numérique 0.

Comment définit-on une condition ?

Comme on vient de le voir pour une variable numérique, il suffit d’écrire une égalité (=) dont la compréhension est évidente… Mais on aurait pu également utiliser inférieur (<), supérieur (>), inférieur ou égal (<=), supérieur ou égal (>=), ou encore différent de (<>).

Pour une “ variable texte ” (String) on utilise en général que l’égalité (=) ou la différence (<>). Bien qu’il soit encore possible d’utiliser les autres comparaisons. A titre d’exemple :

Sub TestIF()

Texte1 = "ABCD"

Texte2 = "ABC"

If Texte1 > Texte2 Then MsgBox "La condition est vraie"

End Sub

Qui renvoie ici le message. En fait, VB compare les variables alphanumériques en les classant à la manière d’un dictionnaire. L’explication fine de cet exemple dépasse le cadre d’une initiation J.

Ecriture multiligne de IF :

Après THEN, rien n’empêche d’exécuter plusieurs instructions au lieu d’une seule. Pour cela, on peut écrire les instructions les unes après les autres séparées par deux points. ( : )

Par exemple : Ecrivons deux messages qui se suivent…

Sub TestIF()

X = 2

If X = 2 Then MsgBox "La condition X=2 est vraie": MsgBox "Deuxième instruction !"

End Sub

Mais cette écriture sur une ligne devient vite illisible. Pour faciliter la vie des programmeurs, il a été prévu une écriture multiligne qui consiste à faire un retour à la ligne après THEN, et de rajouter un marqueur de fin de l’instruction avec END IF. L’exemple précédent devient alors :

Sub TestIF()

X = 2

If X = 2 Then

MsgBox "La condition est vraie"

MsgBox "Deuxième instruction !"

End If

End Sub

De plus, on notera le décalage des instructions MsgBox pour augmenter la lisibilité, réalisé avec la tabulation. La tabulation n’a aucune influence sur l’exécution. Dorénavant, nous prendrons l’habitude de présenter une programmation de cette façon. La pratique courante veut qu’on décale les instructions (ici MsgBox) lorsqu’elles sont “ contenues ” dans une instruction d’un “ niveau supérieur ” (ici IF). En clair ici, comme l’exécution des MsgBox dépend de IF, on les décale d’un cran. Cela permet une relecture plus facile pour le repérage d’éventuelle erreur.

Poursuivons la description de l’instruction IF…

Syntaxe plus complète : programmer l’alternative ?

Dans le cas où la condition n’est pas remplie, au lieu de poursuivre tout de suite le code après IF, on peut lui donner une alternative à exécuter. C’est le rôle du mot clé ELSE.

IF (condition) THEN (instruction 1) ELSE (instruction 2)

Ou sous forme multiligne :

IF (condition) THEN

(instruction 1)

ELSE

(instruction 2)

END IF

ELSE se traduit en français par SINON, je pense que la compréhension est immédiate ! J

A titre d’illustration :

Sub TestIF()

X = 1

If X = 2 Then

MsgBox "La condition X=2 est vraie !"

Else

MsgBox "La condition X=2 n'est pas vérifiée !"

End If

End Sub

Il est à noter qu’il ne peut y avoir plusieurs ELSE.

Syntaxe complète : Tester plusieurs conditions ?

Maintenant, intéressons nous à la forme la plus complète qui permet de tester une multitude de conditions, grâce au complément ELSEIF.

La syntaxe est nécessairement multiligne :

IF (condition 1) THEN

(instructions 1)

ELSEIF (condition 2) THEN

(instructions 2)

ELSEIF (condition 3) THEN

(instructions 3)

ELSE

(instructions 4)

END IF

ELSEIF se traduit en français par SINON SI … ce n’est guère plus difficile à comprendre ! J

Le nombre de ELSEIF n’est pas limité, et lorsqu’une condition est remplie, par exemple “ condition2 ” alors la suite des instructions, c’est à dire “ instructions 2 ” est exécutée, puis le code passe directement à la fin de l’instruction soit END IF, pour poursuivre.

Par exemple :

Sub TestIF()

X = 4

If X = 2 Then

MsgBox "La condition X = 2 est vraie."

ElseIf X = 3 Then

MsgBox "Ici X = 3."

ElseIf X = 4 Then

MsgBox "Là X = 4."

ElseIf X = 4 Then

MsgBox "Ce message ne sera jamais exécuté !!"

Else

MsgBox "Les conditions sur X ne sont pas vérifiées !"

End If

End Sub

Essayer avec X égale 2, 3, 4 et 1. Pour la valeur 4, on a deux conditions X=4 de programmées, mais seule la première s’exécutera… car ensuite l’exécution passera directement à END IF. Avez-vous compris ? J

… par conséquent, la deuxième condition X=4 est une ligne totalement inutile au codage L même si sa syntaxe est juste, et ne déclenche donc pas d’erreur… Ce genre de confusion se rencontre lorsqu’on débute…

Les opérateurs logiques

C’est quoi ces petites bêtes ?

Simple ! Un opérateur logique est une relation entre deux conditions. Euh… oui, dit comme ça… ? c’est bof… En fait, on s’en sert pour rassembler plusieurs tests possibles. Par exemple, si on veut une condition sur une variable X, tel que X=2 OU X=3 … ici l’opérateur logique c’est “ OU ”. En anglais “ OU ” se dit “ OR ”. Et Bien, voilà ! vous venez de découvrir l’opérateur logique “ OR ” !

Un autre très courant c’est “ ET ”, qui se dit en anglais “ AND ”.

Voilà ! c’est tout ! simple, non ? J

IL en existe d’autres très peu utilisés et beaucoup plus subtils à comprendre, que je ne détaille pas…

Un petit exemple :

Sub TestOp()

X = 2

Y = 3

If X = 2 Or Y = 3 Then

MsgBox "X ou Y est vérifié ou les deux à la fois"

End If

If X = 2 And Y = 3 Then

MsgBox "X et Y sont vérifiés en même temps"

End If

If Not (X = 2 Or Y = 3) Then

MsgBox "X ou Y ne sont pas vérifiés ou les deux à la fois"

End If

End Sub

Ouppsss… en prime vous avez un autre opérateur logique : “ NOT ” … qui se traduit par “ NON ” ou par “ N’EST PAS ”, bref par une négation. En clair, l’opérateur logique “ NOT ” renvoie l’inverse du résultat de la condition. Vous souvenez-vous, qu’une condition renvoie seulement VRAIE ou FAUX … ! Ainsi, “ NOT ” inverse VRAIE en FAUX et FAUX en VRAIE.

Mais dans les faits, cet opérateur n’est jamais vraiment nécessaire puisqu’on peut toujours inverser une condition grâce au fait que “ <> ” (différent de) est exactement l’inverse de “ = ” (identique à). La dernière ligne aurait pu donc s’écrire :

If X <> 2 Or Y <> 3 Then

MsgBox "X ou Y ne sont pas vérifiés ou les deux à la fois"

End If

C’est un peu comme en mathématique, il n’existe pas forcément qu’un seul chemin pour arriver à la solution. C’est ce qui fait que pour un même problème, on arrive parfois à des dizaines de programmations différentes ! J

=

Dernier complément sur MsgBox

Revenons à notre fameuse instruction “ Message Box ” qu’on avait mis de côté… On voulait être capable de traiter la réponse de l’utilisateur lorsqu’il choisissait un bouton spécifique.

Comment faire ?

Le principe est simple, car il suffit de récupérer une constante représentant le bouton choisi, et de traiter la réponse grâce à IF.

En effet, à chaque appelle de MsgBox , celui-ci renvoi une constante dépendant du bouton choisi. Pour récupérer cette constante, il suffit de stocker directement dans une variable la réponse renvoyée par MsgBox. Mais avec une petite subtilité de syntaxe. En effet, écrire :

X = MsgBox "Cliquer sur OK, SVP."

… cause une erreur que VB signale tout de suite. La raison en est simple, la partie entre guillemet est non pas considérée comme un complément à l’instruction MsgBox, mais comme un texte “ à concaténner ” à MsgBox à cause de la présence “ = ” , puisque le tout doit être renvoyé dans X.

La solution ?

Pour indiquer que le texte est un complément à l’instruction MsgBox, il suffit de le mettre entre parenthèse. La syntaxe correcte s’écrit alors :

X = MsgBox("Cliquer sur OK, SVP.")

Voilà, ce principe se retrouvera dans bien d’autre situation…

Les constantes prédéfinies qui peuvent être renvoyées par MsgBox sont :

· vbOK : Bouton OK

· vbCancel : Bouton Annuler

· vbAbort : Bouton Abandonner

· vbRetry : Bouton Répéter

· vbIgnore : Bouton Ignorer

· vbYes : Bouton Oui

· vbNo : Bouton Non

Un exemple…

Maintenant voyons comment tout cela s’organise sur un petit exemple un peu plus élaboré, même si encore trivial, mais avec quelques petits points instructifs, et mettant en jeu ce qu’on déjà vu…

Sub Test_If_Msgbox()

Rem =====================================================

Rem CE test sert à illustrer le traitement de la réponse

Rem de Msgbox, en mettant en jeu l'instruction IF

Rem =====================================================

'On pose une question, dont la réponse sera mise dans

'la variable déclarée implicitement "Reponse1"

'-----------------------------------------------------

reponse1 = MsgBox("Choisssez Oui ou Non !", vbYesNo + _

vbDefaultButton1 + vbQuestion, "Un truc...")

'Traitement de la réponse grâce à IF ____________________________________

If reponse1 = vbNo Then 'SI la réponse est NON (vbNo) ALORS

Message = "Je suis très étonné !" 'MESSAGE contiendra "je suis..."

Else 'SINON

Message = "Hum..." 'MESSAGE contiendra "Hum..."

Point = 1 'et POINT vaudra 1

End If 'Fin de l'instruction SI

'On complète Message

Message = Message & vbCrLf & vbCrLf & "J'en ai encore deux autres..."

'On affiche Message

MsgBox Message, vbInformation, "..."

'On pose encore 2 questions Oui ou Non

reponse2 = MsgBox("Préférez-vous ""Oui"" ?", vbYesNo + vbQuestion)

reponse3 = MsgBox("Choisissez encore en votre âme et conscience..." _

& vbCrLf & vbCrLf & "c'est la dernière fois...", _

vbYesNo + vbCritical)

'Calcul des points en fonction des réponses

If reponse2 = vbYes Then Point = Point + 1

If reponse3 = vbYes Then Point = Point + 1

'Traitement des points

Rapport = 100 * Point / 3

MsgBox "Vous avez répondu ""Oui"" dans " & Rapport & " % des cas !"

If Point = 0 Then

Message = "Vous êtes très singulier !"

ElseIf Point = 1 Then

Message = "Vous êtes singulier !"

ElseIf Point = 2 Then

Message = "Vous êtes dans la moyenne !"

Else

Message = "Vous êtes singulier !"

End If

'Réponse finale

MsgBox "... et savez-vous que statistiquement, on répond" & vbCrLf _

& "plus facilement ""Oui"" que ""Non"", dans 60% des cas ?" _

& vbCrLf & vbCrLf & " J'en conclu que : " & vbCrLf & vbCrLf _

& vbTab & Message

MsgBox "Mais rien de grave...", vbOKOnly, " -:); "

End Sub

… normalement vous avez toutes les clés pour comprendre cet exemple… J

=

Cliquer sur le lien pour exécuter cette macro prête à l’emploi :

Classeur exemple

=

Les points instructifs sont déjà deux nouvelles instructions, qui en font qu’une :

- REM ou une apostrophe “ ’ ” écrit en vert en général… A quoi servent-elles ?

Simple ! A rien ! … Bizarre, non ?

En fait, REM est l’abréviation de REMARQUE, destiné uniquement au programmeur afin qu’il puisse écrire des points de repère (des remarques) qui lui permettra de se repérer dans le codage en écrivant tout ce qu’il lui semble utile. L’apostrophe, n’étant qu’un raccourci de REM. Ces remarques peuvent être écrit un peu près n’importe où, sauf bien sur, devant les instructions devant s’exécuter. IL est à noter que ces REMarques sont beaucoup plus utiles qu’on le pense aux premiers abords… Elles deviennent même essentielles lorsque le listing s’agrandit…

- Un renvoi à la ligne en plein milieu d’une instruction ! Regarder les Msgbox…

En fait, encore pour faciliter la visibilité du codage, il a été prévu la possibilité d’une coupure pour un renvoi à la ligne en écrivant un espace suivi d’un soulignement “ _” sans aucune conséquence d’interprétation sur la construction d’une instruction. Ce renvoi vise à éviter une écriture sortant de l’écran, donc avoir tout le code sous les yeux ! … Pratique, non ?

- Observer, dans les Msgbox, comment sont entourés les OUI et les NON ! On voit deux guillemets qui se suivent ! … Etranges, non ?

En fait, on procède ainsi pour afficher les OUI et les NON entourés de guillemets à l’exécution… cela permet de différencier ces guillemets avec ceux destinés à Msgbox pour indiquer le début et la fin du prompt…

… euh… j’ai 3 fois non… ? J

INSTRUCTION CONDITIONNELLE : SELECT…CASE

On va commencer à remplir sa sacoche avec un nouvel outil… J

A quoi cela sert-il ?

Simple, encore une fois !

SELECT CASE est une fonction jumelle à IF… ELSEIF… END IF. La seule différence étant qu’elle s’applique qu’à une seule variable. Son intérêt réside surtout dans sa clarté.

Ici la traduction française de cette instruction pourrait être “ Sélection Case ”, bien sur… mais pour traduire son fonctionnement, il faut l’interpréter de la manière suivante : “ Sélection de la case correspondante en fonction de la valeur de la variable ”. Et par “ Case ” il faut comprendre que l’exécution se branchera sur la partie définie par “ CASE ”.

La syntaxe :

SELECT CASE (variable)

CASE (conditions1)

(instructions1)

CASE (conditions2)

(instructions2)

CASE (conditions3)

(instructions3)

…

CASE ELSE

(instructions)

END SELECT

=

Détaillons la syntaxe… Les conditions ont plusieurs syntaxes adaptées à cette instructions, dont voici le détail :

Pour tester, une valeur particulière, il suffit d’écrire à la place de “ conditions ” directement par la valeur. Par exemple, si on veut tester la variable égale à 1, la syntaxe sera “ CASE 1 ”.

Pour tester une série de valeur particulière, il suffira de les écrire séparées par une virgule. Soit “ CASE 1, 5, 7 ”.

Pour tester une limite supérieure ou inférieure d’une valeur, on utilise la syntaxe : “ CASE IS < ” suivi de la borne.

Pour tester une différence avec une valeur, par exemple avec 1, on utilise la syntaxe “  CASE IS <> 1 ”

Dans tous les cas on peut cumuler les conditions en les séparant par une virgule. Par exemple, la ligne “  CASE 1, IS > 4 ” est valide.

Pour tester une plage de valeur, on utilise la syntaxe “ CASE 2 TO 4 ” , pour les nombres compris entre 2 et 4 inclus.

Bien sur rien n’empêche d’utiliser une variable texte (string). Le principe de la syntaxe reste identique. Par exemple, on écrira Case "Oui".

IL est à noter que dès qu’une condition est vérifiée, il sera exécuter les instructions correspondantes, puis on passera directement à la fin donc juste après END SELECT. Par conséquent, comme avec ELSEIF, on peut programmer plusieurs conditions qui se recoupent et donc inutile au fonctionnement.

Exemple avec des nombres :

Sub Test_Select()

'Initialisation

A = 2.5

B = 8

'Procédure de test

Select Case A

Case 1

Message = "la valeur 1"

Case 2 To 4

Message = "la valeur est comprise entre 2 et 4"

Case 5, 7

Message = "une des valeurs 5, 7"

Case Is < 0, 6

Message = "une valeur négative ou 6"

Case B

Message = "la même valeur que B"

Case Else

Message = "une valeur autre"

End Select

'Affichage du Message

MsgBox "Après SELECT CASE on a :" & vbCrLf & Message

End Sub

Essayer avec plusieurs valeurs de A… J

NOUVELLE INSTRUCTION CLASSIQUE : INPUTBOX

InputBox est une instruction classique, mais en pratique à utiliser rarement, car tomber en peu en désuétude due à la programmation dit “ objet ” beaucoup plus souple. Sauf, que dans cette initiation ont l’utilisera régulièrement pour se simplifier la vie…

Le concept “ d’objet ” sera évoqué par la suite pour la manipulation d’Excel, mais qu’un peu… L. Je reviendrai sur ce point... J

Et puis, on verra un petit frère à cette instruction… je ne vous en dis pas plus… mais on fera un pas vers la découverte du VBA…

Commençons par découvrir cette instruction…

A quoi cela sert-il ?

L’instruction InputBox sert à demander à l’utilisateur de rentrer une information, saisie au clavier, qui sera stockée dans une variable.

La syntaxe :

InputBox ( prompt [, title] [, default] [, xpos] [, ypos] [, helpfile, context] )

Comme pour Msgbox, on retrouve des rubriques identiques qui ont strictement les mêmes significations. Ainsi on a déjà vu :

Prompt : représente le message à afficher.

Title : représente le titre de la boite de dialogue. Par défaut c’est le nom de l’application.

Helpfile : représente le chemin et le nom du fichier d’aide qu’on peut associer à la boite de dialogue.

Context : est un repère dans le fichier d’aide ci-dessus, pour afficher qu’une rubrique spécifiée.

Les autres ont les significations suivantes :

Default : représente une valeur par défaut prédéfinie par le programmeur à l’ouverture de la boite de dialogue.

Xpos et Ypos : Représentent respectivement l’abscisse et l’ordonnée sur l’écran où la boite doit s’afficher. Par défaut, la boite sera centrée, ce qu’on fait en général.

Pour utiliser la valeur saisie par l’utilisateur, on procédera comme précédemment avec MsgBox, c'est-à-dire qu’on a recours à une variable.

Voyons cela sur un exemple…

Exemple :

Sub Test_InputBox()

'Demande INPUTBOX

Reponse = InputBox("JE suis le prompt", "Je suis le titre", "Facile")

'Affichage REPONSE

If Reponse = "" Then

MsgBox "Aucune valeur"

Else

MsgBox "La réponse vaut : " & Reponse

End If

End Sub

Illustration :

Illustration de la boite de dialogue InputBox

Normalement, il est assez facile de comprendre le fonctionnement tant que les points communs avec les explications précédentes sont nombreux… J Par conséquent, je ne développe pas davantage…

Néanmoins, remarquons que tant qu’on n’a pas appuyé sur un des boutons, l’exécution est suspendu et l’application où s’exécute ce code (ici Excel) est bloqué. IL n’est plus possible de cliquer sur une option ou d’utiliser un menu. Ce comportement est normal, et porte même un petit nom : on dit que la fenêtre est “ modal ”. Il faut donc obligatoirement répondre quelque chose, pour que l’exécution reprenne... c’était d’ailleurs aussi le cas avec MsgBox… J

Une syntaxe alternative…

Jusqu’à maintenant on a toujours écrit les paramètres d’une instruction en respectant l’ordre des options. Ainsi si on veut écrire dans InputBox uniquement le prompt et la valeur par défaut, on fait :

InputBox("JE suis le prompt", , "Facile")

donc on laisse l’emplacement pour le titre vide… emplacement vide, mais présent ! et on ne peut pas les rentrer dans le désordre !

IL existe une autre façon de faire, qui consiste à nommer les rubriques. Pour cela, il suffit d’écrire le nom de la rubrique suivie de “ := ” et de sa valeur…

Par exemple pour la ligne de code ci-dessus on aurait pu l’écrire ainsi :

InputBox(Default:="Facile", Title:="Je suis le titre", Prompt:="JE suis le prompt")

C’est un principe général d’écriture des arguments. Et donc on peut faire la même chose avec MsgBox… n’est-ce pas qu’elle est riche cette instruction ! J

On peut également cumuler les deux formes de syntaxe. Par exemple :

InputBox("JE suis le prompt", Default:="Facile", Title:="Je suis le titre")

Ici le prompt n’est pas nommé, mais son emplacement permet la reconnaissance de son type.

Une autre instruction InputBox… sous Excel uniquement !

Vu que InputBox a un comportement modal, on peut se poser la question : existe-t-il un moyen d’interagir avec Excel avec un InputBox ? ou en d’autres termes existe-t-il une instruction plus adaptée… ?

La réponse est oui ! … c’est le petit frère que j’évoquais plus haut. Découvrons cela directement sur un exemple équivalent…

Exemple :

Sub Test_Application_InputBox()

'Demande INPUTBOX

Reponse = Application.InputBox(Prompt:="JE suis le prompt", Title:="Je suis le titre", Default:="Facile", Type:=0)

'Affichage REPONSE

If Reponse = "" Then

MsgBox "Aucune valeur"

Else

MsgBox "La réponse vaut : " & Reponse

End If

End Sub

Et vous remarquerez que vous pouvez ouvrir en arrière plan les menus… bien sur, beaucoup sont grisés, mais non bloqués! J

Avec le curseur de la souris, vous pouvez également sélectionner une plage de cellule qui sera automatiquement inscrite dans la boite de dialogue. Chose totalement impossible avec la première présentation. Voici une illustration :

Illustration Application.InputBox

J’ai présenté cette “ nouvelle forme ” un peu par la fin ! J mais ce n’est pas sans raison…

Que remarquez-vous entre les deux programmes ? vous n’avez qu’une minute… M

ö Votre langue au chat ?

On remarque dans le premier cas, qu’on a utilisé la syntaxe : Reponse = InputBox(…)

et dans le second : Reponse = Application.InputBox(…)

que signifie donc “ Application ” ?

Point sur VB et VBA : ouvrez une parenthèse…

Simple ! Application désigne ici Excel, car on lance le code sous Excel. Application aurait désigné Word sous… Word ! etc… Rappelez-vous dans VBA, le A signifie aussi Application ! En d’autres termes, on utilise une instruction propre à Excel via VB. Le but de ce type d’instruction n’est pas de supplanter Visual Basic, mais permettre une manipulation spécifique de l’application. Donc le VBA est en quel que sorte plus riche que VB puisqu’il se compose des instructions de VB et d’autres spécifiques à l’application où il s’exécute…

Bien sur, l’intégralité des instructions de VB n’est pas reprise en VBA. En général, les instructions qui ne sont pas présentes sont celles qui font redondances avec celles utilisables avec l’application. Par exemple, certaines instructions graphiques du VB pour faire des traits ( .Line ) n’existent pas, mais on trouve leurs équivalents en VBA au sujet des graphiques.

Voilà, cet éclaircissement vise à éviter les confusions qu’on rencontre fréquemment chez les débutants. Fermez la parenthèse… J

Poursuivons…

Maintenant, on pourrait expliquer la syntaxe complète de Application.InputBox, mais son explication précise fait appel à la notion de type de donnée spécifique à Excel, non encore évoqué. Donc, pour l’instant mettons-la de côté… nous y reviendrons… J

REALISER UNE BOUCLE

A quoi cela sert-il ?

Jusqu’à maintenant, les quelques instructions que nous avons étudiées permettent une programmation dite “ linéaire ”. C'est-à-dire qu’on suit le déroulement du programme du début jusqu’à la fin, éventuellement en sautant une partie grâce à IF ou à SELECT CASE, par exemple. En pratique, ce type de déroulement basique constitue les briques élémentaires d’une programmation, mais ne permet pas de traiter la majorité des problèmes. Une première sophistication, encore basique mais essentiel, consiste à répéter d’une partie du codage : “ faire une boucle ”.

Pour illustrer classiquement l’utilité d’une boucle, il suffit d’imaginer les problèmes suivants qui ne peuvent pas se résoudre sans répétition :

Lors d’une demande de saisie d’un nombre avec l’instruction InputBox, tant que l’utilisateur ne rentre pas un nombre, on lui repose la même question…

On veut calculer les valeurs successives d’une fonction mathématique…

On veut tester si parmi les cellules d’une feuille Excel, on retrouve une valeur spécifique… il faut donc se déplacer de cellule en cellule et tester à chaque fois si la valeur est celle recherchée…

On veut connaître tous les fichiers présents dans un répertoire…

… ce sont des exemples qu’on peut multiplier à l’infini…

Pour réaliser une boucle, on dispose de plusieurs instructions possibles, tous plus ou moins concurrentes… Nous verrons en détail que deux instructions permettant de tout faire. Les autres instructions possibles (qui ne donnent rien de plus) serons évoquées brièvement.

Commençons avec une boucle très classique…

La boucle FOR... TO… NEXT

La syntaxe minimale :

FOR (Variable) = (début) TO (fin)

…

(instructions)

…

NEXT

Comme déjà dit, n’hésitons pas à traduire en français, soit :

FOR (POUR)… TO (A)… NEXT (SUIVANT).

Comment ça marche ?

La boucle FOR incrémente d’une unité la (Variable) numérique à chaque passage en partant de la valeur (début) jusqu’à (fin) en boucle. La fin de la boucle est marquée avec NEXT.

Schématiquement, les étapes sont les suivantes :

1. (Variable) prend la valeur (début), soit (Variable) = (début)

2. Si (Variable) dépasse (fin) alors on sort au point 6,

3. on exécute les instructions jusqu’à NEXT

4. on incrémente (variable) d’une unité, soit (Variable) = (Variable) + 1

5. on retourne au point 2,

6. Fin.

Voyons tout cela sur un exemple…

Exemple

Sub BoucleFOR()

'Boucle

For A = 1 To 7

MsgBox A

Next

'Dernier message

MsgBox "On vient de voir les valeurs successives de A" & _

vbCrLf & "et maintenant en fin de boucle, A vaut : " & A

End Sub

Donc à chaque passage, on affiche les valeurs que prend la variable A. Ici A prend successivement les valeurs de 1 à 7. Après la boucle, la valeur de A vaut 8. On comprend parfaitement pourquoi en regardant les étapes de fonctionnement plus haut.

Illustration

Faisons un autre petit aparté… Le pseudo code : juste une évocation…

Sur cet exemple, la traduction (en français) du code aurait été :

· POUR (FOR) A allant de 1 A (TO) 7

· Affiche A

· Prend la valeur SUIVANTE (NEXT)

· Affiche “ On vient de voir les valeurs successives de A et maintenant en fin de boucle, A vaut : ” valeur de A

Cette façon de traduire schématise la programmation. Evidemment sur cet exemple très court, c’est un peu trivial. Si on synthétise davantage l’écriture avec des symboles, par exemple : A <- A+1 pour dire qu’on incrémente A, on arrive à ce qu’on appelle un “ pseudo code ”.

Le “ pseudo code ” est une technique pour aider à l’écriture d’un programme. On parle aussi de “ pseudo langage ”, car à partir de celui-ci, on peut programmer avec tous les langages de programmation. En effet, les fonctions de base sont quasiment identiques quelle que soit le langage utilisé…

Poursuivons la découverte de FOR TO NEXT… J

La syntaxe complète

FOR (Variable) = (début) TO (fin) STEP (pas)

…

(instructions)

…

NEXT

La différence ?

On a juste rajouté l’option STEP, qui sert à définir un pas d’incrémentation. Par défaut, celui-ci vaut 1, mais on peut fort bien définir une autre valeur.

Reprenons le petit exemple précédent mais avec un pas de 2…

Sub BoucleFOR()

'Boucle

For A = 1 To 7 Step 2

MsgBox A

Next A

'Dernier message

MsgBox "On vient de voir les valeurs successives de A" & _

vbCrLf & "et maintenant en fin de boucle, A vaut : " & A

End Sub

Ici A prend les valeurs successivement 1, 3, 5, 7, 9… et 11 en fin de boucle.

Devinette. Et si vous essayez avec un pas de 5.5, qu’elles seraient les valeurs pour A ? J

Essayez…

Peut-on utiliser un pas négatif ?

Oui. IL suffit de mettre une valeur négative… Donc on “ décrémente ” au lieu “ d’incrémenter ”. Mais dans ce cas, pour que FOR fonctionne, il faut aussi inverser les bornes. Ensuite le principe est strictement identique que celui évoqué plus haut.

Exemple

Sub BoucleFOR()

'Boucle

For A = 7 To 1 Step -1

MsgBox A

Next A

'Dernier message

MsgBox "On vient de voir les valeurs successives de A" & _

vbCrLf & "et maintenant en fin de boucle, A vaut : " & A

End Sub

Une petite différence !

Une autre différence, mais très bien caché… C’est avec NEXT !

En effet, dans le tout premier code on a écrit : NEXT tout court, or dans ces deux derniers exemple on écrit NEXT (Variable) , soit NEXT A. On a donc rajouté le nom de la variable qu’on a utilisé avec FOR.

En réalité, il n’y a aucune différence de fonctionnement entre les deux syntaxes. Le seul intérêt est encore une fois, pour le programmeur, pour un meilleur repérage. Cela est surtout utile lorsqu’on imbrique plusieurs instructions FOR… Nous allons voir cela un peu plus loin.

… mais avant poursuivons nos petites investigations sur le fonctionnement…

Comment sortir de la boucle FOR avant la fin ?

Pour sortir d’une boucle FOR, on dispose de l’instruction EXIT FOR qui force l’exécution à aller immédiatement après NEXT.

Exemple

Sub BoucleFOR()

'Boucle

For A = 7 To 1 Step -1

MsgBox A

If A = 3 Then Exit For

Next A

'Dernier message

MsgBox "On vient de voir les valeurs successives de A" & _

vbCrLf & "et on est sortie avec Exit For quand A=3, et A vaut : " & A

End Sub

Et si on calculait avec la variable de la boucle… ?

On a compris que la variable numérique utilisé avec FOR, est une variable comme une autre. Par conséquent, il est possible de calculer avec celle-ci.

Par exemple, la table des 3 donne :

Sub BoucleFOR()

'La table des 3

For A = 1 To 10

MsgBox "3 fois " & A & " vaut " & 3 * A

Next A

End Sub

Jusqu’ici tout va bien !

On n’agit pas sur la valeur de A… Seul FOR incrémente sa valeur. En définitive, on se contente de la lire. Si maintenant on change la valeur de A en cours d’exécution, que se passe-t-il ?

Par exemple, si on double A à chaque passage, et qu’on affiche sa valeur…

Sub BoucleFOR()

For A = 1 To 10

A = 2 * A

MsgBox A

Next A

End Sub

Les valeurs prises sont alors 2, 6 et 14. Donc rien de compliquer, si vous avez compris le fonctionnement… La boucle FOR utilise la valeur courante de A, et ici on l’augmente “ artificiellement ” dans le code en plus de son incrémentation. Si on explicite les étapes :

Au début A=1 qui est multiplié par 2 soit A=2,

FOR incrémente A, soit A=2+1=3 (3 < 10), qui est multiplié par 2 soit A=6,

FOR incrémente A, soit A=6+1=7 (7 < 10), qui est multiplié par 2 soit A=14,

FOR incrémente A, soit A=14+1=15, comme 15 > 10, on sort après NEXT.

Mais agir sur la variable d’une boucle ne se fait pas sans une maîtrise de ce que l’on fait !

En effet dans l’exemple précédent, si au lieu de doubler A, on divise A par 2… que se passe-t-il ?

Exemple :

Sub BoucleFOR()

For A = 1 To 10

A = A / 2

MsgBox A

Next A

End Sub

Essayez.

ET… là !? vous venez de découvrir une boucle sans fin ! … & Bref, l’horreur absolu !! autant pour le programmeur, que pour l’utilisateur… Ah, bah… bravo ! L

En plus, pour sortir de cette impasse, il n’est pas possible de stopper l’application à cause du fonctionnement modal de Msgbox ! … encore bravo ! L

IL vous reste que les grands moyens : CRTL + ALT + SUPPR… et faire Fin de tâche… L

Mais gardez le sourire, on passe tous par là… sauf, qu’en plus je vous guide… enfin… J

Retenons cette règle d’or : Si je travaille avec la variable d’une boucle et que j’en change sa valeur, je dois faire très attention !

Imbrication de boucles

L’imbrication d’une boucle veut simplement dire faire une boucle dans une boucle. L’étude d’un exemple devrait suffire… Générons les tables de Pythagore (de multiplication) de 1 à 3, des onze premiers éléments.

Sub Table()

For i = 1 To 3

For j = 0 To 10

MsgBox i & " x " & j & " = " & i * j

'Next j

'Next i

Next j, i

End Sub

Une petite subtilité syntaxique : Lorsqu’on ferme plusieurs boucles, on peut soit les fermer une par une (c’est Next j et Next i mis en remarque), soit toutes avec un seul NEXT mais dans ce cas il faut citer obligatoirement les variables (ici : Next j, i ).

Une autre remarque : On ferme toujours en premier la dernière boucle, puis en remontant, l’avant dernière boucle, etc… En clair, sur cet exemple, on ne pourrait pas fermer la boucle i, avant la boucle j… donc Next i, j causerait une erreur, du reste, signalée par VB.

Voilà, je crois avoir fait le tour… J Passons à la suivante : la boucle avec DO…

La suite la prochaine fois…

ANNEXE

Listes des constantes intégrées dans MS Office

Sur le site de Microsoft, à l’adresse http://support.microsoft.com/kb/q112671/ vous pouvez télécharger un classeur Excel inventoriant les constantes intégrées dans les applications d’Office Version 97 (Excel 97, Outlook 97, Access 97, PowerPoint 97, Office Binder 97, Word 97, Visual Basic, Office 97 et Excel 5.0 & 7.0). Ces listes se sont un peu allongées depuis avec les versions plus récentes, mais cela donne tout de même une base utile…

Vous pouvez également télécharger directement ce classeur ici : CONSTANT.XLS (432 Ko)