Cours gratuits » Cours informatique » Cours programmation » Cours visual basic » Cours générale pour débuter la Programmation Visual basic

Cours générale pour débuter la Programmation Visual basic

Problème à signaler:

Télécharger



★★★★★★★★★★3.5 étoiles sur 5 basé sur 1 votes.
Votez ce document:

Variables et expressions

Le code de ce Projet bonus met en œuvre des déclarations de variables, des instructions d’affectation et des expressions. Maintenant que vous êtes en mesure de concevoir une feuille et d’utiliser divers contrôles, vous devez vous attaquer aux subtilités du code et apprendre à activer les contrôles de l’application à l’aide d’instructions Visual Basic. Cela commence par le traitement des données.

Le Listing PB2.1 illustre les concepts étudiés au Chapitre 5. Afin que vous puissiez vous concentrer sur le code, aucune feuille visuelle n’y est décrite. Si toutefois vous voulez créer une feuille pour tester le code, il suffit de créer une feuille simple contenant trois labels, lblGrossPay, lblTaxes et lblNetPay, ainsi qu’un bouton de commande cmdCalcPay qui déclenchera le code. Votre feuille devrait ressembler à la Figure PB2.1. Après avoir effectué quelques calculs, le code affiche les résultats comptables d

ans les trois labels.

Listing PB2.1 : Ce code met en œuvre des variables et des instructions d’affectation

•    1:  Private Sub cmdCalcPay_Click()

•    2:  ‘ Calcule les trois variables de la paye.

•    3:     Dim intHoursWorked As Integer

•    4:     Dim sngRate As Single, sngTaxRate As Single

•    5:     Dim curTaxes As Currency, curGrossPay As Currency

•    6:     Dim curNetPay As Currency • 7:

•    8:     ‘ Initialise les variables

•    9:     ‘ (En réalité, ces données viendraient de

Partie II

Listing PB2.1 : Ce code met en œuvre des variables et des instructions d’affectation (suite)

•    10:    ‘  l’utilisateur ou d’un fichier).

•    11:    intHoursWorked = 40     ‘ Total des heures travaillées.

•    12:    sngRate = 7.8           ‘ Paye par heure.

•    13:    sngTaxRate = 0.42       ‘ Pourcentage de prélèvements.

•    14:

•    15:    ‘ Calcule les sommes

•    16:    curGrossPay = intHoursWorked * sngRate

•    17:    curTaxes = sngTaxRate * curGrossPay

•    18:    curNetPay = curGrossPay - curTaxes • 19:

•    20:    ‘ Affiche les résultats dans les labels

•    21:    lblGrossPay.Caption = curGrossPay

•    22:    lblTaxes.Caption = curTaxes

•    23:    lblNetPay.Caption = curNetPay

•    24: End Sub

Figure PB2.1 Vous pouvez créer une feuille simple pour tester ce code.

Analyse

Les lignes 1 et 24 sont les lignes d’encadrement de la procédure événementielle du bouton de commande. Les lignes 2, 8, 15 et 20 sont des commentaires qui facilitent la documentation et la maintenance du code. Les lignes 3 à 6 déclarent les variables. Trois de ces variables sont de type Currency.

Les lignes 11, 12 et 13 affectent des valeurs aux trois variables. En situation réelle, ces données comptables seraient fournies par l’utilisateur, voire reprises d’un fichier. Mais vous n’avez pas encore étudié les entrées utilisateur ni la manipulation de fichiers ; du

 140

Projet bonus 2 : Variables et expressions

reste, les instructions d’affectation se prêtent bien à notre exemple. Notez que, lorsqu’un littéral est affecté à une variable de type Integer (ligne 11), il n’y a pas de virgule décimale. En revanche, les valeurs assignées aux variables Single (lignes 12 et 13) contiennent de telles virgules.

Les lignes 16, 17 et 18 effectuent le calcul de la paye. Les expressions étant courtes, l’ordre des opérateurs n’a pas d’importance. Vous pouvez constater que ces expressions contiennent des types de données différents ; toutes ces données sont pourtant compatibles entre elles.

Enfin, les lignes 21, 22 et 23 affectent les valeurs de variables aux labels. Une fois les valeurs affectées, les contrôles de la feuille se mettent à jour et les labels affichent les résultats.

L’instruction d’affectation ne fait que "copier" le contenu de l’expression située à droite du signe = dans la variable ou le contrôle situé à gauche. Le contenu de l’expression n’est pas déplacé. Par exemple, une fois que la ligne 21 s’est exécutée, la variable curGrossPay contient toujours sa valeur, mais cette valeur est également présente dans la propriété Caption du label.

 


 


Opérateurs et instructions de contrôle

Ce chapitre traite encore des opérateurs Visual Basic, mais les opérateurs que vous allez étudier ne servent pas aux calculs mathématiques. Il s’agit d’opérateurs logiques et conditionnels destinés à comparer les données. Vous découvrirez également des instructions de contrôle grâce auxquelles vos programmes répéteront une section de code autant de fois que nécessaire, et interrogeront diverses conditions.

Voici ce que nous étudierons aujourd’hui :

 les opérateurs conditionnels qui permettent d’interroger les données ;

 les opérateurs logiques qui permettent de combiner les opérateurs conditionnels ;

 l’instruction If ;

 les boucles et leur utilité ;

 la différence entre les quatre types de boucles Do ;  la différence entre les boucles For et Do.

Les opérateurs conditionnels

