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.
|
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.
· 'Passage par valeur
· Sub Addition(ByVal a%, b%)
· a% = a% + b%
· End Sub
· 'Appel de la procédure : a%=234
· Addition a%, 322
· MsgBox a%
· 'a% ne
change pas
· 'Passage par référence
· Sub Addition(a%, b%, ByRef Resultat&)
· Resultat& = a% + b%
· End Sub
· 'Appel de la procédure
· Call Addition (a%, b%, Resultat&)
· MsgBox
Resultat&
· 'Resultat&
est la somme de a% et b%
On peut invoquer une
procédure Sub avec ou sans le
mot clé Call. L'instruction Call
permet de transférer le contrôle à une procédure Sub,
à une fonction Function (La valeur renvoyée
par la fonction est abandonnée) ou à une procédure de bibliothèque de liaisons
dynamiques (DLL). Toutefois, si on a utilisé l'instruction Call, on devrait entourer de parenthèses la liste des arguments.
Tous
les paramètres qui suivent le mot-clé optional
sont des paramètres dits facultatifs. Si vous définissez par exemple une
procédure dans la manière suivante :
· Public Sub
· . . .
· End Sub
son
appel peut avoir la forme suivante :
· Somme Resultat&, 7
ou
· Somme Resultat&, 6, 567
ou
· Call Somme (Resultat&,
5, 856, 32) 'avec l'instruction Call
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
procédure. Les procédures peuvent s'appeler elles-mêmes : ce sont alors des
procédures récursives.
· Sub ProcRecursive (ListeParam)
· 'Instructions
· 'Appel récursif de procédure
· Call ProcRecursive(ListeParam)
· 'Instructions
· End Sub
Si
on veut écrire un programme non événementiel et sans faire appel aux objets (et
ne contenant aucune feuille), on doit posséder une procédure de démarrage Sub Main qui sera le programme
principal parce que les instructions en VB doivent être mises obligatoirement
dans une procédure.
8)
Fonctions
prédéfinies
8. 1) Fonctions mathématiques
VB dispose de toutes les fonctions mathématiques nécessaires au calcul. La fonction Round permet d'arrondir les valeurs à un nombre donné de décimales. Si on ne fixe pas le nombre de décimales, la valeur renvoyée sera sous forme d'entier.
· 'Syntaxe de cette fonction
· resultat
= Round(Expression [, nombre_de_décimales])
· 'Exemple
· resultat
=Round(5.3456, 2) :'resultat
= 5.34
On a aussi les fonctions suivantes : Abs (valeur absolue), Round, Sin, Cos, Tan (Tangente), Atn (Arc tangente), Exp, Log (logarithme base e), Fix (Partie entière), Int (Partie entière), Rnd (Génération d'un nombre aléatoire), Sgn (signe : nombre > 0 retourne 1, nombre = 0 retourne 0, nombre < 0 retourne -1), Sqr (racine carrée).
8. 2) Fonctions de chaînes de caractères
VB dispose de toutes les fonctions nécessaires à la gestion des chaînes de caractères.
Les fonctions LTrim$, RTrim$, Trim$ qui suppriment les espaces gênants dans les chaînes de caractères. LTrim$ supprime tous les espaces au début de la chaîne (à gauche de la chaîne), RTrim$ supprime tous les espaces à la fin de la chaîne et Trim$ supprime les espaces en début et à la fin de la chaîne.
La fonction Left$ renvoie une chaîne de caractères contenant le nombre indiqué de caractères en partant de la gauche (elle supprime le reste). Right$ fait la même chose dans la partie droite d'une chaîne de caractères. Pour éliminer une portion quelconque d'une chaîne de caractères on peut utiliser la fonction Mid$.
· 'Récupérer les 5 premiers
caractères gauches d'une chaîne
·
Nouveau$ = Left$(Ancienne$, 5)
· 'Récupérer les 5 derniers
caractères droits d'une chaîne
· Nouveau$ = Right$(Ancienne$, 5)
· 'Récupérer 5 caractères d'une
chaîne à partir du 3e caractère
· Nouveau$ = Mid$(Ancienne$, 3, 5)
La fonction Instr permet de savoir si une chaîne de caractères se trouve dans une autre chaîne de caractères. Cette fonction renvoie un Long indiquant la position de la première occurrence d'une chaîne à l'intérieur d'une autre chaîne. On peut définir le point de départ de la recherche dans la chaîne.
· Mypos&
= Instr(Total$, Partie$)
· Mypos&
= Instr(5, Total$, Partie$)
La fonction UCase$ convertit une chaîne de caractères en majuscules, la fonction LCase$ effectue la conversion en minuscules. La taille d'une chaîne de caractères est renvoyée par la fonction Len. Notons qu'on peut appeler les fonctions de traitements des chaînes de caractères sans le caractère $. La fonction Val convertit une chaîne de caractères contenant des nombres en une valeur numérique. L'opération inverse est effectuée par l'instruction Str.
· L$ = LCase$("ABC")
: U$ = UCase$("def")
: Longueur = Len(L$)
· A% = Val("123")
· chaine$ = Str(123)
Les nouvelles fonctions de VB6 concernant les chaînes de caractères permettent de faciliter le traitement (ces fonctions peuvent être remplacées par les précédentes).
La fonction Filter permet à partir d'un tableau de chaînes de caractères d'obtenir un nouveau tableau partiel de résultat rassemblant tous les éléments (les chaînes de caractères) contenant ou non le critère de recherche. La syntaxe de cette fonction est la suivante :
· TableautCible$
= Filter(TableauSource$(), ChaineRecherche [,
Récupérer [, Comparer]])
Les tableaux source et cible doivent être déclarés
avant l'appel et le tableau source doit avoir été initialisé. Le paramètre
ChaineRecherche est la chaîne recherchée dans les divers éléments du tableau
source. Si la valeur du paramètre Récupérer est True, tous les éléments
contenant le critère de recherche sont récupérés dans le tableau cible. Avec la
valeur False, Le tableau cible ne reprend que les éléments ne contenant pas le
critère de recherche. Le paramètre Comparer permet de définir le type de
comparaison. Les constantes prédéfinies pour ce paramètre sont les suivantes : VbUseCompareOption (La comparaison
est effectuée avec l'option Compare), VbBinaryCompare (Comparaison binaire),
VbTextCompare (Comparaison au niveau du
texte), VbDatabasecompare (Comparaison à partir des informations d'une base
de données MS Access uniquement).
L'exemple
suivant, montre l'utilisation de Filter. Nous
parcourons deux fois un tableau de chaînes de caractères à la recherche du mot
"est". Le premier tableau de résultat Rés1$() reprend tous les
éléments dans lesquels la chaîne recherchée a été trouvée. Le deuxième tableau
de résultat Rés2$() reprend tous les éléments ne contenant pas le critère de
recherche. Les résultats obtenus sont redirigés dans la fenêtre Exécution par
mesure de simplicité (Debug.Print).
· Private Sub Form_Load()
· Dim Text$(0 To
2) 'Déclaration du tableau
source
· Dim Rés1$(), Rés2$() 'Déclaration
dynamique des tableaux de résultat
· Dim x%
· 'Initialisation du tableau source
· Text$(0) = "Ceci est un exemple de
texte"
· Text$(1) = "Grand Bonjour"
· Text$(2) = "Visual Basic 6.0 est
nouveau"
· 'Filtrer les éléments correspondant au
critère
· Rés1$ = Filter(Text$(),
"est", True)
· 'Filtrer les éléments ne répondant pas au
critère
· Rés2$ = Filter(Text$(),
"est", False)
· 'Afficher les éléments correspondant au
critère
· For x% = LBound(Rés1$)
To UBound(Rés1$)
· Debug.Print Rés1$(x%)
· Next x%
· 'Afficher les éléments ne répondant pas au
critère
· For x% = LBound(Rés2$)
To UBound(Rés2$)
· Debug.Print Rés2$(x%)
· Next x%
· End Sub
Avec
la fonction Join, il est possible de chaîner, de concaténer des chaînes
de caractères en une nouvelle chaîne. Cette fonction a un paramètre facultatif
qui permet de décider si les chaînes partielles doivent avoir un séparateur ou
non. En voici la syntaxe :
· ChaîneTotale$ = Join (TableauChaînes$() [,
Séparateur])
Dans
l'exemple suivant, les chaînes partielles concaténées dans la chaîne globale
sont séparées par le caractère "|". Ce séparateur permet,
éventuellement en utilisant la fonction Split, de retrouver les chaînes partielles
initiales. Si vous n'indiquez pas de séparateur, Visual Basic met automatique
en place un espace, ce qui pose souvent problème pour les scissions
ultérieures. Pour éviter l'espace automatique, on peut utiliser comme
séparateur "".
· Private Sub Form_Load()
· 'Concaténer les éléments d'un tableau de
chaînes partielles en une chaîne globale
· Dim Text$() : Dim ChaîneTotale$ : Dim x% : ReDim Text$(0 to 2)
· Text$(0) = "Ceci est un exemple de
texte"
· Text$(1) = "Grand Bonjour"
· Text$(2) = "Visual Basic 6.0 est
nouveau"
· ChaîneTotale$ = Join(Text$(), "|") 'Concaténation
· Debug.Print ChaîneTotale$
· End Sub
La
fonction Split permet de fractionner des chaînes de caractères stockées
dans un tableau en fonction d'un caractère de séparation. En voici la syntaxe :
· Dim Résultat$()
· Résultat$ = Split(ChaîneTotale$, Séparateur$ [, Nombre& [, Comparer]])
Le
paramètre ChaîneTotale$ est la chaîne de caractères à
fractionner et séparateur$ est le caractère de séparation, sachant que ce
séparateur n'est pas repris dans le résultat de la fonction. Nombre& est le
nombre de remplacements à effectuer (par défaut, toutes les occurrences).
Comparer est le même qu'avec la fonction Filter, il
détermine le type de comparaison.
· Private Sub Form_Load()
· Dim Rés$()
· Dim ChaîneTotale$
: Dim x%
· ChaîneTotale$ = "Peter@Paul@Mary"
· Rés$ = Split(ChaîneTotale$, "@")
· For x% = LBound(Rés()) To UBound(Rés())
· Debug.Print Rés$(x%)
· Next x%
· End Sub
La
fonction Replace permet de remplacer dans une chaîne de caractères une partie
de cette chaîne par une autre chaîne. Si la chaîne recherchée intervient
plusieurs fois, un appel unique de la fonction permet de procéder à plusieurs
remplacements. En voici la syntaxe :
· Résultat$
= Replace(ChaîneTot$, Cherche$, Remplace$ [[[, Déb&], Nombre&], Comp])
Le
paramètre ChaîneTot$ contient la chaîne à parcourir, le paramètre cherche$ est
la chaîne recherchée, Remplace$ est la chaîne de remplacement. Le paramètre
Déb& définit à partir de quelle position, dans la chaîne globale, la recherche
doit commencer. Par défaut, il s'agit de la position 1. Nombre& est le
nombre de remplacements à effectuer (par défaut, toutes les occurrences). Le
paramètre Comp est le même qu'avec la fonction
Filter, il détermine le type de comparaison.
· Private Sub Form_Load()
· ChaîneTotale$ = "Ceci est le texte à
parcourir..."
· Chercher$ = "texte"
· Remplacer$ = "texte intégral"
· Rés$ = Replace(ChaîneTotale$,
Chercher$, Remplacer$)
· MsgBox Rés$
· End Sub
La
fonction StrConv permet de convertir des
chaînes de caractères en majuscules, en minuscules ainsi qu'en Unicode (système
de codage qui permet de représenter 65536 caractères sur 2 octets) et en
respectant les paramètres de la table de conversion des caractères du système.
· Résultat$ = StrConv
(Chaîne$, Conversion)
Le
paramètre Chaîne$ est la chaîne à convertir, Conversion est le type de
conversion. Ce paramètre peut prendre une des constantes prédéfinies suivantes
: VbUpperCase (Conversion en majuscules), VbLowerCase (Conversion en
minuscules), VbProperCase (Le premier caractère de tous les mots en majuscule),
VbUnicode (Conversion en Unicode), VbFromUnicode (Conversion d'une chaîne
Unicode en chaîne normale).
La
fonction StrReverse permet d'inverser une chaîne de caractères. Pour
parcourir une chaîne de caractères de droite vers la gauche.
· MsgBox StrReverse("ABCOEFG")
8. 3) Fonctions d'heure et de date
Visual
Basic dispose de plusieurs instructions qui facilitent grandement les
manipulations de dates et d'heures. Les comparaisons entre dates ne posent plus
aucune difficulté. On distingue à ce titre les fonctions de base, déjà
disponibles dans les versions précédentes de Visual Basic, et les fonctions
étendues, spécifiques à Visual Basic 6 ou à la version actuelle de VBA.
Deux
fonctions de base sont disponibles. La fonction Date qui permet de lire
et définir la date système. Le format utilisé est le suivant : jj/mm/aaaa.
· Dim Cejour
As Date
· Cejour = Date : 'Cejour contient la date
d'aujourd'hui
La
même instruction peut être utilisée pour définir la date du système.
· Date = #21/07/2001# : 'initialisation avec
une chaîne de caractères
La
deuxième fonction est Time qui permet de lire et définir l'heure
système. Le format utilisé est le suivant : hh:mm:ss. Cette même fonction
permet de définir l'heure.
· Dim Heure As Date
· Heure = Time
· Time = #
Les
fonctions d'heure et de date étendues permettent de calculer à partir de dates
ou d'heures et de lire des informations partielles à partir des dates. Le jour,
le mois et l'année (des entiers) sont renvoyés par les fonctions Day, Month
et Year appliquées à la valeur d'une date.
· Jour% = Day(Cejour) : 'Jour : 1-31
· Mois% =Month(Cejour) : 'Mois : 1-12
· Annee% = Year(Cejour) : 'Année
La
fonction inverse DateSerial renvoie la valeur numérique format date
correspondant à une année, un mois et un jour. DateValue renvoie une
valeur numérique format date pour une date passée dans le format de chaîne de
caractères.
· Dim ValeurDate
As Date
· ValeurDate = DateSerial(Year(Cejour), Month(Cejour), Day(Cejour))
· ValeurDate = Datevalue("12
mai 1997")
Pour
connaître l'heure, la minute et la seconde correspondant à une valeur horaire,
on a les fonctions Hour, Minute et Second. La fonction TimeSerial
renvoie une valeur de type Date contenant une heure précise (heure, minute et
seconde). Les valeurs d'heures différentes peuvent être comparées
immédiatement, sans les décomposer en heures, minutes et secondes.
· ValeurHeure = TimeSerial(Hour(Heure),
Minute(Heure), Second(Heure))
Avec
la fonction Timevalue, on obtient la valeur numérique format date d'une
heure exprimée sous forme de chaîne de caractères. Le jour de la semaine d'une
date du type integer est fourni par la fonction Weekday
(Dimanche = 1 , Lundi= 2, etc.). La date et l'heure
courantes format date sont fournies par la fonction Now.
Visual
Basic dispose de fonctions pour calculer facilement des dates et des heures. La
fonction DateAdd permet d'ajouter une durée à la date actuelle. Cette
fonction, qui renvoie une valeur de type date, a la syntaxe suivante :
· Resultat = DateAdd(intervalle,
Valeur, MaDate)
On
transmet à la fonction une chaîne de caractères précisant l'intervalle à
ajouter à la date (voir le tableau tab7 en annexe). Le nombre d'intervalles est
défini par Valeur, et la date sur laquelle porte l'addition est indiquée dans
le paramètre MaDate.
· 'Ajouter 5 mois à la date actuelle
· MsgBox DateAdd("m",
5 , MaDate)
· 'Ajouter 10 heures à la date, l'heure,
actuelles
· MsgBox DateAdd("h",
10, Heure)
Pour
évaluer la différence entre deux dates, on utilise la fonction DateDiff,
qui renvoie un long indiquant le nombre d'intervalles de temps entre deux dates
données, selon la syntaxe suivante :
· Résultat& = DateDiff
(intervalle, Date1, Date2 [, PremJourSem[,
PremSemAnnee]])
Le paramètre Intervalle contient une chaîne de
caractères indiquant l'unité dans laquelle la différence sera retournée (voir
le tableau tab7 en annexe). Le paramètre optionnel PremJourSem désigne le jour
par laquelle la semaine commence (par défaut VbSunday), et PremSemAnnee, la semaine
par lequel débutera la numérotation sur l'année (par défaut :VbFirstJan1).
Le tableau tab8 en annexe présente les valeurs que les constantes
système des paramètres optionnels peuvent prendre.
· 'Calculer une différence en mois (ici 3 mois)
· MsgBox DateDiff("m",
"12-03-1997", "12-6-1997")
· 'Calculer une différence en heures (ici 12
heures)
· MsgBox DateDiff("h",
"10:15:30", "22.12:45")
La
fonction DatePart renvoie un entier contenant l'élément spécifié d'une
date ou d'une heure donnée. Sa syntaxe est :
· Résultat = DatePart(Intervalle,
Date [, PremJourSemaine[, PremSemaineAnnee]])
Le
paramètre Intervalle précise l'intervalle et le paramètre date est la date sur
laquelle Résultat est calculé. L'instruction suivante lit le mois actuel et
l'affiche dans une boîte de message.
· MsgBox DatePart("m",
Cejour)
Avec
la fonction MonthName, il est possible d'obtenir le nom du mois
correspondant à sa valeur numérique. Un deuxième paramètre facultatif du type booléen indiquant si on souhaite
d'obtenir un nom abrégé (True) ou non. La syntaxe de cette fonction est la
suivante :
· Mois$ = MonthName(Mois%
[, Abrégé])
Si
cette valeur est omise, la valeur par défaut est False, ce qui signifie que le
nom du mois n'est pas abrégé.
· Mois$ = MonthName(12,
False) : 'Retourne Décembre
· Mois$ = MonthName(12,
True) : 'Retourne Déc
Avec
la fonction WeekdayName, il est possible d'obtenir le nom des jours
correspondant à leur valeur numérique, en option sous la forme abrégée. En
voici la syntaxe :
· Jour$ = WeekdayName(Jour,
[Abrégé [, PremierJourSemaine]])
Le
jour considéré comme premier jour de la semaine peut être défini par le
paramètre optionnel PremierJourSemaine (voir tab8 en annexe).
'Syntaxe générale
· Jour$ = WeekdayName(1) : 'retourne
Dimanche
· Mois$ = MonthName(2,
False) : 'retourne lun
· Mois$ = MonthName(2,
Flase, True, VbMonday) : 'retourne mardi
8. 4) Fonctions de conversion et de formatage
Les fonctions de conversion permettent de transférer une valeur d'un type de données dans un autre type.
La fonction Asc renvoie le code ASCII du premier caractère d'une chaîne de caractères.
· Valeur% = Asc(Texte$)
Dans le sens contraire, la fonction Chr$ retourne le caractère si on connaît son code ASCII
· Caractere$
= Chr(32) : 'le caractère espace
Les fonctions CBool(expression) : booléen, CByte(expression) : octet, CCur(expression) : Currency, CDate(expression), CDec(expression) : décimal, CInt(expression) : integer, CLng(expression) : long, CSng(expression) : single, CDbl(expression) : double, CVar(expression) : Variant, CStr(expression) : string convertissent une expression de chaîne de caractères ou expression numérique en un type de données spécifique.
La fonction Val convertit une chaîne de caractères numérique en une valeur numérique. Inversement, on peut avec la fonction Str$ convertir une valeur numérique en une chaîne de caractères. La fonction Fix convertit en entier un nombre (un réel).
· Valeur%= Val("123")
: 'résultat Valeur%=123
· Chaine$ = Str$(123) : 'résultat Chaine$ =
"123"
· Valeur%= Fix(123.456)
: 'résultat Valeur%=123
La fonction Format$ permet de formater des nombres, des chaînes de caractères mais aussi des dates et des heures. Elle renvoie une valeur de type chaîne de caractères contenant une expression formatée en fonction des instructions contenues dans la chaîne de formatage (le paramètre Format).
· Chaine$= Format(Expression
[, Format])
Dans cette chaîne on utilise les caractères génériques de substitution (#, 0).
· Chaine = Format(5459.4,
"##,##0.00") ' renvoie
"5 459.40"
· Chaine = Format(5459.4,
"##,##") ' renvoie "5
459"
· Chaine = Format(334.9,
"###0.00") ' renvoie
"334.90"
· Chaine = Format(5,
"0.00%") ' renvoie
"500.00%"
· Chaine = Format("BONJOUR",
"<") ' renvoie
"bonjour"
· Chaine = Format("Et
voilà!", ">") ' renvoie "ET VOILÀ!"
La fonction FormatNumber, qui renvoie une expression formatée sous forme de nombre, est destinée à la mise en forme des valeurs numériques. Sa syntaxe est :
· FormatNumber(Expression [,
NumDigitsAfterDecimal])
Le paramètre NumDigitsAfterDecimal (facultatif) est une valeur numérique indiquant combien de positions à droite de la virgule sont affichées. La valeur par défaut (-1) indique que les paramètres régionaux de l'ordinateur définis dans le panneau de configuration sont employés.
9)
Les fichiers
VB possède toutes les fonctions essentielles de gestion des fichiers séquentiels, binaires et à accès direct.
9. 1) Les fichiers textes
Dans les fichiers textes (séquentiels), les informations sont lues et écrites ligne par ligne. Chaque information peut avoir une longueur différente. L'accès direct à une ligne de ces fichiers est impossible. Il faut lire tout le fichier depuis le début jusqu'à la ligne recherchée, ce qui est très lent, ou mettre toutes les données dans la mémoire (dans un tableau par exemple) et les gérer dans la mémoire pour accélérer, ce qui revient à limiter la taille du fichier à la mémoire disponible. Les fichiers séquentiels permettent de gérer en outre du texte. Ils peuvent être ouverts selon deux procédures différentes soit en lecture soit en écriture.
Pour lire les données d'un fichier séquentiel, on doit l'ouvrir en utilisant le mot-clé Input avec l'instruction Open. Un fichier ne peut être ouvert qu'en un seul exemplaire. Si on tente de l'ouvrir une 2e fois, cela provoque une erreur d'exécution.
Avant d'utiliser Open, on doit faire appel à la fonction FreeFile qui renvoie un entier représentant le prochain numéro de fichier pouvant être utilisé par l'instruction Open. Ce numéro est compris entre 1 et 511 inclus. Cette étape peut être omise en gérant nous même la distribution des numéros.
· 'mode
de lecture dans un fichier séquentiel
· Numfich% = FreeFile
· Open "f:\22-ensgt\pok.dat" For Input As #NumFich%
Pour lire une ligne dans le fichier, on utilise l'instruction Input avec le numéro du fichier.
· Input #Numfich%,
Ligne$
L'affectation immédiate des valeurs lues à des variables est possible à condition que ces variables soient déclarées et les valeurs soient compatibles.
· Input #Numfich%, a%, b%, c%
Si on désire lire le fichier dans sa totalité, on peut détecter la fin du fichier avec la fonction EOF qui renvoie un booléen vrai si on est à la fin du fichier. Cette fonction a un paramètre qui est le numéro de fichier.
· 'Lecture d'un fichier séquentiel
entière
· i% = 0
· While
Not EOF(Numfich%) 'cette
fonction utilise Numfich% sans #
· Input #numfich%, tableau%(i%)
· Debug.Print tableau%(i%)
'Affiche dans la fenêtre Exécution
· i% = i% + 1
· Wend
Tout fichier ouvert doit être fermé à l'aide de l'instruction Close.
· Close #Numfich%
L'ouverture d'un fichier séquentiel en écriture se fait en utilisant le mot-clé Output. Si un fichier sous le même nom existe déjà, il sera remplacé sans aucun avertissement. S'il n'existe pas, ce fichier sera créé. Là aussi, il faut utiliser la fonction FreeFile pour récupérer un numéro de fichier libre.
· 'mode
d'écriture dans un fichier séquentiel
· Numfich% = FreeFile
· Open "f:\22-ensgt\fich7.txt" For Output As #NumFich%
On peut aussi ouvrir un fichier séquentiel en mode d'ajout séquentiel. Dans ce cas, les données d'un fichier existant sont conservées et les nouvelles données sont simplement ajoutées à la fin de fichier. Pour ouvrir un fichier en mode d'ajout, il faut utiliser le mot-clé Append.
· 'mode
d'ajout dans un fichier séquentiel
· Numfich% = FreeFile
· Open "f:\22-ensgt\fich7.txt" For Append As #NumFich%
Quand le fichier séquentiel est ouvert en écriture ou en ajout, on peut y écrire des données avec l'instruction Print. Cette instruction écrit des données mises en forme et rajoute un passage à ligne à la fin. Donc, on peut utiliser avec cette instruction la fonction Spc(n) pour insérer n espaces et la fonction Tab(n) pour insérer n tabulations.
· Print #Numfich%, Ligne$
· Print #Numfich%,
a%, b%, c% 'La virgule et le point-virgule sont des séparateurs
· Print #Numfich%,
Tab(10); "bonjour" 'Écrit le
mot à partir de la colonne 10
L'instruction Write écrit des données brutes dans un fichier séquentiel sans faire la mise en forme (sans pouvoir utiliser les fonctions Spc(n) et Tab(n)), sépare les données dans le fichier par des virgules et rajoute un passage à ligne à la fin. Ces données peuvent être des valeurs numériques ou des chaînes de caractères.
· Write #Numfich%, "le
résultat est : ", a%
La dernière étape ici aussi consiste à fermer le fichier avec l'instruction Close.
La fonction Seek(NumFich%) appliquée à un fichier séquentiel renvoie une valeur de type entier long indiquant la position de lecture/écriture courante.
· position& = Seek(NumFich%)
La taille du fichier exprimée en octets est obtenu en utilisant la fonction LOF(NumFich%) qui renvoie un entier long :
· Taille& = LOF(NumFich%)
9. 2) Les fichiers à accès direct
Dans les fichiers à accès direct, toutes les données (les éléments) ont la même taille en octets. Cela permet d'accéder très rapidement à un élément sans lire tout le fichier. Ces fichiers sont fréquemment utilisés pour gérer de grandes quantités de données.
L'ouverture d'un fichier à accès direct se fait à l'aide de l'instruction Open et en utilisant le mot-clé Random comme mode d'ouverture. En absence de mode d'ouverture le fichier est ouvert en fichier à accès direct. Ceci doit être fait après avoir utilisé la fonction FreeFile.
· Open "Donnees.dat" For Random As
#NumFich Len=Len(VarDat)
La fonction Len renvoie le nombre d'octets occupés par son paramètre. VarDat est la variable qui représente un élément de ce fichier. Cette variable peut être de type personnalisé. Donc, il s'agit d'un enregistrement constitué de plusieurs champs.
· Type Enregistrement
· Champ1 As Integer
· Champ2 As String*50 'chaîne de
caractères statique de taille fixe
· Champ3 As Double
· End Type
· Dim VarDat
As Enregistrement
La lecture et l'écriture d'un élément, quel que soit son type, d'un fichier à accès direct se fait en utilisant l'instruction Get pour la lecture et l'instruction Put pour l'écriture.
· Get #NumFich, NumEnreg&, VarDat
· Put #NumFich, NumEnreg&, VarDat
La position courante dans le fichier est actualisée automatiquement. Chaque fois qu'on utilise l'instruction Get, on avance d'un élément dans le fichier. Avec l'instruction Put la position courante est aussi actualisée. Chaque fois qu'on utilise l'instruction Put, on avance d'un élément dans le fichier. L'argument NumEnreg& (facultatif) est un entier long qui représente le numéro de l'enregistrement à lire ou à écrire sachant que le premier enregistrement occupe la position 1, le deuxième enregistrement la position 2, et ainsi de suite. Donc, cet argument peut être utilisé pour faire l’accès direct pour lire ou écrire un élément donné. Si cet argument est omis, la lecture commence à partir de l'enregistrement courant. Par contre, il est nécessaire d'inclure des séparateurs virgules.
· Get #NumFich, , VarDat
Le nombre d'enregistrements d'un fichier à accès direct est obtenu par l'expression suivante en utilisant la fonction LOF qui renvoie un entier long représentant la taille du fichier exprimée en octets :
· NombreEnreg& = LOF(NumFich)\Len(VarDat)
Pour accéder aux champs, il faut mettre la variable enregistrement suivie d'un point suivi par le nom du champ. Pour lire les contenus des champs d'une variable d'enregistrement, il faut procéder comme suit :
· index%
= VarDat.Champ1
· chaine$
= VarDat.Champ2
· reeldouble# = VarDat.Champ3
Pour affecter des valeurs aux champs d'une variable d'enregistrement, on utilise :
· VarDat.Champ1 =354
· VarDat.Champ2 = "Grand
bonjour"
· VarDat.Champ3 =456.9817
L'instruction Seek permet de se positionner dans un fichier à accès direct. position& est un entier long qui indique l'endroit où l'opération de lecture ou d'écriture suivante doit avoir lieu.
Une écriture effectuée dans un fichier à accès direct après exécution de l'instruction Seek au-delà de la fin du fichier a pour effet d'étendre ce fichier.
· Seek #NumFich, position&
Une fonction qui porte le même nom Seek(NumFich) appliquée à un fichier à accès direct renvoie une valeur de type entier long indiquant la position de lecture/écriture courante.
· position& = Seek(NumFich)
On peut aussi utiliser avec les fichiers à accès direct la fonction EOF(NumFich) qui détecte la fin du fichier en renvoyant la valeur vrai si on est à la fin du fichier.
Le paramètre facultatif "access" permet de préciser les opérations autorisées sur le fichier ouvert Read, Write ou Read Write (par défaut) :
· Open "Donnees.dat" For Random Access Read As #NumFich Len(VarDat)
· Open "Donnees.dat" For Random Access Write As #NumFich Len(VarDat)
La fermeture à la fin d'un fichier à accès direct se fait à l'aide de l'instruction Close.
· Close #Numfich
9. 3) Les fichiers binaires
Les fichiers binaires sont des fichiers de tout type y compris les fichiers EXE. Les données sont lues et écrites octet par octet.
Un fichier est ouvert en mode binaire avec le mot-clé Binary.
· Open "Data.bin" For Binary Access
Read As #NumFich
· Open "Data.bin" For Binary Access
Write As #NumFich
La lecture et l'écriture des données en mode binaire sont commandées par l'instruction Get et l'instruction Put.
· Dim BinVar
As Byte
· Get #NumFich, , BinVar
· Put #NumFich, , BinVar
L'instruction Seek ici définit la position de l'octet à partir duquel l'opération suivante doit s'effectuer.
Le nombre d'octets lus et écrits dépend du type de données de la variable nommée BinVar. Si BinVar est déclaré en tant que Byte, on lit et on écrit dans le fichier octet par octet. Si cette variable est déclarée en tant qu'entier simple (integer), chaque Get et Put lit et écrit deux octets. En général, on utilise des variables de type chaîne de caractères.
· Dim BinVar As String
· BinVar = Space(20000)
· Get #NumFich, , BinVar
La fonction Space permet de créer une chaîne de caractères comprenant le nombre d'espaces de son paramètre. Dans l'exemple précédent, chaque opération de lecture place 20000 octets dans la variable BinVar c.a d. dans la mémoire.
10)
Instructions
de gestion des erreurs d'exécution
Les erreurs d'exécution se produisent après le début de l'exécution de l'application. Voici quelques actions qui pourraient générer des erreurs d'exécution : lecture ou écriture dans un fichier inexistant, rencontre d'un conflit de données, division d'une valeur par zéro, etc.
Les commandes et fonctions suivantes sont utiles pour anticiper et gérer les erreurs d'exécution. On Error permet d'activer un sous-programme de traitement lorsqu'une erreur se produit. Ceci doit se terminer par Resume (pour tenter une nouvelle exécution de la ligne de l'erreur) ou par Exit Sub. La commande Resume Next commande la reprise immédiate de l'exécution du programme après la ligne où l'erreur s'est produite, Resume 0 et Resume tentent une nouvelle exécution de la ligne de l'erreur. Avec Resume étiquette, on peut aiguiller le programme vers une étiquette dans le code après le traitement d'une erreur.
Pour éviter les blocages du programme par survenance d'une erreur, on peut utiliser l'instruction :
· On Error
Resume Next
Ainsi, en cas d'erreur dans une instruction, le programme saute cette instruction et passe automatiquement à la suivante.
· [Sub|Function] nom_de_procedure ([liste des paramètres])
· 'activer la gestion des erreurs en les ignorant
· On Error Resume Next
· 'autres instructions
· Exit [Sub|Function]
Si l'erreur empêche la poursuite correcte du programme, la seule solution est d'installer un sous-programme de traitement des erreurs. Dans ce cas, on utilise l'instruction On Error suivie d'une commande de saut Goto vers une étiquette. Ce traitement d'erreur peut à tout moment être désactivé par l'instruction On Error Goto 0.
· [Sub|Function]
nom_de_procedure ([liste des paramètres])
· 'activer
la gestion des erreurs
· On Error
Goto Erreur
· 'autres
instructions
· 'inactiver
la gestion des erreurs
· On Error Goto 0
· Exit [Sub|Function]
· erreur: 'étiquette
· Msgbox
"L'erreur = " & Str(Err.Number)
& " a été générée par " _
· & Err.Source
& Chr(13)
& Err.Description
· End [Sub|Function]
L'objet Err Contient des informations sur les erreurs d'exécution. A partir de cet objet, on peut accéder à un ensemble d'informations qui sont les propriétés de cet objet comme Err.Number (le numéro d'erreur) ou Err.Source (le message) ou Err.Description.
11)
Instructions
d'impression
L'objet Printer permet de procéder à des impressions. Ses propriétés nous aident à définir par exemple l'aspect de l'impression, comme la police (propriété FontName), sa taille (FontSize) et ses attributs (FontBold, FontUnderline, etc.), la position de l'impression (CurrentX et CurrentY), le numéro de page (propriété page) ainsi que le facteur d'agrandissement ou de réduction. Les instructions d'impression sont envoyées par des méthodes. La 1re méthode est EndDoc qui met fin à l'opération d'impression du document et envoie le document au périphérique d'impression ou au spouleur.
· Printer.EndDoc
La méthode NewPage commande un saut de page. La méthode print envoie des données à l'imprimante. Outre la définition des espaces et des tabulations, nous pouvons aussi demander le saut de ligne automatique (par défaut). Pour l'interdire, il faut ajouter un point virgule à la fin de la liste d'expression.
· 'exemple
avec saut de ligne
· Printer.Print
"Grand Bonjour"
· Printer.Print
Spc(3) "Grand Bonjour" '3 espaces et un texte
· Printer.Print
Tab(2) a%, b% ,c% '2
tabulations et 3 variables
· 'exemple
sans saut de ligne
· Printer.Print
"Grand Bonjour" ; 'écriture
sans passer à la ligne
· Printer.Print
a%, b% ,c% ; '
écriture sans passer à la ligne
Annexes
|
Tab
1 : Les instructions DefType et les types de
données |
|||
Instruction
|
Type de données
|
Plage par défaut
|
|
|
DefBool
|
Boolean |
Valeur Booléenne |
|
|
DefByte |
Byte |
Byte |
|
|
DefInt |
Integer |
Entier |
|
|
DefLng |
Long |
Entier
long |
|
|
DefSng |
Single |
Réel
en simple précision (virgule flottante) |
|
|
DefDbl |
Double |
Réel
en double précision (virgule flottante) |
|
|
DefCur |
Currency |
Monétaire |
|
|
DefDate |
Date |
Date |
|
|
DefStr |
String |
Chaîne
de caractères |
|
|
DefObj |
Object |
Objet |
|
|
DefVar |
Variant |
Variant |
|
|
|
Tab 2 : Constantes de touches spéciales |
|||
Constantes diverses
|
Description
|
Equivalent
|
|
|
VbCrLf |
Retour
chariot+Saut de ligne |
Chr$(13)+Chr$(10) |
|
|
VbCr |
Retour
chariot |
Chr$(13) |
|
|
VbLf |
Saut
de ligne |
Chr$(10) |
|
|
VbNewLine |
Nouvelle
ligne |
Chr$(13)+Chr$(10) ou Chr$(13) |
|
|
VbNullChar |
Null (ASCII Zéro) |
Chr$(0) |
|
|
VbNullString |
Chaîne
de caractères nulles |
|
|
|
VbTab |
Tabulation |
Chr$(9) |
|
|
VbBack |
Effacement
arrière |
Chr$(8) |
|
|
VbFormFeed |
Ejecte
feuille |
Chr$(12) |
|
|
VbVerticalTab |
Tabulation
verticale |
Chr$(11) |
|
|
|
Tab 3 : Constantes de caractères de contrôle |
|||
Constantes clavier
|
Commande clavier
|
Equivalent (hexadécimal)
|
|
|
VbKeyLButton |
Bouton
souris gauche |
0x1 |
|
|
VbKeyRButton |
Bouton
souris droite |
0x2 |
|
|
VbKeyMButton |
Bouton
souris milieu |
0x4 |
|
|
VbKeyBack |
Effacement
arrière |
0x8 |
|
|
VbKeyTab |
Tabulation |
0x9 |
|
|
VbKeyReturn |
Entrée |
0xD |
|
|
VbKeyShift |
Majuscule |
0x10 |
|
|
VbKeyControl |
Ctrl |
0x11 |
|
|
VbKeyMenu |
Menu |
0x12 |
|
|
VbKeyPause |
Pause |
0x13 |
|
|
VbKeyCapital |
Verrouillage
majuscule |
0x14 |
|
|
VbKeyEscape |
Echap |
0x1B |
|
|
VbKeySpace |
Espace |
0x20 |
|
|
VbKeyPageUp |
Page
précédente |
0x21 |
|
|
VbKeyPageDown |
Page
suivante |
0x22 |
|
|
VbKeyEnd |
Fin |
0x23 |
|
|
VbKeyHome |
Début |
0x24 |
|
|
VbKeyLeft |
Flèche
gauche |
0x25 |
|
|
VbKeyUp |
Flèche
vers le haut |
0x26 |
|
|
VbKeyRight |
Flèche
droite |
0x27 |
|
|
VbKeyDown |
Flèche
vers le bas |
0x28 |
|
|
VbKeyPrint |
Impression |
0x2A |
|
|
VbKeyKeyInsert |
Insertion |
0x2D |
|
|
VbKeyDelete |
Suppression |
0x2E |
|
|
VbKeyNumLock |
Verrouillage
numérique |
0x90 |
|
|
VbKeyF1
à VbKeyF16 |
Touches
de fonctions F1 à F16 |
|
|
|
|
Tab 4 : Les constantes de couleurs et les
constantes système |
|||
Constantes de couleurs
|
Couleur
|
Equivalent (hexadécimal)
|
|
|
VbBlack
|
Noir |
0x0 |
|
|
VbRed |
Rouge |
0xFF |
|
|
VbGreen |
Vert |
0xFF00 |
|
|
VbYellow |
Jaune |
0xFFFF |
|
|
VbBlue |
Bleu |
0xFF0000 |
|
|
VbMagenta |
Magenta |
0xFF00FF |
|
|
VbCyan |
Cyan |
0xFFFF00 |
|
|
VbWhite |
Blanc |
0xFFFFFF |
|
|
VbScrollBars |
Barres
de défilement |
0x80000000 |
|
|
VbDesktop |
Bureau |
0x80000001 |
|
|
VbActiveTitleBar |
Couleur
barre de titre actif |
0x80000002 |
|
|
VbInactiveTitleBar |
Couleur
barre de titre inactif |
0x80000003 |
|
|
VbMenuBar |
Couleur
de fond de menu |
0x80000004 |
|
|
VbWindowBackground |
Couleur
de fond de fenêtre |
0x80000005 |
|
|
VbWindowFrame |
Encadrement
fenêtre |
0x80000006 |
|
|
VbMenuText |
Texte
de menu |
0x80000007 |
|
|
VbWindowText |
Texte
de fenêtre |
0x80000008 |
|
|
VbTitleBarText |
Texte
de barre de titre |
0x80000009 |
|
|
VbActiveBorder |
Cadre
actif |
0x8000000A |
|
|
VbInactiveBorder |
Cadre
inactif |
0x8000000B |
|
|
VbApplicationWorkspace |
Zone
de travail d'une fenêtre |
0x8000000C |
|
|
VbHeighlight |
Couleur
de fond de la sélection |
0x8000000D |
|
|
VbHighLightText |
Couleur
de texte de la sélection |
0x8000000E |
|
|
VbButtonFace |
Bouton |
0x8000000F |
|
|
VbButtonShadow |
Ombre
de bouton |
0x80000010 |
|
|
VbGrayText |
Texte
inactif |
0x80000011 |
|
|
VbButtonText |
Texte
de bouton |
0x80000012 |
|
|
VbInactiveCaptionText |
Couleur
de texte d'une barre inactive |
0x80000013 |
|
|
Vb3Dhighlight |
Sélection 3D |
0x80000014 |
|
|
Vb3DDKShadow |
Ombre 3D |
0x80000015 |
|
|
Vb3Dlight |
Sélection
3D (2e couleur la + claire) |
0x80000016 |
|
|
VbInfoText |
Couleur
de texte d'une Info-bulle |
0x80000017 |
|
|
VbInfoBackground |
Couleur
de fond d'une Info-bulle |
0x80000018 |
|
|
|
Tab 5 : Les
valeurs renvoyées dans une boîte de dialogue |
|||
Valeur renvoyée
|
Bouton enfoncé
|
Constante système
|
|
|
1 |
OK |
VbOK |
|
|
2 |
Annuler |
VbCancel |
|
|
3 |
Abandonner |
VbAbort |
|
|
4 |
Répéter |
VbRetry |
|
|
5 |
Ignorer |
VbIgnore |
|
|
6 |
Oui |
VbYes |
|
|
7 |
Non |
VbNo |
|
|
|
Tab 6-1 : La
table de vérité And |
|||
Valeur1
|
Valeur2
|
Résultat
|
|
|
0 |
0 |
0 |
|
|
0 |
1 |
0 |
|
|
1 |
0 |
0 |
|
|
1 |
1 |
1 |
|
|
|
Tab 6-2 : La
table de vérité Eqv |
|||
Valeur1
|
Valeur2
|
Résultat
|
|
|
0 |
0 |
1 |
|
|
0 |
1 |
0 |
|
|
1 |
0 |
0 |
|
|
1 |
1 |
1 |
|
|
|
Tab 6-3 : La
table de vérité Imp |
|||
Valeur1
|
Valeur2
|
Résultat
|
|
|
0 |
0 |
1 |
|
|
0 |
1 |
1 |
|
|
1 |
0 |
0 |
|
|
1 |
1 |
1 |
|
|
|
Tab 6-4 : La
table de vérité Or |
|||
Valeur1
|
Valeur2
|
Résultat
|
|
|
0 |
0 |
0 |
|
|
0 |
1 |
1 |
|
|
1 |
0 |
1 |
|
|
1 |
1 |
1 |
|
|
|
Tab 6-5 : La
table de vérité Xor |
|
|||||
Valeur1
|
Valeur2
|
Résultat
|
|
||||
0 |
0 |
0 |
|
||||
0 |
1 |
1 |
|
||||
1 |
0 |
1 |
|
||||
1 |
1 |
0 |
|
||||
|
Tab 6-6 : La table de vérité Not |
||||||
|
Valeur |
Résultat |
|||||
|
0 |
1 |
|||||
|
1 |
0 |
|||||
Tab 7 :Description de l'intervalle
|
|||
Intervalle
|
description
|
Intervalle
|
description
|
aaaa |
année |
e |
jour de la semaine |
t |
trimestre |
ee |
semaine |
m |
mois |
h |
heure |
a |
jour de l'année |
n |
minute |
j |
jour |
s |
seconde |
|
Tab 8 : Les constantes système du premier jour de la semaine et la première semaine de l'année |
|||
Constantes système
|
Valeur
|
Description
|
|
|
VbUseSystem |
0
|
National
Language Support (NLS) API |
|
|
VbSunday |
1 |
dimanche (par défaut) |
|
|
VbMonday |
2 |
lundi |
|
|
VbTuesday |
3 |
mardi |
|
|
VbWednesday |
4 |
mercredi |
|
|
VbThusday |
5 |
jeudi |
|
|
VbFriday |
6 |
vendredi |
|
|
VbSaturday |
7 |
samedi |
|
|
VbFirstJan1 |
Semaine du 1 janvier est la 1re semaine |
|
||
VbFirstFourDays |
La semaine comportant au moins 4 jours
dans la nouvelle année est la 1re semaine |
|
||
VbFirstFullWeek |
La première semaine complète dans
l'année est la 1re semaine de l'année |
|
||