PAGORA
Présentation
du langage
Visual Basic
Mazen MAHROUS
Table des matières
Table des matières.................................................................................................. page
1
1) Formatage du code et commentaires .......................................................... page 3
2) Types de données et variables ....................................................................... page 3
2. 1) Types de données simples prédéfinis......................................... page 4
2. 2) Affichage sur l'écran .................................................................... page 6
2. 3) Domaine de validité ..................................................................... page 7
2. 4) Les tableaux .................................................................................. page 8
2. 5) Les types et structures de données personnalisés ................... page 10
3) Constantes systèmes et Constantes personnalisées .................................. page 11
4) Les boîtes de dialogue d'entrée et de sortie ............................................... page 11
4. 1) Les messages..................................................................................
page 11
4. 2) Les Boîtes de saisie.......................................................................
page 13
5) Les opérateurs mathématiques ..................................................................... page 14
5. 1) Opérateurs arithmétiques.............................................................
page 14
5. 2) Opérateurs de comparaison.........................................................
page 14
5. 3) Opérateurs logiques ou arithmétiques bit à bit ........................ page 14
6) Instructions de contrôle de l'exécution........................................................ page
15
6. 1) Les instructions de saut GOTO et GOSUB................................ page 15
6. 2) Boucles avec incrémentation.......................................................
page 16
6. 3) Les tests
: (If, Select … Case)......................................................
page 20
7) Procédures et fonctions................................................................................... page
25
7. 1) Fonctions - Des procédures avec valeurs de résultat............... page 25
7. 2) Les procédures...............................................................................
page 28
8) Fonctions prédéfinies....................................................................................... page
30
8. 1) Fonctions mathématiques.............................................................
page 30
8. 2) Fonctions de chaînes de caractères............................................ page 31
8. 3) Fonctions d'heure et de date........................................................
page 34
8. 4) Fonctions de conversion et de formatage.................................. page 37
9) Les fichiers......................................................................................................... page
38
9. 1) Les fichiers séquentiels................................................................
page 38
9. 2) Les fichiers à accès direct............................................................
page 40
9. 3) Les fichiers binaires......................................................................
page 41
10) Instructions de gestion des erreurs d'exécution...................................... page
42
11) Instructions d'impression............................................................................. page
43
Annexes.................................................................................................................... page
45
Visual Basic 6
Comme tout langage de programmation de haut niveau, Visual Basic (VB) impose des règles de codage (d'écriture du texte code) des programmes. Dans cette documentation, les principales instructions sont présentées avec des exemples. La syntaxe de Visual Basic permet une programmation structurée et modulaire.
1)
Formatage du
code et commentaires
Un programme peut être destiné aussi à être lu. Donc, il est important de documenter le plus lisiblement possible le code source avec des commentaires explicatifs et de le formater (VB prend en charge une partie du formatage du code). Un commentaire est précédé d'une apostrophe ou du mot-clé Rem :
· Rem 1er Programme
VB
· 'Auteur : EFPG
· ' Date de la dernière modification : 07/09/2001
On peut combiner les instructions et les commentaires avec rem précédé d'un deux-points ou en utilisant une apostrophe.
· A = 17 : Rem affectation de la variable A
· B = 20 'affectation de la variable B
VB permet de placer plusieurs instructions sur la même ligne, à condition de les séparer par des doubles points (:). Cependant, il est déconseillé d'utiliser cette facilité, car la lisibilité en pâtit.
·
A=10: B=20: For i=1
To 100: x(i)=0: Next i : Rem utilisation d'une boucle
Afin que la ligne de code longue ne disparaisse pas au-delà de la limite droite de la fenêtre ou lors de l'impression, on peut la répartir sur plusieurs lignes (jusqu'à 10). Il suffit de taper un espace à l'endroit où on veut scinder la ligne suivie du caractère souligné "_" sachant qu'on ne peut pas couper une ligne à l'intérieur d'une chaîne.
· Chaine =
"Visual Basic" & _
· "est un langage de programmation" '& permet de concaténer deux chaînes
2)
Types de
données et variables
Dans les langages de haut niveau, les variables ne peuvent stocker de données qu'après avoir été déclarées. Le fait de déclarer toutes les variables avant utilisation permet d'éliminer les erreurs de fautes de frappe dans les noms de variables. Chaque variable a un nom pouvant contenir jusqu'à 255 caractères (!). Le nom de la variable doit commencer par une lettre (chiffre pas admis), être différent des mots-clés de Visual Basic et être différent des identificateurs déjà utilisés.
2. 1 Types de données simples prédéfinis
Chaque type de variable occupe un certain nombre d'octets et couvre donc un intervalle de valeurs. Toute excursion hors de ce domaine provoque une erreur d'exécution. Il faut veiller, pendant la création, à affecter aux variables des types de données exploitant la mémoire (nombre total d'octets) de manière optimale. La déclaration des variables peut être effectuée selon 2 méthodes. Soit de faire appel à un identificateur de type (par exemple nombre% : le signe pourcentage désigne un entier sur 2 octets : Integer), soit d'utiliser une instruction Dim.
· Dim I As Integer | · Dim I%
· I = 100 | · I = 100
Byte : Ce type de données (1 octet) permet de gérer des variables entières dans l'intervalle 0 à 255 (ce type ne possède pas d'identificateur de type).
· Dim b As Byte
Boolean : Ce type peut prendre 2 valeurs : True et False (2 octets). On peut utiliser les constantes systèmes True et False pour affecter une valeur à ce type de variable.
· Dim s As Boolean
· S = True
Decimal : Ce type traite des entiers ou des décimaux (codés sur 12 octets) dans la plage ± 79 228 162 514 264 337 593 543 950 335 (sans une partie décimale) ou des nombres décimaux comportant jusqu'à 28 chiffres après la virgule dans la plage ±7.9228162514264337593543950335. La plus petite valeur non nulle est 0.0000000000000000000000000001. Ce type de données est parfaitement adapté aux calculs financiers, car il évite les erreurs d'arrondi. On peut obtenir une variable de ce type après une conversion en utilisant la fonction Cdec() sur une variable déclarée en tant que variant (ce type va être présenté plus tard).
· Dim TestVar As Variant
· TestVar = Cdec(TestVar) 'Transformation du type variant en sous-type Décimal
Integer : Ce type de données gère des entiers compris entre –32768 et +32767 (2 octets). L'identificateur de type est le caractère %.
Long : Il correspond aux entiers longs compris entre –2 147 483 648 et 2 147 483 647 (4 octets=32 bits). L'identificateur de type est le caractère &.
· Dim variable As Long | · Dim variable&
Single : Ce type de données correspond aux nombres à virgule
flottante en simple précision (4 octets). Leur intervalle est compris entre
–3.402823E+38 et
–1.401298E-45 pour les valeurs négatives, 1.401298E-45 et 3.402823E+38 pour les
valeurs positives. Leur identificateur de type est le caractère !.
· Dim variable As Single | · Dim variable!
Double : Ce type de données correspond aux nombres à virgule flottante en double précision (8 octets). Leur intervalle est compris entre -1,79769313486232E308 et -4,94065645841247E-324 pour les nombres négatifs et entre 4,94065645841247E-324 et 1,79769313486232E308 pour les positifs. On a 14 chiffres significatifs (décimaux). Le caractère de déclaration de type Double est le signe #
· Dim variable As Double | · Dim variable#
Date : A l'aide de ce type, on peut gérer des dates comprises entre le 1er janvier 1000 et le 31 décembre 9999 et des heures entre 0:00:00 et 23:59:59 (8 octets). Les valeurs affectées aux variables Date sont délimitées par des dièses (#).
· Dim D1 As Date : Dim
D2 As Date
· D1 = #
Currency : Les données de ce type peuvent contenir des valeurs monétaires avec 4 décimales et jusqu'à 15 positions entières dans un intervalle de valeurs de -922 337 203 685 477.5808 et 922 337 203 685 477.5807 (8 octets). Le caractère de déclaration de type Currency est le signe @
· Dim variable As Currency | · Dim variable@
· variable = 13.22 | · variable = 13.22
String : Ce type permet de gérer les chaînes de caractères dynamiques d'une longueur atteignant environ 2 milliards (2 exposant 31) de caractères. Le caractère de déclaration de type String est le signe $
· Dim variable As String | · Dim variable$
· variable = "Pierre" | · variable = "Pierre"
La taille d'une chaîne dynamique de caractères est variable ; elle peut changer pendant l'exécution du programme.
String * N : Ce type de données gère les chaînes de caractères statiques de taille fixe comprise entre 0 et 65 535 caractères (64 K octets).
· Dim variable As String*N
Le N définit le nombre de caractères de la chaîne. Ce nombre ne peut pas être modifié en cours d'exécution.
Variant : est un type de données pouvant contenir des données de toutes sortes Ce type traite les données numériques (Boolean, Byte, Integer, Long, Single, Double), ainsi que les chaînes de caractères dynamiques (String). Le temps machine nécessaire pour le traitement de ce type est plus important que les autres types en raison des vérifications et conversions. L'avantage est la possibilité d'affecter plusieurs valeurs avec la même variable.
· Dim variable As Variant
· variable = 1234
· somme# = variable + 0.5 ' La variable somme est un double
· Texte$ = variable & " F" ' L'opérateur & correspond à la concaténation
· variable = Empty
Si une variable de type Variant n'est pas affectée au départ d'une valeur précise, elle contient la valeur Empty, ce qui correspond à la valeur numérique 0 ou à une chaîne vide "". La fonction IsEmpty() sur cette variable permet de savoir si la variable est affectée d'une valeur (elle renvoie True) ou non (False). Si une variable variant contient une valeur invalide, cette valeur correspond à une valeur Null. La fonction Isnull() permet de savoir si la valeur est valide (True) ou non (False).
Object : Les objets comme les feuilles ou les éléments de commande sont traités au moyen de variable object (4 octets). L'instruction Set affecte une référence (adresse) à une variable déclarée comme object.
· Dim variable As
object
· Set variable = NomDeClasse
2. 2 Affichage sur l'écran
Pour afficher un texte sur l'écran, on utilise l'instruction Print (comme dans l'ancien langage Basic). Dans VB, l'affichage se fera dans une fenêtre (chaque programme pouvant ouvrir plusieurs fenêtres). Pour visualiser le contenu de la variable i% dans la fenêtre d'exécution, il faut utiliser l'objet Debug.
· Debug.Print
i%
L'affichage peut aussi être dirigé dans une feuille, zone d'image ou sur l'imprimante. Pour cela, il suffit d'utiliser l'objet de destination avant l'instruction Print séparé par un point.
· [objet.]Print [expression]
· 'l'objet est facultatif
L'exemple suivant montre la réalisation d'un premier programme d'exemple. La 1re étape consiste à ouvrir un nouveau projet en passant par le menu Fichier/Nouveau projet et en choisissant le type EXE standard. La fenêtre Form1 s'affiche. Cette fenêtre est utilisée pour afficher le texte. Pour modifier le titre de cette fenêtre, on affecte "Démo de la déclaration de variable" à la propriété Caption. Il suffit de faire double-clic sur cette fenêtre vide pour appeler l'éditeur de texte source pour frapper les instructions.
Dans la fenêtre intitulée "Projet1 – Form1 (code)", on a une zone de sélection. La liste contient uniquement l'objet Form, qui est la feuille et Général qui permet la saisie des déclarations de variables et de fonctions. On sélectionne l'objet Form et dans la liste modifiable de droite, on choisit Paint comme événement lié à cet objet. L'événement Paint se produit quand la feuille est dessinée pour la 1re fois ou quand elle est redimensionnée.
On remarque qu'il n'y a pas de programme principal. Les procédures d'événement sont appelées par les événements. Pour exécuter le programme, on passe par le menu Exécution/Exécuter. On clique sur la case de fermeture pour quitter le programme. Le fichier de feuille est enregistré avec l'extension (.FRM) et le projet avec l'extension (.VBP).
2. 3 Domaine de validité
Si on déclare une variable dans une procédure, la variable ne peut être employée que dans cette procédure (variable locale). Par contre, si on la déclare dans la section générale d'un module ou d'une feuille, la variable est reconnue dans ce module ou cette feuille. On qualifie cette variable de globale uniquement au module ou à la feuille. Les variables statiques sont déclarées dans les procédures par le mot réservé Static. La valeur des variables statiques, locales, est conservée d'un appel de la procédure à l'autre, contrairement à celle des variables ordinaires. La variable statique n'est pas visible de l'extérieur de la procédure. Il est conseillé de n'utiliser les variables statiques qu'exceptionnellement.
· 'Déclaration dans la section générale
· Dim VariableGlobaleDuModule
as Long
· Function NomDeFonction()
· Dim VariableLocale as Long 'Variable locale
· Static VariableStatique as Long 'Variable statique
· End Function
Si on souhaite déclarer des variables globales au projet, autrement dit des variables visibles au niveau du module, on doit employer le mot réservé Public dans la section générale du module. Ces variables sont également connues et utilisables au niveau du programme. Si on désire que ces variables ne soient connues que dans le module où elles sont déclarées, on utilise le mot réservé Private. Les variables qui ne sont pas déclarées sont automatiquement de type Variant. Si on a une variable publique dans un module et le même nom est utilisé localement, on devra spécifier le nom du module de la variable globale. Ceci n'est pas nécessaire si ce n'est pas le cas.
· VariableTest = Module1. VariableTest
2. 4 Les tableaux
Visual Basic permet d'utiliser des variables de type tableau à une ou à plusieurs dimensions. Les types de données des tableaux sont définis par les identificateurs de type (par exemple%, &, ! ou #) ou par les mots-clés (par exemple integer, Long, single et Double). Sous VB tous les tableaux doivent être déclarés, même s'ils contiennent moins de dix éléments. La dimension d'un tableau est définie entre parenthèses. Les instructions suivantes déclarent par exemple un tableau de 30 entiers nommé Test :
· Dim test(29) As
Integer | · Dim Test%(29)
La valeur 29 a été utilisée parce que la limite inférieure des tableaux est 0 par défaut. L'instruction Option Base, qui est obligatoirement utilisée dans la section générale des modules, permet de forcer la limite inférieure des tableaux à 1. On notera que cette instruction n'admet pas d'autres valeurs que 0 et 1.
· Option Base 1
· Dim Test(30) As integer 'déclaration d'un tableau de 30 éléments
La définition des limites basse et haute prend la forme suivante en utilisant une limite inférieure et une limite supérieure :
· Dim Test(-50 To 30)
As Integer
sachant que cette déclaration est prioritaire sur une éventuelle précédente instruction "Option Base".
Visual Basic gère des tableaux pouvant atteindre 60 dimensions. Leur déclaration est similaire à celle des tableaux à une dimension, la limite basse et haute pouvant être définie séparément pour chaque dimension. En l'absence de définition explicite de la limite basse, elle est définie pour chaque dimension par l'instruction Option Base ou par défaut, par définition, sur 0.
· 'déclaration de tableaux à plusieurs dimensions
· Dim matrice(l To 34, -23 To 23) As Double 'deux dimensions
· Dim A# (20,20,20) 'trois dimensions
· Dim B%(l To 10,
Les tableaux à plusieurs dimensions doivent être utilisés avec parcimonie car la mémoire occupée augmente de manière exponentielle avec le nombre de dimensions.
Visual Basic gère les tableaux statiques et dynamiques. Les tableaux statiques ont une taille fixe pendant l'exécution du programme alors que les tableaux dynamiques peuvent être adaptés aux besoins à tout instant. Les tableaux dynamiques sont déclarés sous la forme
· Dim TableauDynamique( ) As Integer 'tableau dynamique d'entiers
et modifiés pendant l'exécution par une expression du type :
· Redim NomTableau (LimiteInf To LimiteSup[,LimiteInf To LimiteSup, ...])
Cela permet de libérer de la mémoire qui sera disponible pour d'autres utilisations. Donc, les dimensions des tableaux dynamiques peuvent être modifiées pendant l'exécution du programme avec l'instruction Redim. Si certains éléments contenaient déjà une valeur, ils sont réinitialisés, autrement dit les valeurs sont perdues.
· Option Base 1
· Dim Tableau() As Integer ' Déclaration d'un tableau dynamique
· ReDim Tableau(3) 'Redimensionnement (alloue 3 éléments)
· Tableau (1) = 10 'initialisation des éléments du tableau
· Tableau (2) = 20
· Tableau (3) = 30
Il est possible de changer la dimension d'un tableau sans systématiquement perdre toutes les données déjà affectées. Il suffit d'utiliser Preserve avec l'instruction ReDim.
· 'Extension du tableau (sans perte de données)
· ReDim Preserve
Tableau (5)
· Tableau (5) = 50 'Affectation de valeurs
Si vous utilisez le mot clé Preserve, vous ne pouvez
redimensionner que la dernière dimension du tableau. Vous ne pouvez en aucun
cas modifier le nombre de dimensions. De même, le mot clé Preserve ne permet de
redimensionner un tableau qu'en modifiant la limite supérieure ; toute
modification de la limite inférieure provoque une erreur.
Les valeurs d'un tableau statique sont maintenues en mémoire pendant toute la durée de l'exécution du programme. Les limites d'un tableau statique ne peuvent pas être modifiées. Ce type ne doit être utilisé qu'exceptionnellement.
· Static Test(1 To 10)
As Integer
On peut déclarer des tableaux globaux Public ou des tableaux visibles au niveau du module dans lequel sont déclarés : Private. On peut récupérer les limites d'un tableau à l'aide des fonctions UBound et LBound. UBound acquiert la limite supérieure et LBound acquiert la limite inférieure.
· LimiteInferieure% = LBound(NomTableau, NumeroDimension)
· LimiteSuperieure% = UBound(NomTableau, NumeroDimension)
Avec VB, il est possible d'affecter par une seule et unique instruction le contenu intégral d'un tableau à un autre tableau à conditions que les deux soient déclarés en dynamique, aient les mêmes dimensions et gèrent les mêmes types de données (avec l'opérateur =). Si le tableau cible est de type statique, la seule solution est de procéder élément par élément.
2. 5 Les types et structures de données personnalisés
On peut définir des types personnalisés et des structures d'enregistrements (record). Ces types doivent être déclarés dans la section générale d'un module et non pas à l'intérieur d'une procédure ou d'une fonction en respectant la syntaxe suivante :
· Private Type monType1 | · Public Type monType2
· Champs As integer | · Champs As integer
· tableau(100) As double | · tableau(100) As double
· End Type | · End Type
Le mot Private ou Public peut être omis. A l'intérieur de l'enregistrement la définition d'un type avec un identificateur est impossible (il faut utiliser le mot-clé As). L'utilisation de variables de type variant ou chaîne de caractères dynamiques entraîne une taille indéfinie du type personnalisé. La déclaration d'une variable de ce type et l'accès aux éléments se fait de la manière suivante :
· Dim VariableTest As
monType1
· Entier% = VariableTest.Champs
· Reel# = VariableTest.tableau(1)
Il est même possible de déclarer un enregistrement dans lequel un élément est aussi un enregistrement (variable d'enregistrement imbriqué).
· Type monTypedeVar1
· A As integer
· B As integer
· End Type
· Type monTypeEtendu
· Nombre As integer 'Type de données standard
· Bloc As monTypedeVar1 'Type d'enregistrement personnalisé
· End Type
L'accès aux éléments se fera d'une manière classique.
· Dim GrandeVariable As monTypeEtendu
· Nombre1% = GrandeVariable.Nombre
· ValeurA% = GrandeVariable.Bloc.A
On note que les enregistrements destinés aux fichiers typés (à accès direct) ont une taille fixe. Donc, dans ce domaine l'utilisation des chaînes de caractères dynamiques et le type variant est prohibé.
Sous VB, il est possible de définir des types de données standards pour certains noms de variables à l'aide de l'instruction DefType (à utiliser avec modération) à laquelle associe une ou plusieurs plages de caractères. Toutes les variables commençant par une lettre de cette plage de caractères ont systématiquement le type de données défini avec l'instruction DefType. Le tableau 1 de l'annexe donne les valeurs possibles de DefType sachant que chaque déclaration effectuée avec une instruction Dim a la priorité sur l'instruction DefType.
En VB, on peut forcer les déclarations explicites de variables avec l'instruction :
· Option Explicit
La déclaration d'une constante par Const ou d'une variable par Dim a une portée privée (dans le module ou la feuille). Par contre la déclaration d'un type, d'une procédure par Sub ou d'une fonction par Function est publique.
3)
Constantes
systèmes et Constantes personnalisées
Les constantes sont initialisées avec une valeur fixe, qui ne peut pas être modifiée pendant l'exécution. VB reconnaît les constantes prédéfinies (système) et les constantes personnalisées. Les constantes les plus importantes figurent dans les tableaux tab2, tab3 et tab4. On rappelle que True et False sont des constantes systèmes prédéfinies. Les constantes personnalisées sont définies en respectant la syntaxe suivante :
· [Private|Public] Const NomConstante [As Type] = Expression
Le mot-clé Private ou Public est facultatif ainsi que son type. L'exemple suivant montre la déclaration d'une constante :
· Const G = 9.80665
4)
Les boîtes de
dialogue d'entrée et de sortie
Les entrées et sorties en VB ne sont généralement pas gérées par des instructions mais par des boîtes de dialogue personnalisées.
4. 1 Les messages
Pour afficher un message sur l'écran, on peut utiliser l'instruction MsgBox :
· MsgBox Message [[,[ Style%][, Titre$]] [, FichierAide$, Contexte%]]
Le contenu du message est passé dans le paramètre Message et celui de la barre de titre dans le paramètre Titre$. Les boutons et icônes qui seront affichés dans la boîte de message sont définis par le paramètre Style%. Par défaut, on a une boîte de message avec un seul bouton OK.
|
Les identificateurs d'icônes |
|||
|
Identificateur |
Icône |
Nom |
Constante système |
|
16 |
|
Stop |
VbCritical |
|
32 |
|
Confirmation |
VbQuestion |
|
48 |
|
Message d'avertissement |
VbExclamation |
|
64 |
|
Message d'information |
VbInformation |
Si On désire avoir une boîte de message dans laquelle il y a un deuxième bouton d'aide (en plus du bouton OK), on peut utiliser la valeur 16384 ou la constante système VbMsgBoxHelpButton à Style%. Bien sûr, on transmet par FichierAide$ le chemin et le nom du fichier à afficher quand on clique sur ce bouton et par Contexte% le numéro de la rubrique d'aide. L'exemple suivant montre l'utilisation de MsgBox :
· T$ = "Erreur" : M$ = "La fonction n'a pu être exécutée."
· M = M + " Le programme est terminé !"
· MsgBox M, VbCritical, T$
On peut forcer des sauts de lignes dans les messages en utilisant la constante VbCrLf :
· Message$ = "Première ligne" & VbCrLf & "Deuxième ligne"
Il existe aussi une fonction MsgBox( ) équivalente à l'instruction MsgBox et qui possède les mêmes paramètres. La seule différence est qu'on peut récupérer la valeur renvoyée. Le tableau suivant montre des boutons et des icônes affichés dans la boîte de message selon le style.
|
Les
constantes des boutons |
|||
Identificateur
|
Bouton
|
Constante système
|
|
|
0
|
OK |
VbOKOnly |
|
|
|
1 |
OK, Annuler |
VbOKCancel |
|
|
|
2 |
Abandonner,
Répéter, Ignorer |
VbAbortRetryIgnore |
|
|
|
3 |
Oui,
Non, Annuler |
VbYesNoCancel |
|
|
|
4 |
Oui,
Non |
VbYesNo |
|
|
|
5 |
Répéter,
Annuler |
VbRetryCancel |
|
|
En utilisant la constante VbYesNo comme style, on peut comparer la valeur renvoyée avec les valeurs suivantes : VbYes et VbNo. Pour choisir une sorte d'icône et un style de bouton, il faut additionner les deux valeurs correspondantes et passer cette somme au paramètre Style%. Par exemple pour obtenir une icône du point d'interrogation (identificateur = 32) avec deux boutons Oui ou Non (identificateur = 4), le paramètre Style% sera donc l'expression VbQuestion+VbYesNo (ou 32+4=36).
· Reponse% = MsgBox("Désirez-vous quitter le programme", 36, "Attention")
La valeur renvoyée par cette fonction stockée dans la variable Reponse% dépend du bouton enfoncé (Tab 5 en annexe donne la liste des valeurs renvoyées).
4. 2 Les Boîtes de saisie
Pour permettre à l'utilisateur de saisir des données simples, on peut utiliser la fonction InputBox$( ) qui recueille les données sous forme d'une chaîne de caractères. Sa syntaxe est la suivante :
·
Resultat$ = InputBox (Massage$
[, Titre$] [, Default$] [, Xpos%] [, Ypos%]
[, FichierAide$, ContexteAide%])
Le message est passé dans le paramètre Message$, le contenu de la barre de titre dans le paramètre Titre$. A l'exception du paramètre Message$, tous les paramètres sont facultatifs. La boîte de saisie peut être remplie par une valeur par défaut passée à la variable Default$. Cette valeur est prête à être modifiée. Les paramètres Xpos% et Ypos% permettent de définir la position de la boîte de saisie en pixel par rapport à l'angle supérieur gauche de l'écran. Le paramètre FichierAide$ définit un fichier d'aide et le paramètre ContexteAide% spécifie un numéro de rubrique de ce fichier d'aide. L'utilisation de ces deux paramètres implique l'existence automatique du bouton Aide permettant l'appel au fichier indiqué.
· Message$ = "Veuillez donner votre nom" : Titre$ = "Saisie d'un nom"
· MonNomt$ = InputBox (Massage$ , Titre$)
L'exemple suivant Montre l'utilisation de la
fonction InputBox associée à l'instruction MsgBox. Ce
programme sera non événementiel ; donc
on va supprimer la feuille obtenue par défaut en créant un nouveau projet. La 1re
étape consiste à créer un nouveau projet de type EXE Standard en passant par Fichier/Nouveau
projet. Ensuite, on crée un nouveau module de code source en faisant Projet/Ajouter un module qu'on va
enregistrer en faisant Fichier/Enregistrer
Module1 sous dans le fichier addition.bas. On sélectionne la feuille Form1
pour la supprimer à l'aide de Projet/Supprimer
Form1. On tape toutes les instructions dans une procédure appelée Sub Main( ) dans le module 1. Pour
cela, on va sélectionner le module dans la fenêtre de projet. Ensuite, on
clique sur le bouton Code 
(ou
double clic sur module1) et on tape les instructions dans la fenêtre de code.
Pour exécuter le programme, on passe par Exécution/Exécuter.
· Option Explicit
· Sub Main()
· Dim A%, B%
· Dim c#
· A = InputBox("Donnez le premier entier", "saisie d'un entier")
· B = InputBox("Donnez le deuxième entier", "saisie d'un entier")
· c = A / B
· MsgBox c, vbInformation, "affichage du résultat"
· End Sub
Ce programme illustre, outre les boîtes de message et de saisie, la possibilité de développer avec VB des programmes non événementiels et sans faire appel aux objets.
5)
Les opérateurs
mathématiques
Ces opérateurs sont classés dans différentes catégories.
5. 1 Opérateurs arithmétiques :
Les priorités des opérateurs arithmétiques permettant d'effectuer des calculs
mathématiques sont présentées ci-dessous. Pour inverser les priorités, il faut
utiliser des parenthèses.
|
Les
opérateurs arithmétiques |
|||
Priorité
|
Opérateur
|
Description
|
|
|
1 |
^ |
Puissance |
|
|
|
2 |
- |
Négation |
|
|
|
3 |
*, / |
Multiplication, Division |
|
|
|
4 |
\ |
Division entière |
|
|
|
5 |
Mod |
Reste de la division entière |
|
|
|
6 |
+, - |
Addition (concaténation), soustraction |
|
|
|
7 |
& |
Concaténation de chaînes de caractères |
|
|
5. 2 Opérateurs de comparaison :
Pour comparer des données, il faut utiliser les opérateurs de comparaison. Le
résultat est une valeur logique (True ou False).
Les opérateurs de comparaison sont les suivant : =, >, >=, <,
<=, <>, Like (comparaison de chaînes de caractères) et Is (comparaison
de variables objets). Ces opérateurs ont la même règle de priorité.
5. 3 Opérateurs logiques ou arithmétiques bit à
bit : Ces Opérateurs permettent
d'effectuer des relations logiques (booléens) ou de travailler au niveau bit par bit.
|
Les opérateurs logiques ou
arithmétiques bit à bit |
|||
Priorité
|
Opérateur
|
Description
|
|
|
1 |
Not |
Négation logique |
|
|
|
2 |
And |
ET logique |
|
|
|
3 |
Or |
OU logique |
|
|
|
4 |
Xor |
OU exclusif |
|
|
|
5 |
Eqv |
équivalence logique |
|
|
|
6 |
Imp |
Implication |
|
|
Le tableau tab6 en annexe montre les tables de vérité de ces opérateurs.
6)
Instructions
de contrôle de l'exécution
Visual
Basic dispose de toutes les structures de contrôle et de décision d'un langage
de haut niveau. Les instructions de saut Goto et Gosub (à utiliser avec
parcimonie) figurent encore sur la liste. VB conserve des reliques de l'ancien
Basic pour faciliter l'importation d'anciens textes source. Les instructions en
VB doivent donc être utilisées exclusivement dans des procédures.
6. 1 Les instructions de saut GOTO et GOSUB
Branchement simple, Goto : L'instruction
Goto est la plus simple instruction de contrôle du programme en VB. Elle permet
de créer un branchement vers une instruction quelconque à l'intérieur d'une
procédure (une étiquette). Le branchement vers des lignes de procédures
externes est impossible. Cette instruction met en péril l'aspect structurel
d'un programme (pas de possibilité d'établir un algorithme). Le code source obtenu
sera difficile à lire et éventuellement à modifier ou à corriger. En plus,
Cette instruction est déconseillée sauf en liaison avec le traitement d'erreurs
On error
parce que le risque de l'apparition de boucles infinies est grand. Cette
instruction peut être facilement remplacée par une boucle ou par un test if.
· On Error GoTo message_d_erreur : ' message_d_erreur est une étiquette
Branchement selon valeur - On Goto : Vous
pouvez réduire plusieurs branchement Goto à l'aide de l'instruction :
· On Valeur Goto Etiquette
Selon
la valeur obtenue avant On Goto, le programme sera aiguillé vers des lignes
définies. Chacune des étiquettes sera suivie d'une virgule et éventuellement
convertie en un entier.
· 'Sélection spéciale d'un bloc Goto
· Sub Nom_de_Procédure([Liste des paramètres)]
· 'éventuellement, d'autres instructions avec
· 'initialisation de la variable Valeur%
· On Valeur% Goto Etiquettel, Etiquette2, Etiquette3
· 'Intervalle de validité de Valeur% : 0-255
· 'Valeur% = 0 pas de branchement
· 'Valeur% = 1 branchement vers la première étiquette
· 'Valeur% = 2 branchement vers la deuxième étiquette
· 'Valeur% = 3 branchement vers la troisième étiquette
· 'Valeur% > 3 And Valeur% < 256 : pas de branchement
· 'Valeur% < 0 Or Valeur% > 255 : Erreur
· 'autres instructions éventuelles
· Exit Sub
· Etiquette1 : 'autres instructions
· Exit Sub
· Etiquette2 : 'autres instructions
· Etiquette3 : 'autres instructions
· End Sub
Dans
le code ci-dessus, le branchement vers la première étiquette aboutit à la sortie
de la procédure par l'instruction Exit sub. Le branchement vers la deuxième
étiquette commande l'exécution de toutes les instructions suivantes, y compris
celles qui se trouvent après Etiquette3. Le saut vers celle-ci conduit à
exécuter seulement les instructions qui se trouvent après Etiquette3. Notez
l'absence de retour à l'instruction qui suit la ligne Goto.
Branchement pour exécuter un bloc interne, Gosub : L'instruction
Gosub permet, comme pour l'instruction Goto, de définir des branchements dans
une procédure vers une étiquette. A la différence de l'instruction Goto, les
instructions du code exécutées après le branchement sont terminées par le
mot-clé Return. Notez que les
instructions Gosub et Return doivent se trouver dans la même procédure, Après
le traitement du bloc Gosub, le retour à la position d'appel dans le texte
source et l'exécution des instructions suivant l'instruction Gosub se trouvent
ainsi garantis.
L'avantage
des blocs d'instructions internes par rapport aux procédures utilisateur est
que vous n'avez pas à leur transmettre de paramètres, puisque ces blocs
connaissent toutes les variables de la procédure (Cet avantage n'est pas
vraiment convaincant).
La
prolifération d'instructions Gosub dans une procédure a tôt fait de réduire
considérablement la clarté du code source. Il faut réserver les instructions
Gosub à des cas exceptionnels et donner la préférence aux procédures et
fonctions personnalisées.
6. 2 Boucles avec incrémentation
Les
boucles Sont les principales Structures de contrôle d'exécution des programmes
dans les langages de haut niveau. Visual Basic propose les
structures de boucles For ... Next, While ... Wend et Do... Loop. La boucle For Each parcourt les éléments d'un
tableau ou d'une liste. Ces instructions simplifient le contrôle du déroulement
de l'exécution d'un programme.
For... Next : Utilisez
les boucles For ... Next pour
définir une valeur de début, une valeur de fin et le pas de l'incrémentation.
Cela permet par exemple d'initialiser les éléments d'un tableau de données ou
d'une zone de liste ou de les mettre à jour. La syntaxe générale de la boucle For ... Next est la suivante :
· For VariableCompteur = ValeurInitiale To ValeurFinale [Step Pas]
· 'instructions
· Next [VariableCompteur]
La
variable de comptage est le plus souvent de type Integer (nombre entier), les
valeurs initiales et finales peuvent être définies en fonction des besoins.
L'intervalle des valeurs initiales et finales dépend du type de données de la
variable de comptage.
Si
aucun pas n'est indiqué, la valeur 1 est automatiquement utilisée. Notez que le
pas doit être négatif si la valeur finale est plus petite que la valeur
initiale, car la boucle ne serait pas parcourue si le pas était positif.
· 'Une boucle For ...
Next simple
· For x% = 1 To 100 'ici Step = 1
· D%(x%) = 0 : 'Remarque le
tableau de données D% doit être déclaré
· Next x%
· 'boucle For ... Next imbriquée
· For i% = 1 To 100
· For j% =
5 To 10
· For k%. = 10 To 1 Step –1
· Textl.Print "i%="; i%; "j%="; j%; "k%="; k%; Chr$(13)
· Next
k%
· Next j%
· Next
i%
Pour
une sortie prématurée d'une boucle For...
Next, par exemple parce que vous avez trouvé la valeur cherchée, on peut
utiliser l'instruction Exit For.
Quitter une boucle avant terme peut réduire considérablement la durée de
l'exécution d'un programme.
· 'Sortie prématurée d'une boucle
For ... Next avec
Exit For
· For x% = 1 To 1000 Step 2
· 'instructions
· If condition Then Exit For :
'L'instruction If est une instruction conditionnelle
· Next
x%
Dans
une structure de boucle, il est possible d'intégrer plusieurs instructions Exit For, en prévision des
interruptions prématurées de la boucle. Cependant, pour limiter les risques
d'erreur, il vaut mieux les regrouper à une seule instruction de sortie.
Pour
parcourir les éléments d'un tableau, on peut utiliser la boucle suivante :
· Dim Tableaux%(5), i%
· For i = LBound(Tableaux()) To UBound(Tableaux())
· msgbox Tableaux(i)
· Next i
Une
boucle For Each
est une manière simple de parcourir les éléments d'un tableau ou les objets
d'une collection.
· For Each PrinterObject In
Printers
· ' Printers est une collection
d'objets
· 'Parcourir la liste des
imprimantes et afficher leur nom
· MsgBox PrinterObject.DeviceName, VbInformation, "Liste
des imprimantes"
· Next PrinterObject
Il
est également possible de quitter prématurément une boucle For Each par une instruction Exit
For. Les éléments parcourus dans la boucle des exemples précédents sont
gérés au moyen de la variable entière Variable% dans le cas du tableau, et par
la variable objet Printerobject dans le cas de la collection d'objets. Il n'est
pas nécessaire de préciser les indices qui seraient indispensables dans une
boucle For ... Next. Les valeurs de
début et de fin ne sont pas non plus à indiquer, ils sont définis dans les
tableaux et les collections d'objets.
While... Wend
(boucle conditionnelle) : Alors que la boucle For ... Next est commandée par des
valeurs, la boucle While ... Wend
peut être parcourue tant que une condition est vraie (True).
· While
condition = True
· 'instructions
du programme
· Wend
Les
instructions de la boucle While ... Wend
ne sont exécutées que si la condition est vraie avant de pénétrer dans la
boucle. Si la condition est fausse dès le départ, la boucle While ... wend n'est pas exécutée. Dans
ce cas, utilisez la boucle Do... Loop
qui peut être écrite de manière à être parcourue au moins une fois.
· 'boucle While ... Wend simple
· A% = 2000
· While A% >= 500
·
'autres
instructions du code source
·
A% = A% - 1
· Wend
· 'A% vaut maintenant 499
Les
boucles While ... Wend peuvent être
imbriquées, comme les boucles For ...
Next, Mais elles sont généralement utilisées sans imbrication.
· 'boucle While... Wend imbriquée
· A% = 2000 : B% = 100
· While A% >= 500
·
'autres
instructions du code source
· A% = A% - 1
· While
B% < 1000
·
'autres
instructions du code source
· B% = B% + 1
· Wend
· Wend
· 'A% vaut maintenant 499 et B%
vaut 1000
Veuillez
observer les retraits de chaque niveau d'imbrication destinés à améliorer la
clarté du code. Ils permettent de trouver très facilement le début et la fin de
chaque niveau.
Do ... Loop : La boucle Do... Loop
est comparable à la boucle While ...
Wend dans son principe, mais elle permet d'énoncer une condition commandant
la sortie de la boucle et forçant au moins une itération de la boucle. Dans la
première variante, la boucle Do... Loop
est utilisée comme une boucle While ...
Wend sachant qu'elle peut être quittée de manière prématurée à l'aide de
l'instruction Exit Do. La syntaxe de
cette instruction est la suivante :
· Do [While|until] condition = True
· 'instructions
du programme
· [Exit Do]
· Loop
Les
instructions de cette variante de boucle Do
... Loop ne seront exécutées que si la condition est vraie (True ) avant le début de la boucle. Si elle est fausse, la
boucle n'est pas exécutée.
· 'boucle Do... Loop simple (1re variante: syntaxe While ... Wend)
· A% = 2000
· Do While A% >= 500
·
'autres
instructions du code source
·
A% = A% - 1
· Loop
· 'A% vaut maintenant 499
Comme
les boucles For... Next et While ... Wend,
la boucle Do... Loop peut être
imbriquée, mais elle est généralement utilisée sur un seul niveau.
· 'boucle Do... Loop imbriquée
(1re variante : syntaxe While ... Wend)
· A% = 2000 : B% = 100
· Do While A% > 500
·
'autres
instructions du code source
· A% = A% - 1
· Do While B% < 1000
· 'autres instructions du code source
· B% =
B% + 1
· Loop
· Loop
·
'A% vaut maintenant 500 et B% vaut 1000
Veuillez observer les retraits de chaque niveau
d'imbrication destinés à améliorer la clarté du code. Le mot-clé while de la boucle Do ... Loop peut être remplacé par le mot-clé Until. Avec while, une
boucle est exécutée tant que la condition indiquée est vraie. Avec Until, la boucle est exécutée jusqu'à
ce que la condition indiquée soit vraie ou, autrement dit, tant que la
condition n'est pas vraie. Vous venez de faire la connaissance d'une première
extension de la structure While ... Wend.
Do ... Loop polyvalente : La
deuxième variante de la boucle Do ...
Loop a la syntaxe suivante :
· Do
· 'instructions
du programme
· [Exit Do]
· Loop [While|Until] condition = True
Les
instructions de cette variante de boucle Do...
Loop sont exécutées au moins une fois, car la condition est vérifiée à la
fin de la boucle. Sa valeur, vraie ou fausse, au début de la boucle est sans
importance.
· 'autre
boucle Do... Loop (deuxième variante : un parcours au moins)
· A% = 100
· Do
· 'autres instructions du code source
· A% = A% - 1
· Loop While A% > 100
· 'A% vaut maintenant 99
Comme
les boucles For ... Next
et While ... Wend,
les boucles Do ... Loop peuvent
aussi être imbriquées. Elles sont pourtant utilisées en règles générales sans
imbrication.
6. 3 Les tests
: (If, Select … Case)
Les
tests sont un moyen de contrôler le déroulement des programmes qui vient
compléter les boucles. Les structures de test sont utilisées pour créer des
branchements asservis à une comparaison entre deux valeurs (True ou False). Ces
comparaisons font appel à des opérateurs logiques.
Test simple, If : La
structure de test la plus simple est l'instruction If. Elle permet, selon la valeur d'une variable ou d'une certaine
condition, d'exécuter ou de sauter une instruction. Sa syntaxe est la suivante
:
· If Condition Then InstructionA [Else InstructionB]
La
partie Else
dans une instruction If simple est
facultative :
· 'instruction If simple
· If Valeur% < 0 Then Valeur% =
1
On
peut aussi dans un test affecter une valeur si la condition n'est pas remplie.
· 'instruction If simple
· If Valeur% < 0 Then Valeur% =
1 Else Valeur% = 2
Les
possibilités des tests d'une ligne sont limitées. Pour définir des instructions
de décision plus élaborées, il faut compléter le bloc If avec If ... Then ... Else
... End If.
· 'exemple
de bloc If
· If a% = l Then
· 'instructions exécutées si la condition est vraie
· Else
· 'instructions exécutées si la condition n'est pas vraie
· End If
· 'Structure If ... Then ... ElseIf... End If
· If B% = 0 Then
· 'instructions exécutées si la condition est vraie
· ElseIf B% < 0 Then
· 'instructions
· ElseIf B% > 5 Then
· 'instructions
· Else
· 'instructions exécutées si aucune des conditions n'a été
remplie
· End If
L'exemple
suivant montre des imbrications de structures de décision :
· 'bloc If imbriqué
· If B% = 0 Then
·
'instructions
exécutées si la condition est vraie
· If C%
> 0 Then D% = 0 : 'If sans une
partie Else
· ElseIf B% < 0 Then
· 'instructions
· If A% =
1 Then
· 'instructions
· ElseIf A% > 1 Then
· 'instructions
· Else
· 'instructions
· End If
· ElseIf B% > 5 Then
· 'instructions
· Else
· 'instructions
· End If
Il
ne faut pas abuser des imbrications de boucles en général et de tests en
particulier. Une bonne règle pour conserver un code concis et puissant consiste
à limiter les imbrications au minimum indispensable. Dans cet exemple aussi,
les retraits de chaque niveau d'imbrication permettent d'améliorer la clarté du
code.
Choix multiple, Select Case : Dans
les choix faisant intervenir de nombreuses possibilités, il est conseillé
d'utilisez la structure Select ... Case
qui permet de définir des blocs d'instructions réservés à des valeurs. La
syntaxe de cette instruction est la suivante :
· Select Case Expression
· Case Valeur1
· instructions
· [Case Valeur2
· instructions]
· [...]
· [Case Else
· instructions]
· End Select
Le
mot-clé Is permet d'utiliser des
opérateurs de comparaison. Les intervalles de valeurs sont définis à l'aide du
mot-clé To.
· Select Case A%
· Case 1
· 'instructions
· Case
· 'instructions
· Case Is > 5
· 'instructions
· Case Else
· 'instructions
· End Select
Comme
les autres structures de contrôle d'exécution, Select ... Case peut aussi être
imbriqué.
· Select Case A%
· Case 1
· Select Case B%
· Case 1
· 'instructions
· Case 2
· 'instructions
· Case 3
· 'instructions
· Case Else
· 'instructions
· End Select
· Case
· 'instructions
· Case Is > 5
· 'instructions
· Case Else
· 'instructions
· End Select
Les
structures de test et les boucles peuvent aussi être combinées et imbriquées.
IIf, Choose
et Switch : Les instructions IIf,
Choose et Switch issues du macro-langage VBA (Visual
Basic pour Applications) sont des formes spéciales (et abrégées) de décision.
IIf
évalue une expression et, selon la valeur obtenue, affecte une valeur ou une
autre à une variable. La syntaxe générale de IIf est
la suivante :
· Valeur = IIf (expression,
ValeurSiVrai, ValeurSiFaux)
L'exemple
:
· Test% = IIf(x% > 100, 1, 10)
affecte
1 à la variable test% si la valeur de la variable x% est supérieure à 100 et 10
dans le cas contraire. Cette formulation est donc plus concise et plus claire
que le bloc If ... Then ... Else
... End If. Cette
instruction remplace le bloc If suivant
· If x% > 100 Then
· Test% = 1
· Else
· Test% = 10
· End If
L'instruction
Choose
sélectionne et renvoie une valeur dans une liste d'arguments. Sa syntaxe
générale est la suivante :
· Valeur = Choose(Index,
choix_1[, choix_2, ... ,choix_n])
Le premier paramètre Index désigne ici une
valeur numérique qui peut aussi être le résultat d'une expression numérique. une seule valeur, définie par la valeur de l'index, des
autres paramètres de cette instruction sera affectée à la variable valeur. Dans
l'exemple suivant, A$ reçoit la chaîne de caractères "Rouge" Si Index
vaut 1. Si Index vaut 2, la chaîne de caractères A$ contiendra
"Vert", et elle contiendra "Bleu" si Index vaut 3. Si Index
ne correspond à aucune valeur (ici Index = o et
Index > 3), Choose renvoie la
valeur #Null#.
· A$ = Choose(Index,
"Rouge", "Vert", "Bleu")
L'instruction
Choose peut remplacer le bloc If ou la structure Select ... Case. L'exemple précédent de l'instruction choose correspond au bloc If suivant :
· If Index = 1 Then
· A$ =
"Rouge"
· ElseIf Index=2 Then
· A$ =
"Vert"
· ElseIf Index=3 Then
· A$ =
"Bleu"
· Else
· A$ = ""
· End If
On
peut aussi remplacer cette instruction par la structure Select ... Case
suivante :
· Select Case Index
· Case 1
· A$ = "Rouge"
· Case 2
· A$ = "Vert"
· Case 3
· A$ = "Bleu"
· Case Else
· A$
= ""
· End select
L'instruction
choose
permet donc de formuler des structures If
et Select ... Case simples de
manière plus concise. En toute hypothèse, une liste d'expressions claire est la
première condition nécessaire à l'emploi de l'instruction choose.
Avec
l'instruction Switch, il est
également possible de choisir et de retourner une valeur précise dans une liste
d'arguments. En voici la syntaxe :
· Valeur = Switch (Expres1, Val1
[, Expres2, Val2] ... [, ExpresN, ValN])
Elle
vérifie la liste d'expressions de la gauche vers la droite et retourne la
valeur de résultat de l'expression correspondante.
· Dim Couleur As Variant
· 'Définition de la valeur de
l'expression à vérifier
· Couleur = "Bleu"
'Comparaison des expressions
· ValeurCouleur&
= Switch (Couleur = "Rouge", &H000000C0&, _
· Couleur
= "Vert", &H00008000&, Couleur = "Bleu",
&H00C00000&)
· ' ValeurCouleur&
est définit en tant que entier long
· MsgBox
"&H" & ValeurCouleur&, VbInformation, "ValeurCouleur
Bleu"
Comme
dans une structure If, une simple
expression Switch permet de tester
plusieurs expressions indépendantes les unes des autres. A noter que la valeur
correspondante à la première expression vraie est retournée comme résultat bien
que la vérification des expressions suivantes soient
aussi vraies. Cette instruction Switch correspond à la structure if suivante :
· If Couleur = "Rouge" Then
· ValeurCouleur& = &H000000C0&
· 'cette valeur est équivalente à &HC0&
· ElseIf Couleur =
"Vert" Then
· ValeurCouleur& = &H00008000&
· ElseIf
Couleur = "Bleu" Then
· ValeurCouleur&
= &H00C00000&
· End If
7)
Procédures et
fonctions
Les
éléments primordiaux pour l'écriture d'un code source structuré et modulaire
sont les procédures personnalisées (les procédures et les fonctions). Etant
donné que l'emploi de procédures est imposé sous Visual Basic, on n'a pas
d'autre choix que d'écrire un code structuré.
7. 1 Fonctions - Des procédures avec valeurs de résultat
Les
fonctions sont définies par l'utilisateur et, comme les fonctions internes de
Visual Basic, elles renvoient dans leur nom un résultat qui est stocké dans une
variable.
Pour
créer une fonction, activez la fenêtre de code d'une feuille ou d'un module
donné. Vous pouvez la définir publique (par défaut) ou privée à l'aide des
mots-clés Private et Public. Les fonctions peuvent donc être
privées (elles sont seulement connues dans le module dans lequel elles ont été
déclarées) ou globalement accessibles dans tout le programme (connues dans
toutes les feuilles et les modules). Tapez dans la fenêtre de code le mot-clé Function suivi du nom de la fonction et
validez cette saisie avec Entrée. Un modèle de la fonction est automatiquement
créé.
Vous
pouvez aussi définir les fonctions dans une boîte de dialogue que vous ouvrez
en faisant Outils/Ajouter une procédure.
La liste des paramètres est définie librement. La définition d'une fonction a
la syntaxe suivante :
· [Static]
[Public] [Private] Function
Nom_fonction([Liste_paramètres]) [As Type]
· 'instructions
· [Exit Function]
'sortie
avant la fin
· Nom_fonction
= Resultat
· End Function
Le
mot-clé Static
force la conservation des valeurs de toutes les variables locales de la
fonction entre les appels. L'instruction Exit Function
vous permet de quitter une fonction en cours d'exécution de façon prématurée :
· Function Calcul (a%, b%)
As Single
· 'si b%
est nulle, impossible de calculer
· If b% = 0 Then
· Calcul = 0 'empêcher une
division par zéro
· Exit Function
· End If
· Calcul = a% + 2 / b%
· End Function
Chaque
élément de la liste des paramètres a la structure suivante :
· [Optional] [ByVal] [ByRef]
[ParamArray] VarName [( )]
[As Type]
Les
fonctions doivent avoir un type de données, car elles renvoient une valeur,
affectée au nom de la fonction, ce qui permet de l'utiliser dans la procédure appelante.
Des valeurs peuvent aussi être échangées dans les listes de paramètres à
condition d'être passées par références (voir plus loin ByRef). Il est
préférable dans ce cas là d'utiliser une procédure Sub.
· 'exemples
d'en-têtes de fonctions
· Function Test% (b%, c%)
· Function Resultat (B As
Integer, C As String) As Long
· Function Pi ( )
· Private Function Addition# (a#, b#)
· Static
Check%(LimMaxi%, LimMini%)
La
fonction suivante renvoie par exemple la valeur du nombre Pi :
· Function Pi( ) As Double
· Pi = 3.141592265
· End Function
· 'appel
: Les parenthèses sont facultatives, si aucune liste de paramètres n'a été
· 'définie.
Elles permettent toutefois de distinguer facilement les appels de fonction
· NbrePi#
= Pi ( )
Les
valeurs des variables peuvent être passées à la fonction par valeur (mot-clé ByVal) ou par références (mot-clé ByRef) dans les paramètres. Quand vous
passez à une fonction une variable par valeur (by value), toute modification de
cette valeur dans la fonction n'a aucune influence sur la variable. A
l'inverse, quand vous passez à une fonction une variable par référence (adresse
dans la mémoire), toute modification de la valeur affecte immédiatement la
variable. Le dernier est le passage par défaut.
· 'Passage des paramètres par valeur
· Function Addition( ByVal
a%, ByVal b%) As Long
· Addition& = a% + b%
· End Function
· Resultat& = Addition& (234, 322)
· Resultat& = Addition (a%, b%)
· 'Passage des 2 premiers
paramètres par valeur et le dernier par référence
· Function Addition&( ByVal
a%, ByVal b%, ByRef i%)
· Function
Addition&( ByVal a%, ByVal b%, i%)
· 'i% est
passé par référence
· Addition& = a% + b%
· i% = i% +1
· End Function
· Resultat& = Addition& (a%, b%, i%)
Tous
les paramètres qui suivent le Mot-clé Optional
sont des paramètres dits facultatifs. Si vous définissez par exemple une
fonction dans la forme suivante :
· Public Function
· . . .
· End Function
Son appel peut
avoir les formes suivantes :
· Test& = Somme(7)
ou
· Test& = Somme(6,
567)
ou
· Test& = Somme(5,
856, 32)
sans
provoquer de message d'erreur. Un élément ParamArray
est autorisé exclusivement comme dernier argument de la liste des paramètres.
Il indique qu'un tableau de données de type Variant peut figurer dans l'appel
de la fonction. L'entête de cette fonction a la syntaxe suivante :
· Function TestParamArray([…, ] ParamArray Vvar( ) As Variant)
· . . .
· End Function
Au
sein de la fonction (ou de la procédure sub),
on accède individuellement aux paramètres par l'argument de type variant vparametre. Dans l'exemple suivant on a pris le cas d'une
procédure Sub.
· Sub TestParamArray(ParamArray vparametre(
) As Variant)
· Dim i As Integer
· For i = LBound(vParametre) To UBound(vParametre)
· Debug.Print vparametre(i)
· Next i
· End Sub
L'appel
de la fonction ou de la procédure se réalise de la manière suivante
· Private Sub Form_Load( )
· Call TestParamArray("Pararn 1", "Param 2", "Param
3")
· Call TestParamArray("Param 1", "Param 2", "Param
3", "Param 4")
· End Sub
Les
fonctions peuvent s'appeler elles-mêmes : ce sont alors des fonctions
récursives. Il vaut mieux éviter les appels récursifs, car les valeurs
intermédiaires sont déposées sur la pile et provoquent très rapidement un
débordement de capacité. Il faut utiliser pour les fonctions récursives un test
d'arrêt, en absence de ce test la récursivité ne s'arrête qu'à la saturation de
la pile.
· Function
RecursiveFunction(ListeParam)
· 'Instructions
· 'Appel récursif de fonction
conditionné par un test d'arrêt
· Résultat =
RecursiveFunction(ListeParam)
· 'Instructions
· End Function
7. 2 Les procédures
Les
procédures sont définies par l'utilisateur avec des paramètres définis
librement et se comportent exactement comme les procédures d'événements ou
comme les instructions internes de Visual Basic.
Pour
créer une procédure, il faut activer la fenêtre de code de la feuille ou du
module choisi. Les procédures des feuilles sont connues exclusivement dans leur
feuille. Les procédures des modules de code peuvent être déclarées privées
(connues dans leur module d'origine seulement) ou publiques (par défaut), et
être connues, dans l'ensemble du programme (feuilles et modules).
Le
fait de taper dans la fenêtre de code le mot-clé Sub suivi du nom de cette procédure et de valider avec entrée
permet de créer automatiquement un modèle de procédure. On peut aussi définir
les procédures dans une boîte de dialogue en passant par le menu Outils/Ajouter une procédure.
La
définition d'une procédure suit la syntaxe
· [Static]
[Private] [Public] Sub Nom_Procédure([Liste_paramètres])
· 'instructions
· [Exit Sub] 'Sortie avant la fin
· End Sub
Chaque
élément de la liste des paramètres a la structure suivante :
· [Optional][ByVal][ByRef][ParamArray] VarName [( )] [As
Type]
Contrairement
aux fonctions, les valeurs sont exclusivement échangées à travers les
paramètres des procédures (il n'y a pas une valeur renvoyée). Le mot-clé static force la conservation des
valeurs de toutes les variables locales de la procédure entre les appels. Si on
déclare une procédure Private, elle
est connue seulement dans le module de sa déclaration. Les procédures déclarées
Public sont utilisables dans tout le
programme (feuilles et modules). Un exemple proposé plus bas traite
spécifiquement de cette particularité.
· 'Exemples d'en-têtes de
procédures
· Sub Test% (b%, C%, d$)
· Sub Resultat (B As
Integer, C As String)
· Private Sub Addition (a#, b#, Resultat#)
· Static
Check%(LimMini%, LimMaxi%, Resultat%)
· Sub Test (ByVal a$, ByVal
b$)
· 'a$ et
b$ sont ici passés explicitement par valeur et non par référence
· 'Transmission d'un tableau typé
variant
· Function
Min(Tableau ( )) as Long
La
procédure suivante affiche un message à l'aide de la fonction MsgBox de VB.
· Public Sub
MonMessage(Texte$)
· Titre$ = "Attention"
· MsgBox
Texte$, VbExclamation, Titre$
· End Sub
· 'appel :
· MonMessage
"Ceci est un message"
· Call MonMessage
("Ceci est un message") 'en utilisant des parenthèses
Les
paramètres permettent de passer à la procédure des variables par valeur (mot-clé
ByVal) ou par référence (mot-clé ByRef) qui est le mode par défaut.
Quand on passe une variable par valeur (by value) à une procédure, toute
modification de cette valeur dans la procédure n'a aucune influence sur la
variable. A l'inverse, quand on passe une variable par référence (adresse dans
la mémoire) à une procédure, toute modification de sa valeur affecte
immédiatement la variable.