Imaginons que vous ayez à écrire une application comptable. Cette application doit totaliser l’ensemble des sommes dues à chaque fournisseur, puis imprimer le chèque. Mais qu’en est-il des fournisseurs avec lesquels la société n’a pas réalisé d’affaires depuis la dernière session de paiement ? Le programme doit-il imprimer un chèque de 0,00 F ? Evidemment non. Toutes les procédures que nous avons étudiées jusqu’ici se contentaient d’exécuter une instruction après l’autre. Grâce aux opérateurs conditionnels et aux instructions connexes que nous allons découvrir, vos programmes pourront modifier l’ordre d’exécution des instructions selon les données en présence. Ainsi, l’application comptable n’imprimerait de chèques que pour les fournisseurs auxquels vous devez de l’argent.

Le Tableau 6.1 présente ces nouveaux opérateurs Visual Basic. A la différence de ceux que nous avons étudiés au chapitre précédent, aucun de ces opérateurs n’effectuent d’opérations mathématiques. Il s’agit d’opérateurs conditionnels qui comparent les données. Grâce à eux, vos programmes Visual Basic seront plus intelligents. En comparant et en analysant les résultats, le programme peut décider par lui-même, et sur la seule base des données qui lui sont fournies, de ce qu’il convient de faire. En incluant à vos programmes opérateurs et instructions conditionnels, vous laissez Visual Basic décider, lors de l’exécution, quelles sont les instructions à exécuter.

Les opérateurs conditionnels permettent de comparer une valeur à une autre. Grâce aux opérateurs conditionnels, vous savez si une valeur est plus petite, plus grande qu’une autre ou lui est égale.

Tableau 6.1 : Visual Basic supporte six opérateurs conditionnels

Opérateur

Description

Exemple

Résultat

=

Egal à

7 = 2

False

Supérieur à

6 > 3

True

Inférieur à

5 < 11

True

>=

Supérieur ou égal à

23 >= 23

True

<=

Inférieur ou égal à

4 <= 21

True

<> 

Différent de

3 <> 3

False

Remarquez, dans le Tableau 6.1, la colonne des résultats. Quel est le résultat de 6 > 3 ? Est-ce que 6 est plus grand que 3 ? Oui, et le résultat de l’expression conditionnelle est donc "vrai", True. Comme nous l’avons vu au chapitre précédent, Visual Basic supporte le type de données Boolean, qui n’accepte que les valeurs True ou False. Les mots clés True et False sont utilisés dans le code pour affecter des valeurs aux variables booléennes et aux propriétés de contrôles.

Nous avons vu que l’opérateur d’addition était surchargé. C’est également le cas de l’opérateur =. On l’utilise dans les instructions pour affecter des expressions aux variables et aux contrôles. On l’utilise aussi pour des comparaisons d’égalité. Visual Basic fait la distinction entre les deux en fonction du contexte dans lequel l’opérateur = apparaît.

Avant d’employer ces opérateurs dans votre code, assurez-vous d’en comprendre le fonctionnement. L’expression 23 >= 23 est True parce que 23 est supérieur ou égal à 23. Etudiez la colonne des résultats du Tableau 6.1 pour bien saisir ce concept.

Les littéraux ne sont pas les seules valeurs qui puissent apparaître de chaque côté d’un opérateur conditionnel. C’est aussi le cas des expressions, des variables, des contrôles et des combinaisons de tous ces éléments. Visual Basic traite de multiples types de données, et vos programmes doivent tester et comparer les données avant d’exécuter le code le plus approprié.

La présence d’une valeur Null d’un côté ou de l’autre d’un opérateur conditionnel constitue un cas particulier. Car Visual Basic ne renvoie alors, comme résultat de la condition, ni True ni False, mais Null. Vous devez être attentif à ce que l’une des valeurs comparées puisse être Null. Dans ce cas, trois résultats sont possibles : True, False et Null. Parce que de tels résultats peuvent être déroutants, Visual Basic dispose d’un outil appelé fonctions internes, qui aide à détecter les valeurs Null ; vous étudierez cet outil au Chapitre 8, "Sous-routines et fonctions". Notez que les opérateurs conditionnels considèrent toute valeur Empty (correspondant à un contrôle ou à une variable qui n’a pas encore été initialisé par quelque valeur que ce soit) comme égale à zéro, ou comme une chaîne nulle si ce sont des chaînes que l’on compare.

Les opérateurs conditionnels comparent les chaînes exactement de la même manière que les valeurs numériques. Les comparaisons de chaînes suivent ces règles générales :

 Les lettres capitales valent moins que les minuscules ; ainsi, "BONJOUR" vient avant "bonjour".

 Les lettres se comparent selon l’ordre alphabétique ; ainsi, "A" vaut moins que "B", et le nom "Walter" passe avant le nom "William".

 Les nombres valent moins que les lettres ; ainsi, "3" est plus petit que "trois".

Si ces règles vous semblent obscures, rassurez-vous : Visual Basic compare la plupart des chaînes en suivant le même ordre que votre carnet d’adresses. Cette capacité à comparer les chaînes permet à vos programmes de classer les noms par ordre alphabétique, de tester les mots de passe, et d’analyser les données.

Une instruction spéciale peut apparaître dans la section de déclarations d’un module :

Option Compare Text

Cette instruction, éventuellement associée à l’instruction OptionExplicit, étudiée au chapitre précédent, a pour effet que les capitales et les minuscules sont égales en comparaison. Si vos comparaisons ne doivent pas tenir compte du style, incluez l’instruction OptionCompareText dans votre module. Cependant, un programme qui ne tient pas compte du style dans ses comparaisons ne donnera pas, dans la plupart des cas, un classement alphabétique fiable.

