Exemple de procédure d'événement
Utilisez ce document comme bon vous semble; mais soyez prudent(e)s, et consultez aussi les normes acceptées de programmation VB dans ce cours.
Comme tout langage de haut niveau, les programmes écrits en VB doivent respecter des règles. Ce langage comprend tout d'abord des objets possédant leurs propriétés et méthodes auxquelles viennent se greffer les instructions spécifiques du Basic. La syntaxe de VB permet d'écrire des programmes structurés et modulaires. Ce chapitre a pour objet de faire un survol rapide des différents groupes d'instructions composant le langage hôte VB. Vous verrez que ce langage possède de grandes similitudes avec d'autres dialectes du Basic.
Les commentaires sont inscrits directement dans le code pour en faciliter la lecture. Ils sont ignorés par le compilateur et n'affectent pas le fonctionnement du programme. Un commentaire est précédé d'une apostrophe («'») ou du mot réservé «Rem».
Il est conseillé d'ajouter des commentaires à vos programmes, en particulier dans les sections plus complexes. Cela permettra de mieux comprendre le code et surtout de pouvoir le réutiliser efficacement.
Les variables de VB doivent avoir un type. Vous pouvez déclarer ce type de façon explicite ou laisser le soin à VB de le définir.
Chaque variable a un nom qui lui est propre, d'une longueur maximale de 256 caractères, commençant par une lettre et n'étant pas identique aux mots réservés du langage.
Les constantes sont initialisées avec une valeur qui ne varie pas durant l'exécution du programme. Il y a les constantes "systèmes" appartenant à VB, et celles définies par l'utilisateur.
Les entiers (Integer), réels (Real), chiffres monétaires (Currency) et les chaînes de caractères (String) sont géré(e)s dans des variables de types biens définis. Chaque type peut couvrir une échelle de valeurs qui lui est propre. Les débordements des limites de valeur causent des erreurs durant l'exécution du programme. Ces limites sont imposées par le nombre d'octets utilisés pour représenter la variable. Les entiers occupent de 2 à 4 octets, les réels de 4 à 8.
Les calculs sur les entiers sont les plus rapides, et ce type occupe moins de mémoire que d'autres. Il est donc conseillé de privilégier le type de données Integer quand la situation le permet.
Si vous utilisez une variable en omettant de la déclarer, Visual Basic lui affectera automatiquement le type Variant. L'instruction Option Explicit impose la déclaration par Dim avant toute utilisation de la variable. Le tableau ci-après montre les types de données fondamentaux et donne pour chacun d'eux la taille d'enregistrement et la plage de valeurs correspondantes.
Les déclarations sont des instructions de code non exécutables qui identifient des procédures externes, des constantes ou des variables et qui définissent leurs attributs (tels que le type de données).
Vous pouvez écrire des déclarations pour des modules de feuille, des modules standard ou des modules de classe. Pour saisir des déclarations de niveau module, placez-vous dans la section des déclarations d'un module. Pour taper des déclarations globales, ouvrez la section des déclarations d'un module et utilisez l'instruction Public pour les constantes et les variables. Vous pouvez également effectuer des déclarations à l'aide des mots clés Dim, Static et Private.
Vous avez également la possibilité de saisir des déclarations de niveau procédure. Quel que soit le niveau de code ou la technique que vous utilisez pour déclarer une variable ou une constante, vous devez respecter des règles de portée bien définies.
Ce type est spécifique à Visual Basic et n'est pas reconnu par les autres dialectes Basic. Sa taille dépend des données stockées par la variable. Il gère les valeurs allant jusqu'au type Double et aux chaînes de caractères. Les conversions sont effectuées à l'interne, ce qui est agréable pour le concepteur mais prend du temps de calcul et ralentit l'exécution du programme.
La fonction VarType renvoie le type interne d'une variable Variant.
|
|
|
|
| Byte |
|
0 à 255 |
| Boolean |
|
True ou False |
| Integer |
|
-32768 à 32767 |
|
Long (entier long) |
|
-2147483648 à 2147483647 |
|
Decimal (Ce type n'est pas disponible directement pour une déclaration de variable, mais il peut servir de sous-type à un Variant) |
|
+/-79228162514264337593543950335pour les nombres sans décimales. La plage de valeurs des nombres à 28 décimales est +/-7,9228162514264337593543950335. Le plus petit nombre différent de zéro est 0,0000000000000000000000000001. |
|
Single (valeur à virgule flottante en simple précision) |
|
-3,402823E38 à -1,401298E-45 pour les valeurs négatives; 1,401298E-45 à 3,402823E38 pour les valeurs positives. |
|
Double (valeur à virgule flottante en double précision) |
|
-1,79769313486232E308 à -4,94065645841247E-324 pour les valeurs négatives; 4,94065645841247E-324 à 1,79769313486232E308 pour les valeurs positives. |
|
Currency (entier à l'échelle) |
|
-922337203685477,5808 à 922 337 203 685 477,5807 |
| Date |
|
1er janvier 100 au 31 décembre 9999. |
| Object |
|
Toute référence à des données de type Object. |
|
String (longueur variable) |
|
De 0 à environ 2 milliards de caractères. |
|
String (longueur fixe) |
|
De 1 à environ 65536 caractères. |
|
Variant (avec nombres) |
|
Toute valeur numérique jusqu'aux limites du type Double. |
|
Variant (avec caractères) |
|
Même étendue que pour un String de longueur variable. |
En plus des types de données fondamentaux, Visual Basic connaît les types tableaux, à une ou à plusieurs dimensions.
Les tableaux permettent de manipuler des listes ou des matrices identifiées par une seule variable. Le type d'un tableau est affecté par un mot réservé (exemples : Integer, Long, Single ou Double). Visual Basic vous permet d'utiliser deux types de tableaux : les tableaux de taille fixe, dont la taille ne change pas, et les tableaux dynamiques, dont la taille peut être modifiée au moment de l'exécution.
Les tableaux dynamiques peuvent être "redimensionnés" sans perte de données à l'aide des instructions ReDim et Preserve.
En VB, tous les tableaux doivent être déclarés. Pour cela, on utilise les instructions Dim, Private, Public, Static ou ReDim. La ou les dimensions du tableau sont ajoutées entre parenthèses au nom de la variable.
Vous pouvez déclarer un tableau de taille fixe de trois (3) manières différentes, selon la portée que vous souhaitez conférer à votre tableau:
Par exemple, pour déclarer un tableau de 20 entiers, nous devrions utiliser l'instruction suivante: Dim Toto(19) As Integer. Par défaut, la valeur entre parenthèses indique la borne maximale de la dimension. La borne minimale par défaut est 0.
Quel que soit le type de données, les tableaux nécessitent 20 octets de mémoire, auxquels viennent s'ajouter quatre (4) octets pour chaque dimension et le nombre d'octets occupés par les données proprement dites.
L'espace occupé en mémoire par les données peut être calculé en multipliant le nombre d'éléments par la taille de chacun d'eux. Par exemple, les données stockées dans un tableau unidimensionnel constitué de quatre (4) éléments de type Integer de deux octets chacun occupent huit (8) octets. Ajoutés aux 24 octets d'espace mémoire de base, ces huit (8) octets de données portent le total à 32 octets de mémoire requis.
Un Variant contenant un tableau nécessite 12 octets de plus qu'un tableau seul.
L'instruction Option Base numéro, où numéro est une expression numérique valant 0 ou 1, permet de fixer la borne par défaut à 0 ou 1.
Vous pouvez également définir la valeur de la borne inférieure directement lors de la déclaration du tableau. Par exemple, pour déclarer un tableau de 20 entiers dont la borne inférieure est fixée à 10 et la borne supérieure à 29, nous devrions utiliser l'instruction suivante: Dim Toto(10 to 29) As Integer.
Les tableaux de Visual Basic peuvent avoir jusqu'à 60 dimensions, mais il est très rare que l'on utilise un tableau ayant plus de trois (3) dimensions.
Elles permettent d'allier des types fondamentaux variés. Elles sont déclarées dans des modules de code source et peuvent être locales ou globales.
|
|
Type StructureUtilisateur Élément [ (Indice) ] As TypeDonnée [ Élément [ (Indice) ] As TypeDonnée ] ... End Type |
Un type défini par l'utilisateur est encadré par les mots réservés Type et End Type. Il peut regrouper divers types fondamentaux. Chaque type est déclaré par la clause As, et l'usage des préfixes est interdit.
|
|
Type StructureUtilisateur Entree As Integer Valeur As Double Description As String *30 Donnee (-50 To 30) As Long Supplement As Variant Identification As String End Type ' ... Dim VariableEssai As StructureUtilisateur ' ... Texte1.Text = Str$(VariableEssai.Entree) Texte2.Text = Str$(VariableEssai.Valeur) |
Visual Basic gère les variables globales (à l'échelle du programme ou de la feuille), locales et statiques. Le domaine de validité d'une variable est défini par sa déclaration et par son emplacement.
Si elles sont déclarées par l'instruction Public dans la partie générale d'un module de code, elles sont accessibles depuis la totalité du programme. Cela interdit l'utilisation de variables homonymiques, même si elles sont de type différent, dans un même domaine de validité.
Elles ne sont connues que dans la procédure où elles ont été déclarées. Des variables homonymiques et de type identique déclarées dans des modules différents sont considérées comme des variables distinctes. Notez que leurs valeurs sont perdues entre les appels de leurs procédures.
Elles ne sont connues que dans la procédure où elles ont été déclarées par l'instruction Static. Des variables homonymiques et de type identique déclarées dans des modules différents sont considérées comme des variables distinctes. Leurs valeurs sont conservées entre les appels de leurs procédures pendant toute la durée du programme.
L'emploi de constantes symboliques est encouragé car il améliore la clarté des programmes. Par convention, on utilise des majuscules pour les noms de constantes, ce qui permet de les identifier d'un coup d'œil.
Les constantes définies par l'utilisateur sont déclarées par l'expression suivante:
[ Public ] Const NomDeLaConstante = expression |
Une instruction Const a une portée et obéit aux mêmes règles qu'une déclaration de variable:
Les opérateurs arithmétiques listés dans le tableau suivant se chargent des opérations de base. Les rangs de priorité doivent être pris en considération dans l'écriture de vos expressions arithmétiques. Les parenthèses permettent de modifier l'ordre d'exécution des opérateurs.
|
|
|
|
|
|
|
Exposant |
|
|
|
Négation |
|
|
|
Multiplication, Division |
|
|
|
Division entière |
|
|
|
Reste d'une division entière |
|
|
|
Addition, Soustraction |
|
|
|
Concaténation |
Les opérateurs relationnels se chargent des opérations de comparaison. Ils renvoient toujours une valeur logique (vrai ou faux). Leurs principaux domaines d'application sont les structures de contrôles des programmes (tests, boucles). Notez l'absence de priorité entre les opérateurs relationnels.
|
|
|
|
|
Égal |
|
|
Supérieur à |
|
|
Inférieur à |
|
|
Supérieur ou égal à |
|
|
Inférieur ou égal à |
|
|
Différent de |
|
|
Comparaison de chaînes |
Les opérateurs logiques fournissent le résultat d'une opération logique et d'opérations sur les champs de bits. Ils sont représentés dans le tableau suivant. Notez leur priorité.
|
|
|
|
|
|
|
Négation logique |
|
|
|
ET logique |
|
|
|
OU logique |
|
|
|
OU exclusif |
|
|
|
Équivalence logique |
|
|
|
Implication logique |
|
|
|
Comparaison de deux variables objets |
Les tables de vérités suivantes donnent les résultats des diverses opérations logiques.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
VB vous propose trois boucles, For ... Next, While ... Wend et Do ... Loop qui permettent de gérer le déroulement du programme à l'intérieur des procédures. Notez que la répétitive While ... Wend est considérée obsolète, et peut en tout temps être remplacée par une boucle de type Do ... Loop.
Cette instruction définit une valeur initiale, une valeur finale et un pas. Elle convient parfaitement à l'initialisation de tableaux ou de listes, ou encore à l'échange de données. Sa syntaxe est décrite ci-dessous.
For Variable_compteur = Valeur_initiale To Valeur_finale [ Step Pas ] 'instructions [ Exit For ] Next [ Variable_compteur, ... ] |
Variable_compteur est toujours un entier pour des raisons de rapidité, sauf cas particuliers.
L'étendue du domaine Valeur_finale - Valeur_initiale est limitée par le type de données choisi pour ces deux valeurs.
Si aucune valeur n'est définie pour le Pas, la valeur 1 est utilisée. Si le Pas est négatif, la valeur initiale doit être supérieure à la valeur finale.
Les boucles For ... Next peuvent être imbriquées. L'instruction Exit For permet de quitter prématurément la boucle For.
Le critère de décision d'itération d'une boucle Do ... Loop est également une valeur logique. Par contre, il est possible de l'écrire de manière parcourue au moins une fois.
Do [ {While | Until} condition ]
'instructions
[ Exit Do ]
Loop [ {While | Until} condition ] |
Avec l'option While, la condition doit être vraie pour que la boucle s'exécute, tandis qu'avec l'option Until la condition doit être fausse. Si vous n'utilisez aucune de ces deux options, il vous faudra prévoir une "sortie de secours" à l'aide de l'instruction Exit Do.
Les instructions GoTo, GoSub, On ... GoTo et On ... GoSub sont des instructions qui nuisent à votre programme. Elles sont génératrices d'erreurs et rendent votre programme tout à fait illisible. Il est fortement conseillé de bannir ces instructions de vos programmes.
Dans les faits, nous retrouverons l'instruction GoTo lorsque nous verrons le traitement des erreurs d'exécution.
Visual Basic vous propose deux structures de test, If et Select Case, qui permettent de gérer facilement le déroulement du programme à l'intérieur des procédures.
Cette structure décisionnelle doit être utilisée selon la syntaxe suivante:
If expression_relationnelle_ou_logique_1 Then
Instruction_1
[ .
.
Instruction_m ]
[ ElseIf expression_relationnelle_ou_logique_2 Then
Instruction_m+1
[ .
.
Instruction_n ] ]
[ ElseIf ... Then ... ]
[ Else
Instruction_n+1
[ .
.
Instruction_o ] ]
End If
|
Ici, expression_relationnelle_ou_logique_... représente soit une expression logique, soit un test de la forme TypeOf objet Is type_objet.
Dans certains cas la structure Select Case permet une structure plus claire qu'une longue liste de If imbriqués. Elle permet de définir des blocs clairement délimités, qui seront exécutés selon la valeur prise par une variable. La syntaxe de cette instruction est:
Select Case Expression_test
[ Case Liste_expressions_1
Bloc_Instructions_1 ]
[ Case Liste_expressions_2
Bloc_Instructions_2 ]
...
[ Case Else
Bloc_Instructions_n ]
End Select |
Expression_test est une expression numérique ou de type chaîne de caractères. Liste_expressions est une séquence d'une ou plusieurs valeurs possibles, d'intervalle de valeurs et de test à l'aide de l'instruction Is.
La ligne décrite ci-dessous représente une Liste_expression valide.
Case 1 To 4, 7 To 9, 11, 13, Is > MaxNumber |
En Visual Basic, nous devons distinguer plusieurs types de regroupement algorithmiques. Nous parlerons ici des fonctions internes, des procédures d'événement ainsi que des fonctions et procédures définies par le développeur.
Visual Basic possède une importante bibliothèque de fonctions internes. Il existe environ 130 fonctions différentes, réparties dans les catégories suivantes:
Les fonctions de cette catégorie permettent de convertir des données de type quelconque dans un type précis. Le type de la valeur retournée par chacune de ces fonctions dépend du rôle de la fonction. Ces fonctions se présentent habituellement sous la forme C... où les points représentent un acronyme du nom du type.
Les fonctions de conversion les plus utilisées sont:
|
|
|
| Cbool | Convertit une expression en Boolean |
| Cbyte | Convertit une expression en Byte |
| Ccur | Convertit une expression en Currency |
| Cdate | Convertit une expression en Date |
| CDbl | Convertit une expression en Double |
| Cdec | Convertit une expression en Decimal |
| CInt | Convertit une expression en Integer |
| CLng | Convertit une expression en Long |
| CSng | Convertit une expression en Single |
| CStr | Convertit une expression en String |
| CVar | Convertit une expression en Variant |
Les fonctions de cette catégorie permettent d'effectuer des vérifications sur le contenu de différents types de variables. Ces fonctions retournent généralement une valeur de type Boolean.
Les fonctions de vérification les plus utilisées sont:
|
|
|
| IsArray | Indique si une variable est un tableau |
| IsDate | Indique si une expression peut être convertie en date |
| IsEmpty | Indique si une variable a été initialisée |
| IsMissing | Indique si un paramètre facultatif est absent |
| IsError | Indique si une expression est une valeur d'erreur |
| IsNull | Indique si une expression ne contient aucune donnée valide (Null) |
| IsNumeric | Indique si une expression peut être interprétée comme un nombre |
| IsObject | Indique si un identificateur représente une variable objet |
| TypeName | Fournit des informations sur une variable |
| VarType | Indique le sous-type d'une variable de type Variant |
Les fonctions de cette catégorie permettent d'effectuer des traitements sur des variables de type String.
Les fonctions de traitement des chaînes de caractères les plus utilisées sont:
|
|
|
| Asc | Renvoie le code de caractère ANSI ou DBCS du premier caractère d'une chaîne |
| AscB | Renvoie la valeur du premier octet d'une chaîne donnée contenant des données binaires |
| AscW | Renvoie le code de caractère Unicode du premier caractère d'une chaîne |
| Chr | Renvoie une chaîne contenant un code de caractère ANSI ou DBCS spécifique |
| ChrB | Renvoie une chaîne binaire contenant un octet spécifique |
| ChrW | Renvoie une chaîne contenant un code de caractère Unicode spécifique |
| Input | Renvoie le nombre de caractères ANSI ou DBCS indiqué d'un fichier |
| InputB | Renvoie le nombre d'octets indiqué d'un fichier |
| InStr | Renvoie la première occurrence d'une chaîne au sein d'une autre chaîne |
| InStrB | Renvoie la première occurrence d'un octet dans une chaîne binaire |
| Left | Renvoie le nombre de caractères indiqué en partant de la gauche d'une chaîne |
| Right | Renvoie le nombre de caractères indiqué en partant de la droite d'une chaîne |
| LeftB | Renvoie le nombre d'octets indiqué en partant de la gauche d'une chaîne binaire |
| RightB | Renvoie le nombre d'octets indiqué en partant de la droite d'une chaîne binaire |
| Len | Renvoie la longueur de la chaîne en nombre de caractères |
| LenB | Renvoie la longueur de la chaîne en nombre d'octets |
| Mid | Renvoie le nombre de caractères indiqué d'une chaîne |
| MidB | Renvoie le nombre d'octets indiqué d'une chaîne |
Lorsqu'un événement se produit dans votre application, Visual Basic reconnaît automatiquement l'événement et exécute le code que vous avez écrit en conséquence. Ce code est appelé une procédure d'événement (voir schéma ci-dessous).
Exemple de procédure d'événement
Le nom d'une procédure d'événement est composé d'un nom d'objet et d'un nom d'événement. C'est la propriété Name de la feuille ou du contrôle qui définit le nom de l'objet. Dans une procédure d'événement, il peut y avoir une ou plusieurs instructions (voir schéma ci-dessous).
Exemple de procédure d'événement
Comme les fonctions internes de Visual Basic, les fonctions définies par l'utilisateur renvoient une valeur exploitable par l'application. Une fonction définie dans un module source peut être locale au module ou encore globale au programme. Une fonction définie dans une feuille est obligatoirement locale à la feuille.
Une fonction renvoie la valeur d'une variable dont vous devez définir le type. Le résultat doit être affecté au nom de la fonction pour être exploitable dans la procédure appelante.
Des valeurs peuvent également être échangées à l'aide de paramètres, passés par la procédure d'appel avant d'être renvoyé par la fonction.
La syntaxe d'une fonction est:
[ Static ] [ Private ] Function Nom_de_la_fonction ( [ Liste des paramètres ] ) [ As Type ] 'Instructions [ Exit function ] Nom_de_la_fonction = expression End Function |
Le mot réservé Static commande le verrouillage des valeurs de toutes les variables locales entre les appels de la fonction. Private déclare une procédure connue exclusivement du module où elle est déclarée.
Les paramètres sont passés à la fonction par valeur ou par référence. Le passage par valeur ne modifie pas le contenu de la variable pendant ou après le traitement de cette valeur dans la fonction. Par contre, avec le passage par référence, toute action sur la valeur est opérée directement à l'adresse de la variable, dont le contenu est ainsi modifié.
L'exemple suivant illustre le passage des paramètres:
|
|
Function Addition (Val1 As Integer, Val2 As Integer) As Integer Addition = Val1 + Val2 End Function . . Resultat = Addition(125, 75) toto = 24 titi = 32 Resultat = Addition(toto, titi) |
Les procédures définies par l'utilisateur fonctionnent comme les procédures d'événements ou comme les instructions internes de Visual Basic. Contrairement aux procédures d'événements, les procédures définies par l'utilisateur disposent d'une liste de paramètres librement définie.
Une procédure définie dans un module source peut être locale au module ou encore globale au programme. Une procédure définie dans une feuille est obligatoirement locale à la feuille.
La syntaxe d'une procédure est:
[ Static ] [ Private ] Sub Nom_de_la_procédure ( [ Liste des paramètres ] ) 'Instructions [ Exit Sub ] 'Instructions End Sub |
Le mot réservé Static commande le verrouillage des valeurs de toutes les variables locales entre les appels de la fonction. Private déclare une procédure connue exclusivement du module où elle est déclarée. Les paramètres sont passés comme pour la fonction par valeur ou par référence.