Pour la comparaison des chaînes, Visual Basic suit l’ordre prescrit par la table ASCII — à moins que le module ne contienne l’instruction Option Compare Text.

La table ASCII (prononcer "aski") contient la liste de tous les caractères disponibles sur le PC, et attribue un numéro unique à chacun de ces caractères. La valeur ASCII de la lettre "A" est 65, celle de la lettre "B" 66, etc.

Recherchez "ASCII" dans l’index de l’aide Visual Basic pour obtenir cette table (voir Figure 6.1). L’Annexe C de cet ouvrage reproduit également la table ASCII.

Voici quelques exemples de comparaisons de chaînes :

•    "abcdef" > "ABCDEF"

•    "Oui !" < "Oui ?"

•    "Bill vous regarde" = "Bill vous regarde"

•    "PC" <> "pc"

•    "Merci, Merci, Merci" >= "Merci, Merci"

Chacune de ces comparaisons de chaînes renvoie le résultat True.

Visual Basic supporte un autre opérateur conditionnel, Like, qui compare les valeurs sur la base de caractères génériques, ou "jokers". Vous avez sans doute déjà eu affaire aux jokers * et ? en travaillant sur des fichiers. Ainsi, * symbolise n’importe quel nombre de caractères (zéro inclus), tandis que ? symbolise un seul caractère. Like reconnaît un

Figure 6.1

Pour la comparaison des chaînes, Visual Basic suit l’ordre des codes ASCII. troisième joker, #, qui symbolise tout chiffre. Nous vous donnons ci-dessous quelques exemples d’utilisation de Like. Les expressions conditionnelles suivantes renvoient toutes le résultat True :

•    "Simon & Schuster Macmillan" Like "Si*"

•    "Qtr???" Like "QtrOne"

•    "Total##" Like "Total98"

•    "X" Like "[XYZ]"

Le dernier exemple relève d’un type spécial d’expression Like. Lorsque le caractère correspond à l’un des caractères entre crochets, le résultat renvoyé est True. Les crochets permettent d’interroger une série de caractères. Comparées à la chaîne

"Code[12345]Rouge", les valeurs suivantes sont toutes True : "Code1Rouge", "Code2Rouge", "Code3Rouge", "Code4Rouge", "Code5Rouge".

En réalité, vos programmes Visual Basic compareront des variables et des contrôles dont le contenu est appelé à changer dans le cours de l’exécution. Les exemples ne comparent que des littéraux afin d’illustrer le fonctionnement des opérateurs.

Pour ces expressions, l’opérateur = aurait renvoyé la valeur False, car la condition d’égalité ne reconnaît pas les jokers.

Les données conditionnelles

Les valeurs comparées doivent toujours relever de types de données compatibles. Vous pouvez comparer entre eux des nombres de n’importe quels types de données. Vous pouvez comparez entre eux des chaînes ou des booléens. Mais vous ne devez jamais, par exemple, comparer une chaîne à un nombre, car le résultat risquerait fort d’être faux.

Les données de types Boolean, Currency, String, Date, et les différents entiers (Byte, Integer et Long) peuvent être comparés entre eux et répondre à une condition d’égalité. Ce n’est pas le cas des valeurs à précision simple ou double, comme dans sngSales =sngGoal. A cause de la façon dont Visual Basic stocke les données de précision, la comparaison de deux valeurs Single peut renvoyer un résultat d’inégalité ; en effet, Visual Basic arrondit de lui-même les valeurs, ce qui fausse les résultats. Pour tester l’égalité de deux variables de précision, il faut soustraire l’une de l’autre et mesurer la différence. De telles opérations s’avèrent assez fastidieuses, aussi vaut-il mieux les éviter.

Le type de données Variant se prête plutôt bien aux comparaisons conditionnelles. Vous aurez souvent à comparer la valeur d’un contrôle (une zone de texte, par exemple) à une variable ou à un littéral. Les propriétés de contrôles se comparent généralement comme des données Variant. Si un contrôle ou une variable Variant contiennent une valeur numérique, telle que 234.56, et que vous compariez cette valeur à une variable numérique, Visual Basic procède en convertissant provisoirement la valeur Variant en nombre. Si, en revanche, vous comparez un contrôle ou une variable Variant à une chaîne, Visual Basic convertit provisoirement la valeur en chaîne, de sorte que la comparaison se fasse caractère par caractère, sur la base des codes ASCII. Ainsi, Visual Basic se charge des détails importuns qui, autrement, rendraient délicates les comparaisons impliquant un type Variant.

Si vous comparez une valeur numérique à une valeur Variant, et que cette dernière ne puisse être proprement convertie en nombre, Visual Basic générera une erreur d’exécution. Faites attention aux données utilisées. Les fonctions internes, dont nous parlerons au Chapitre 8, permettent d’interroger les types de données.

Combinaison d’opérateurs conditionnels et logiques

Techniquement, les six opérateurs conditionnels suffisent à interroger n’importe quelle condition. Mais on peut considérablement améliorer leur flexibilité en les combinant aux opérateurs logiques Visual Basic. Le Tableau 6.2 présente ces opérateurs.

Les opérateurs logiques permettent de combiner plusieurs séries de comparaisons conditionnelles. A l’instar de l’opérateur Mod, les opérateurs logiques sont des mots clés, et non des symboles.

Tableau 6.2 : Visual Basic supporte quatre opérateurs logiques

Opérateur

Description

Exemple                           Résultat

And

Chaque terme de l’expression doit être True

(2 < 3) And (4 < 5) True

Or

L’un des deux termes doit être True

(2 < 3 ) Or (6 < 7) True

Xor

Seul l’un des termes doit être True

(2 < 3) Xor (7 > 4) False

Not

Nie l’expression

Not (3 = 3)                                   False

Les opérateurs And et Or sont, de loin, les plus utilisés. L’opérateur Xor permet de distinguer deux options s’excluant mutuellement. Ainsi, dans une situation où une seule valeur doit être True, comme lorsque l’utilisateur doit sélectionner son mois de naissance, le résultat False d’une condition Xor indique que plus d’une option (ou aucune) a été sélectionnée. Enfin, l’opérateur Not nie une expression True ou False. Notez que cet opérateur doit être utilisé avec parcimonie, car il implique que l’on fasse abstraction de la logique en écrivant ou en déboguant le code.

L’expression suivante combine à des opérateurs conditionnels l’opérateur logique And :

 (curSales < curMinSales) And (intYrsEmp > 10)

Si le chiffre de vente courant (curSales) est inférieur au minimum requis (curMinSales) et que le nombre d’années d’ancienneté (intYrsEmp) soit supérieur à 10, l’expression est entièrement True (et il y a du licenciement dans l’air !). Il serait tout à fait possible de tester chaque condition séparément, mais l’opérateur And permet de regrouper le tout en une même expression.

Ne combinez pas trop d’expressions conditionnelles avec des opérateurs logiques ; votre code deviendrait confus. Il convient de fragmenter les expressions trop complexes, telles que la suivante :

(a > 6) And (b < 1) Or Not(1 = c) Xor (d = 4)

L’ordre des opérateurs affecte le placement et l’exécution des opérateurs conditionnels et logiques. Considérez l’expression suivante : curSales * sngCommission > curHighSales / 10

Quelles opérations Visual Basic traitera-t-il en premier ? Va-t-il d’abord comparer sngCommission à curHighSales pour ensuite multiplier le résultat par curSales, puis diviser ce dernier résultat par 10 ? Cela n’aurait aucun sens, puisque l’opérateur > ne peut renvoyer de résultats que True ou False, et qu’un tel résultat ne peut être impliqué dans un calcul mathématique.

Le Tableau 6.3 expose l’ordre des opérateurs de façon plus complète que le chapitre précédent. Il décrit le fonctionnement conjoint des opérateurs conditionnels et logiques contenus dans une même expression.

Tableau 6.3 : Ordre de préséance des opérateurs mathématiques, conditionnels et logiques

Priorité

Opérateur

1

Parenthèses

2

^

3

*, /, \, Mod

4

+,–

5

Opérateurs conditionnels tels que Like

6

Not

7

And

8

Or

9

Xor

Afin que vos programmes soient aussi clairs que possible, placez les expressions entre parenthèses ; vous éviterez ainsi toute ambiguïté dans l’ordre des opérations. Selon cette méthode, l’expression présentée plus haut ressemblerait à ceci :

(curSales * sngCommission) > (curHighSales / 10)

Les instructions If

If est l’une des commandes Visual Basic les plus utilisées. La commande If fait partie d’une instruction multiligne, l’instruction If, dont voici le format :

•       If condition Then

•       Bloc d’instructions Visual Basic

•       End If

Ici, condition représente toute expression susceptible de renvoyer un résultat True ou False. Il peut s’agir d’une variable Boolean, d’un contrôle renvoyant une valeur True ou False, ou d’une expression plus longue incluant des opérateurs conditionnels et/ou logiques.

Visual Basic supporte toujours l’ancien format de If, hérité du BASIC, et qui s’écrit sur une seule ligne :

If condition Then instruction

Comme les instructions If donnent presque toujours sur plusieurs instructions, le format multiligne est plus approprié et plus répandu. Même dans le cas où le If ne déclenche qu’une seule instruction, le format multiligne est plus approprié, car des instructions supplémentaires pourront plus facilement être insérées.

Faire

Indentez le corps de l’instruction If, de sorte à repérer d’un simple coup d’œil son début et sa fin. Pour chaque instruction If, il existe, plus loin dans le programme, une instruction End If. Quelle que soit l’indentation du code, une instruction End If correspond toujours à l’instruction If la plus récente.

Sans s’en apercevoir, on emploie des instructions de type If tous les jours :

 Si (If) je reçois mon chèque, alors (Then) je payerai mon loyer dans les temps.

 Si (If) tu ranges ta chambre et (And) que tu finisses tes devoirs, alors (Then) tu sortiras jouer au foot.

Ainsi, les instructions Visual Basic If suivent un mode de raisonnement tout à fait commun. Elles fonctionnent de la manière suivante : le code contenu dans le corps de l’instruction ne s’exécute que si et seulement si la condition est remplie. Considérez de nouveau les raisonnements communs exposés ci-dessus. Si et seulement si vous touchez votre salaire, vous pourrez payer votre loyer à temps. Si vous ne recevez pas le chèque, eh bien votre propriétaire attendra. Le second raisonnement implique que deux conditions soient satisfaites : si tu ranges ta chambre et si tu finis tes devoirs, alors seulement tu pourras aller taper dans le ballon.

Examinez l’instruction If du Listing 6.1 :

Listing 6.1 : Comparaison de données avec instruction If

•    1:  If (curSales > curSalesGoal) Then

•    2:     ’ Ce commercial explose ses objectifs

•    3:     curSalaryBonus = 10000.00

•    4:     lblSalesNote.Caption = "Objectifs explosés !"

•    5:     lblSalesNote.BackColor = Red

•    6:     lblSalesNote.FontBold = True

•    7:  End If

•    8:  ’ Le code continue ici

Si la valeur de curSales (chiffre de vente) est supérieure à la valeur de curSalesGoal (objectifs), les quatre instructions (sans compter le commentaire) des lignes 3 à 6 s’exécutent. Si la valeur est inférieure (ou même égale, le patron est exigeant), les lignes 3 à 6 ne s’exécutent pas. Dans tous les cas, le programme se poursuit à partir de la ligne 8, après que l’instruction If a fait ce qu’elle avait à faire. Ainsi, ce sont les données qui pilotent l’instruction If, et le programme prend une décision lors de l’exécution. Cette décision concerne l’exécution, ou non, d’une partie du code, à savoir le corps de l’instruction If.

Dans une instruction If, les parenthèses ne sont pas nécessaires autour de la condition ; en revanche, elles désignent clairement la condition à interroger, et en cela clarifient le code.

Les instructions Else

Nous venons de décrire un format d’instruction If. Mais les programmeurs emploient souvent un format plus étendu, qui ressemble à cela :

•       If condition Then

•       Bloc d’instructions Visual Basic

•       Else

•       Bloc d’instructions Visual Basic

•       End If

Comme pour toutes les instructions multilignes, l’indentation du corps est recommandée, mais non obligatoire. Selon le premier format d’instruction If, le code s’exécutait si et seulement si la condition était satisfaite ; mais rien n’indiquait au programme ce qu’il devait faire si la condition n’était pas satisfaite. L’instruction Else sert justement à cela. Une instruction If Else contient deux corps distincts : l’un qui ne s’exécute que si la condition est True, l’autre qui ne s’exécute que si la condition est False. Quelle que soit la condition, le reste du programme se poursuit après que le test If Else a été effectué.

Le programme du premier Projet bonus, "Contrôles, propriétés et événements", se servait d’une instruction If Else pour tester la validité du mot de passe saisi. Cette partie du code est reproduite dans le Listing 6.2.

Listing 6.2 : Test du mot de passe par une instruction If

•    1:    If = “SSM” Then

•    2:       ’ Mot de passe correct

•    3:       Beep

•    4:       Beep       ’ Afficher l’image

•    5:       imgPassword.Picture = LoadPicture(“C:\Program Files\”

•    6:         & “Microsoft Visual Studio\Common\Graphics\MetaFile\”

•    7:         & “Business\”)

•    8:     lblPrompt.Caption = “Aboule le fric !”

•    9:    Else

•    10:      lblPrompt.Caption = “Mot de passe incorrect -

         ?Essayer encore ”

•    11:      = “”   ’ Efface le mauvais mot de passe

•    12:      txtPassword.SetFocus    ’ Met le focus sur la zone

         ?de texte

•    23:   End If

La ligne 1 vérifie si la zone de texte contient le bon mot de passe. Si c’est le cas, le corps de l’instruction If, soit à partir de la ligne 2, s’exécute. L’instruction Beep provoque l’émission d’un bip par le haut-parleur du PC ; ainsi, si le mot de passe est correct, les lignes 3 et 4 s’exécutent, et l’ordinateur fait "bip bip". Les lignes 5, 6 et 7 affichent l’image, tandis que la ligne 8 modifie le contenu du label. Au terme de l’instruction If, c’est-à-dire tout de suite après la ligne End If, le programme poursuit son exécution. Si toutefois le mot de passe saisi n’est pas le bon, et donc que la condition ne soit pas remplie, le corps de Else s’exécute (lignes 10, 11 et 12) pour indiquer à l’utilisateur que son mot de passe n’est pas valide.

Comme le montre le Listing 6.3, on peut imbriquer les instructions If.

Listing 6.3 : Les instructions If imbriquées permettent des comparaisons plus poussées

•       If (curSales > 100000.00) Then

•       If (intHrsWorked > 40) Then

•       curBonus = 7500.00•   Else

•       curBonus = 5000.00

•       End If

•       lblBonus.Caption = "Bon boulot !"

•       End If

Dans les instructions ainsi imbriquées, chaque Else et chaque End If renvoie toujours au If le plus récent. Les différents niveaux d’indentation appliqués aux If imbriqués permettent de les circonscrire de façon claire.

Les instructions Exit

Il arrive parfois, selon les données, qu’une procédure (événementielle ou autre) doive être précipitamment interrompue. C’est ce que permet la combinaison des instructions If et Exit.

Voici le format de l’instruction Exit :

Exit Sub/Function/Do/For

Les slash indiquent que seul l’un des mots clés peut suivre l’instruction Exit ; tout dépend de ce dont on veut sortir. Pour sortir d’une procédure événementielle (c’est-à-dire d’une sous-routine, comme nous l’avons vu au Chapitre 4), l’instruction est Exit Sub.

Pour sortir d’une fonction, ce serait Exit Function. Quant aux instructions Exit Do et Exit For, elles seront expliquées vers la fin de ce chapitre.

Le Listing 6.4 interrompt la procédure événementielle à la ligne 3 si la condition spécifiée dans l’instruction If est satisfaite.

Listing 6.4 : L’instruction Exit Sub permet d’interrompre une procédure

•    1:  Private Sub cmdCalc ()

•    2:     If ( < 50000.00) Then

•    3:       Exit Sub   ’ Interrompt la procédure

•    4:     Else

•    5:       ’ Si le chiffre de vente est au moins

•    6:       ’ de 50 000 F, exécute l’instruction • 7:       ’ suivante, qui affiche le bonus comme

•    8:       ’ pourcentage des ventes.

•    9:       lblBonus.Caption = * .05

•    10:    End If

•    11: End Sub

Instructions If Else imbriquées

Lorsque deux instructions If Else sont imbriquées l’une dans l’autre, l’instruction intérieure doit utiliser le mot clé ElseIf à la place du simple If. Voyez le Listing 6.5.

Listing 6.5 : Le mot clé ElseIf permet de combiner les instructions If Else

•    1:  If (intHours <= 40) Then

•    2:     curOverTime = 0.0

•    3:  ’ Interroge les heures entre 40 et 50, • 4:  ’ et paye les 50 % d’heures sup.

•    5:  ElseIf (intHours <= 50) Then

•    6:        curOverTime = (intHours - 40) * 1.5 * sngRate

•    7:      Else

•    8:        ’ Au-delà de 50, les heures doivent être payées • 9: ’ doubles  ; entre 40 et 50 heures, la prime

•    10:       ’ est de 50 %.

•    11:       curOverTime = ((intHours - 50) * 2 + (10 * 1.5))

          ?* sngRate

•    12: End If

Une instruction imbriquée est une instruction qui apparaît à l’intérieur d’une autre.

L’instruction ElseIf de la ligne 5 commence un nouveau bloc If Else. La ligne 1 vérifie si le nombre d’heures travaillées (intHours) est inférieur ou égal à 40 ; si tel n’est pas le cas, ce nombre doit logiquement être supérieur à 40. La ligne 5 vérifie si le nombre d’heures est inclus entre 40 et 50 (si le nombre est inférieur à 40, cette ligne ne s’exécute pas). La prime (curOverTime) de 50 % est alors calculée pour les heures supplémentaires. Si la condition de la ligne 5 n’est pas remplie, c’est que nécessairement le nombre d’heures travaillées est supérieur à 50. L’expression de la ligne 11 calcule le paiement à 200 % des heures situées au-delà de 50, et le paiement à 150 % des heures situées entre 40 et 50.

Ces instructions If ElseIf End If imbriquées sont-elles particulièrement difficiles à déboguer ? Certes, et cet exemple simple en est la parfaite illustration. La section suivante décrit les instructions Select Case, qui offrent une solution plus intéressante.

Les instructions Select Case

L’instruction Select Case est la plus appropriée pour vérifier des conditions multiples. L’imbrication successive de trois ou quatre instructions If Else complique considérablement le programme. On aboutit à une logique discutable du genre : "Si cela est vrai, alors si cela est vrai, alors si cela encore est vrai, alors faire cela ou cela, sinon " L’instruction Select Case vous épargne ces imbroglios inutiles. En voici le format :

•       Select Case expression

•       Case condition

•       Bloc d’instructions Visual Basic

•       [ Case condition1

•       Bloc d’instructions Visual Basic]

•       [ Case condition2

•       Bloc d’instructions Visual Basic]

•       :

•       [ Case conditionN

•       Bloc d’instructions Visual Basic]

•       [Case Else

•       Bloc d’instructions Visual Basic]

•       End Select

Select Case choisit entre plusieurs conditions. Le nombre de ces conditions, indiqué dans le corps [ Case condition# ], varie selon la situation. Si aucune des conditions n’est remplie, le corps de Case Else (s’il y en a un) s’exécute.

Malgré un format un peu déroutant, Select Case est simple d’utilisation. Examinez le Listing 6.6.

Listing 6.6 : Les instructions Select Case comparent des valeurs multiples

•    1:  ’ Interrogation d’une note scolaire

•    2:  Select Case

•    3:    Case "A"

•    4:       lblAnnounce.Caption = "Très bien"

•    5:    Case "B"

•    6:       lblAnnounce.Caption = "Bien"

•    7:    Case "C"

•    8:       lblAnnounce.Caption = "Peut mieux faire"

•    9:    Case "D"

•    10:      lblAnnounce.Caption = "Médiocre"

•    11:   Case "E"

•    12:      lblAnnounce.Caption = "Mauvais"

•    13:   Case Else

•    14:      lblAnnounce.Caption = "Note non validée"

•    15: End Select

Le type de données de expression doit être repris par chaque condition de

Case. Le code du Listing 6.6 suppose que est une chaîne contenant une lettre : en effet, c’est bien à une chaîne que les lignes 3, 5, 7, 9 et 11 comparent la valeur de .

Si la zone de texte contient la lettre "A", le corps du Case de la ligne 3 s’exécute, et Visual Basic saute les autres conditions ; puis le code poursuit son exécution à partir de la ligne 15. Si contient la lettre "B", c’est le corps du Case de la ligne 5 qui s’exécute, et ainsi de suite. (Ce n’est pas le cas ici, mais le corps d’un Case peut courir sur plusieurs lignes.) Une fois qu’une condition Case est satisfaite, Visual Basic exécute tout le code compris jusqu’au prochain Case ; lorsque cela est achevé, l’instruction Select Case a fait son travail, et le programme peut continuer.

Si, pour une raison ou pour une autre, la zone de texte renvoie autre chose que A, B, C, D ou E, c’est le Case Else qui s’exécute et affiche dans le label un message d’erreur.

Visual Basic supporte un autre format de Select Case, qui permet de spécifier, par le mot clé Is, un opérateur conditionnel pour chaque condition. Le Listing 6.6 reprend notre exemple en mettant à profit ce format.

Listing 6.7 : Comparaisons conditionnelles dans Select Case

•    1:  ’ Test d’une note scolaire

•    2:  Select Case

•    3:    Case Is >= 18

•    4:       lblAnnounce.Caption = "Très bien"

•    5:    Case Is >= 15

•    6:       lblAnnounce.Caption = "Bien"

•    7:    Case Is >= 12

•    8:       lblAnnounce.Caption = "Peut mieux faire"

•    9:    Case Is >= 10

•    10:      lblAnnounce.Caption = "Médiocre"

•    11:   Case Else

•    12:      lblAnnounce.Caption = "Mauvais"

•    13: End Select

Ici, chaque Case implique que la note se situe entre une valeur supérieure ou égale à 18 et une valeur inférieure ou égale à 10. Notez qu’aucun test spécifique n’est nécessaire pour les notes situées en-dessous de 10 car, en deçà de cette note, c’est le Case Else qui prend la relève. (Comme il ne s’agit que de montrer le fonctionnement de Case Else, cet exemple ne contient pas d’instruction de traitement d’erreur, et suppose donc que la note entrée se situe entre 0 et 20.)

Les instructions SelectCase ne conviennent pas à tous les types de comparaisons. Les opérateurs d’inclusion ou logiques ne sont pas supportés ; les conditions Case ne peuvent donc pas être interrogées par And, Or, Xor, ni Not. Pour cela, la seule solution consiste à imbriquer des instructions If ElseIf EndIf.

Visual Basic supporte un troisième format de Select Case, dans lequel le mot clé To spécifie un ordre de choix. C’est cet ordre qui détermine quel corps de Case doit s’exécuter. Ce format est utilisé lorsque les valeurs testées sont séquentielles (voir Listing 6.8).

Listing 6.8 : Comparaisons de valeurs séquentielles dans Select Case

•    1:  ’ Interrogation d’une note scolaire

•    2:  Select Case

•    3:    Case 0 To 9

•    4:       lblAnnounce.Caption = "Mauvais"

•    5:    Case 10 To 11

•    6:       lblAnnounce.Caption = "Médiocre"

•    7:    Case 12 To 14

•    8:       lblAnnounce.Caption = "Peut mieux faire"

•    9:    Case 15 To 17

•    10:      lblAnnounce.Caption = "Bien"

•    11:   Case Else

•    12:      lblAnnounce.Caption = "Très bien"

•    13: End Select

Vous pouvez remarquer que l’ordre des Case est inversé par rapport aux listings précédents, en raison du format utilisé. La première condition Case, ligne 3, teste la plage des notes les plus basses possible. Si la note renvoyée entre dans cette catégorie, le message "Mauvais" s’affiche dans le label. (Pour plus de simplicité, on présuppose que l’utilisateur entre des entiers. Ainsi, une note de 9.5 pourrait générer une erreur.) Les plages de valeurs se suivent séquentiellement. Vous pouvez également tester, de cette façon, des chaînes, en partant de la plus petite (en codes ASCII cumulés).

On peut combiner les différents formats de Case à l’intérieur d’une même instruction SelectCase. Voici un exemple :

Case 101, 102, 201 To 205, Is > 300

Si l’expression spécifiée dans Select Case renvoie une valeur égale à 101, 102, 201, 202, 203, 204, 205, ou supérieure à 300, le corps de Case s’exécute.

Les boucles

Votre PC est puissant. Il peut traiter rapidement d’énormes quantités de données, telles que la comptabilité d’une grosse entreprise. Mais le traitement efficace de tant d’informations exige une technique spéciale : il s’agit d’intégrer le code dans des boucles, grâce auxquelles le programme analyse, et analyse encore, les données, jusqu’à ce que sortent les résultats attendus. Les boucles sont l’un des éléments les plus importants de la programmation.

Une boucle est une série d’instructions appelées à s’exécuter plusieurs fois. L’instruction de boucle se répète tant qu’une condition prédéfinie n’est pas satisfaite.

Les boucles nous renvoient au prochain chapitre, qui vous enseigne à recevoir de l’utilisateur des entrées (input) autrement que par les zones de texte — lesquelles ne conviennent pas à tous les types d’informations. Il arrive souvent qu’une question simple soit posée à l’utilisateur, qui répond en appuyant sur Entrée ; pour de telles réponses, les zones de texte ne sont pas ce qu’il y a de plus indiqué. (Les zones de texte sont parfaites pour les informations textuelles, telles que noms et adresses.)

Il est capital de bien comprendre les boucles avant d’aborder la question des entrées utilisateur : en effet, la réponse donnée n’est pas toujours celle qu’on attend. Imaginons que vous demandiez à l’utilisateur son âge, et qu’il réponde 291. Manifestement, il y a une erreur. Grâce aux instructions de boucle, la question peut être reposée jusqu’à ce que l’utilisateur donne une réponse raisonnable. Naturellement, le programme ne pourra jamais détermnier si l’utilisateur donne son âge réel ; mais vous pouvez faire en sorte qu’une réponse au moins plausible soit exigée. Les boucles peuvent répéter n’importe quel bloc de code.

Les boucles Do

La boucle Do est une instruction multiligne. Comme l’instruction If, l’instruction Do supporte différents formats :

•       Do While condition

•       Bloc d’instructions Visual Basic

•       Loop

•       Do

•       Bloc d’instructions Visual Basic

•       Loop While condition

•       Do Until condition

•       Bloc d’instructions Visual Basic

•       Loop

•       Do

•       Bloc d’instructions Visual Basic

•       Loop Until condition

Ici, condition peut être une expression, un contrôle ou une valeur Boolean. Le choix du format est, avant tout, une question de préférence et de style. Les points à considérer sont les suivants :

 L’emplacement de la condition. Si la condition apparaît au début de la boucle, dans l’instruction Do, le corps peut aussi bien ne jamais s’exécuter. Si, en revanche, la condition apparaît à la fin de la boucle, dans l’instruction Loop, le corps s’exécutera au moins une fois, puisque la condition n’est interrogée qu’en dernier.

 La nature de la condition. La boucle Do peut se répéter : a) tant que (While) la condition est remplie, b) jusqu’à ce que (Until) la condition soit remplie. Dans le premier cas, le corps cesse de s’exécuter dès que la condition n’est plus remplie. Dans le second, le corps cesse de s’exécuter dès que la condition est remplie.

La Figure 6.2 montre une boucle Do et illustre le processus de répétition. Ce code se contente d’augmenter une valeur (affichée comme Caption du label) par incréments de 1 ; lorsque la valeur de 10 est atteinte, la boucle s’arrête. (En réalité, un PC moderne exécuterait ce programme si rapidement que l’on n’aurait pas le temps de voir les valeurs s’afficher. Il s’agit d’un exemple.)

Figure 6.2 La boucle répète le corps d’instructions.

Ces instructions se

' Démonstration des boucles Do.

Dim intCtr As Integer

IntCtr =  1   ' Initialise le compteur.

répètent jusqu'à ceDo

que la condition lblOut.Caption = intCtr interrogée renvoient     intCtr = intCtr + 1 le résultat True.Loop Until [intCtr = 10]

Le code de la Figure 6.2 illustre un type particulier d’affectation, dans lequel le même nom de variable apparaît de chaque côté de l’opérateur =. Une telle affectation ne sert, en fait, qu’à mettre à jour la valeur de la variable. Dans ce cas précis, l’instruction intCtr =intCtr+1 ajoute 1 à la valeur de intCtr à chaque répétition de la boucle.

Le corps du code de la Figure 6.2 s’exécute dix fois, et chaque fois la valeur de la variable intCtr est incrémentée de 1. Le format utilisé ici est Do Loop Until, de sorte que la boucle se répète jusqu’à ce que intCtr soit égal à 10. Le Listing 6.9 présente une boucle semblable, mais selon le format While Loop.

Listing 6.9 : L’instruction Do existe en plusieurs formats

•    1:  Do While intCtr <= 10

•    2:    ’ Cette boucle fait la même chose

•    3:    ’ que celle de la Figure 6.2

•    4:    lblOut.Caption = intCtr

•    5:    intCtr = intCtr + 1

•    6:  Loop

Vous devez, d’une manière ou d’une autre, modifier la condition contenue dans le corps de la boucle ; autrement, la boucle s’exécuterait indéfiniment. Si d’aventure vous écrivez une boucle sans fin, votre application se bloque jusqu’à ce que vous cliquiez sur le bouton Fin de Visual Basic ou sur le bouton de fermeture de l’application. Si rien, dans le corps de la boucle, ne permet de modifier la condition testée, la boucle continuera de s’exécuter.

Certaines boucles, notamment les boucles impliquant une entrée utilisateur, exigent que le corps s’exécute au moins une fois ; de là découle le choix du format de boucle. Si votre boucle doit s’exécuter au moins une fois, le format à utiliser est celui dans lequel la condition est interrogée à la fin de la boucle (voir Listing 6.10).

Les exemples de codes qui suivent ne sont pas complets. Les instructions censées traiter les entrées utilisateur et envoyer les messages d’erreur y sont remplacées par des commentaires. Concentrez-vous, pour l’instant, sur le fonctionnement des boucles. Le traitement des entrées utilisateur fera l’objet du prochain chapitre.

Listing 6.10 : L’utilisateur n’entre pas toujours des données valides du premier coup

•    1:  Dim strAns As String

•    2:  ’

•    3:  ’ L’utilisateur doit répondre par Oui ou Non.

•    4:  lblPrompt.Caption = "Continuer ? (Oui ou Non)"

•    5:  ’

•    6:  ’ Stockage de la réponse dans la

•    7:  ’ variable chaîne nommée strAns.

•    8:  ’ Test de la réponse et réitération • 9:  ’ de la question si nécessaire.

•    10: Do While (strAns <> "Oui" And strAns <> "Non")

•    11:   Beep    ’ Avertissement

•    12:   lblError.Caption = "Merci de répondre par Oui ou Non"

•    13:   ’ Stockage de la réponse dans la

•    14:   ’ variable chaîne nommée strAns (rebelote).

•    15: Loop

•    16: ’ Effacement du message d’erreur.

•    17: lblError.Caption = Null

La boucle Do commence à la ligne 10. Si l’utilisateur a entré Oui ou Non aux lignes 6 et 7 (rappelez-vous que les commentaires tiennent ici lieu d’instructions de traitement), la boucle affiche le message d’erreur de la ligne 12. Les commentaires des lignes 13 et 14 simulent une instruction qui recevrait de nouveau la réponse de l’utilisateur, et la ligne 15 renvoie la boucle à la ligne 10, qui teste de nouveau l’entrée. Combien de fois cette boucle s’exécutera-t-elle ? Soit jamais (si l’utilisateur a entré Oui ou Non), soit jusqu’à ce que l’utilisateur réponde correctement (non mais !).

Naturellement, la touche Verr Maj de l’utilisateur peut être ou non enclenchée ; et donc la réponse, être OUI ou oui, NON ou non. Dans ce cas, la ligne 10 échouerait, car les deux chaînes auraient des styles différents. Il vous faudra attendre le Chapitre 8 pour apprendre à tester les chaînes différentes.

L’instruction Exit Do permet d’interrompre une boucle avant son dénouement normal. Par exemple, vous traitez une série de factures dans une boucle qui se répète jusqu’à ce que le dernier numéro de compte client soit atteint. Si un mauvais numéro de compte est décelé par une instruction If à l’intérieur de la boucle, vous pouvez interrompre la répétion par Exit Do et afficher un message d’erreur.


135