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 = #12:45:23 AM# : D2 = #12/09/01#

 

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, 2 To 10, -10 To -5, 0 To 30)     'quatre dimensions

 

Les tableaux à plusieurs dimensions doivent être utilisés avec parcimonie car la mémoire occupée augmente de manière exponentielle avec le nombre de dimensions.

Visual Basic gère les tableaux statiques et dynamiques. Les tableaux statiques ont une taille fixe pendant l'exécution du programme alors que les tableaux dynamiques peuvent être adaptés aux besoins à tout instant. Les tableaux dynamiques sont déclarés sous la forme

· Dim TableauDynamique( ) As Integer                   'tableau dynamique d'entiers

 

et modifiés pendant l'exécution par une expression du type :

· Redim NomTableau (LimiteInf To LimiteSup[,LimiteInf To LimiteSup, ...])

 

Cela permet de libérer de la mémoire qui sera disponible pour d'autres utilisations. Donc, les dimensions des tableaux dynamiques peuvent être modifiées pendant l'exécution du programme avec l'instruction Redim. Si certains éléments contenaient déjà une valeur, ils sont réinitialisés, autrement dit les valeurs sont perdues.

· Option Base 1

· Dim Tableau() As Integer     ' Déclaration d'un tableau dynamique

· ReDim Tableau(3)                 'Redimensionnement (alloue 3 éléments)

· Tableau (1) = 10                    'initialisation des éléments du tableau

· Tableau (2) = 20

· Tableau (3) = 30

 

Il est possible de changer la dimension d'un tableau sans systématiquement perdre toutes les données déjà affectées. Il suffit d'utiliser Preserve avec l'instruction ReDim.

· 'Extension du tableau (sans perte de données)

· ReDim Preserve Tableau (5)

· Tableau (5) = 50                                'Affectation de valeurs

 

Si vous utilisez le mot clé Preserve, vous ne pouvez redimensionner que la dernière dimension du tableau. Vous ne pouvez en aucun cas modifier le nombre de dimensions. De même, le mot clé Preserve ne permet de redimensionner un tableau qu'en modifiant la limite supérieure ; toute modification de la limite inférieure provoque une erreur.

 

Les valeurs d'un tableau statique sont maintenues en mémoire pendant toute la durée de l'exécution du programme. Les limites d'un tableau statique ne peuvent pas être modifiées. Ce type ne doit être utilisé qu'exceptionnellement.

· Static Test(1 To 10) As Integer

 

On peut déclarer des tableaux globaux Public ou des tableaux visibles au niveau du module dans lequel sont déclarés : Private. On peut récupérer les limites d'un tableau à l'aide des fonctions UBound et LBound. UBound acquiert la limite supérieure et LBound acquiert la limite inférieure.

· LimiteInferieure% = LBound(NomTableau, NumeroDimension)

· LimiteSuperieure% = UBound(NomTableau, NumeroDimension)

 

Avec VB, il est possible d'affecter par une seule et unique instruction le contenu intégral d'un tableau à un autre tableau à conditions que les deux soient déclarés en dynamique, aient les mêmes dimensions et gèrent les mêmes types de données (avec l'opérateur =). Si le tableau cible est de type statique, la seule solution est de procéder élément par élément.

 

2. 5 Les types et structures de données personnalisés

 

On peut définir des types personnalisés et des structures d'enregistrements (record). Ces types doivent être déclarés dans la section générale d'un module et non pas à l'intérieur d'une procédure ou d'une fonction en respectant la syntaxe suivante :

· Private Type monType1                   |           · Public Type monType2

· Champs As integer                            |           · Champs As integer

· tableau(100) As double                    |           · tableau(100) As double

· End Type                                             |           · End Type

 

Le mot Private ou Public peut être omis. A l'intérieur de l'enregistrement la définition d'un type avec un identificateur est impossible (il faut utiliser le mot-clé As). L'utilisation de variables de type variant ou chaîne de caractères dynamiques entraîne une taille indéfinie du type personnalisé. La déclaration d'une variable de ce type et l'accès aux éléments se fait de la manière suivante :

· Dim VariableTest As monType1

· Entier% = VariableTest.Champs

· Reel# = VariableTest.tableau(1)

 

Il est même possible de déclarer un enregistrement dans lequel un élément est aussi un enregistrement (variable d'enregistrement imbriqué).

· Type monTypedeVar1

· A As integer

· B As integer

· End Type

· Type monTypeEtendu

· Nombre As integer 'Type de données standard

· Bloc As monTypedeVar1 'Type d'enregistrement personnalisé

· End Type

 

L'accès aux éléments se fera d'une manière classique.

· Dim GrandeVariable As monTypeEtendu

· Nombre1% = GrandeVariable.Nombre

· ValeurA% = GrandeVariable.Bloc.A

 

On note que les enregistrements destinés aux fichiers typés (à accès direct) ont une taille fixe. Donc, dans ce domaine l'utilisation des chaînes de caractères dynamiques et le type variant est prohibé.

 

Sous VB, il est possible de définir des types de données standards pour certains noms de variables à l'aide de l'instruction DefType (à utiliser avec modération) à laquelle associe une ou plusieurs plages de caractères. Toutes les variables commençant par une lettre de cette plage de caractères ont systématiquement le type de données défini avec l'instruction DefType. Le tableau 1 de l'annexe donne les valeurs possibles de DefType sachant que chaque déclaration effectuée avec une instruction Dim a la priorité sur l'instruction DefType.

 

En VB, on peut forcer les déclarations explicites de variables avec l'instruction :

 

· Option Explicit

 

La déclaration d'une constante par Const ou d'une variable par Dim a une portée privée (dans le module ou la feuille). Par contre la déclaration d'un type, d'une procédure par Sub ou d'une fonction par Function est publique.

 

 

3)    Constantes systèmes et Constantes personnalisées

 

Les constantes sont initialisées avec une valeur fixe, qui ne peut pas être modifiée pendant l'exécution. VB reconnaît les constantes prédéfinies (système) et les constantes personnalisées. Les constantes les plus importantes figurent dans les tableaux tab2, tab3 et tab4. On rappelle que True et False sont des constantes systèmes prédéfinies. Les constantes personnalisées sont définies en respectant la syntaxe suivante :

· [Private|Public] Const NomConstante [As Type] = Expression

 

Le mot-clé Private ou Public est facultatif ainsi que son type. L'exemple suivant montre la déclaration d'une constante :

· Const G = 9.80665

 

 

4)    Les boîtes de dialogue d'entrée et de sortie

 

Les entrées et sorties en VB ne sont généralement pas gérées par des instructions mais par des boîtes de dialogue personnalisées.

 

4. 1 Les messages

 

Pour afficher un message sur l'écran, on peut utiliser l'instruction MsgBox :

· MsgBox Message [[,[ Style%][, Titre$]] [, FichierAide$, Contexte%]]

 

Le contenu du message est passé dans le paramètre Message et celui de la barre de titre dans le paramètre Titre$. Les boutons et icônes qui seront affichés dans la boîte de message sont définis par le paramètre Style%. Par défaut, on a une boîte de message avec un seul bouton OK.

Les identificateurs d'icônes

Identificateur

Icône

Nom

Constante système

16

Stop

VbCritical

32

Confirmation

VbQuestion

48

Message d'avertissement

VbExclamation

64

Message d'information

VbInformation

 

Si On désire avoir une boîte de message dans laquelle il y a un deuxième bouton d'aide (en plus du bouton OK), on peut utiliser la valeur 16384 ou la constante système VbMsgBoxHelpButton à Style%. Bien sûr, on transmet par FichierAide$ le chemin et le nom du fichier à afficher quand on clique sur ce bouton et par Contexte% le numéro de la rubrique d'aide. L'exemple suivant montre l'utilisation de MsgBox :

· T$ = "Erreur" : M$ = "La fonction n'a pu être exécutée."

· M = M + " Le programme est terminé !"

· MsgBox M, VbCritical, T$

 

On peut forcer des sauts de lignes dans les messages en utilisant la constante VbCrLf :

· Message$ = "Première ligne" & VbCrLf & "Deuxième ligne"

 

Il existe aussi une fonction MsgBox( ) équivalente à l'instruction MsgBox et qui possède les mêmes paramètres. La seule différence est qu'on peut récupérer la valeur renvoyée. Le tableau suivant montre des boutons et des icônes affichés dans la boîte de message selon le style.

 

 

Les constantes des boutons

Identificateur

Bouton

Constante système

 

0

OK

VbOKOnly

 

1

OK, Annuler

VbOKCancel

 

2

Abandonner, Répéter, Ignorer

VbAbortRetryIgnore

 

3

Oui, Non, Annuler

VbYesNoCancel

 

4

Oui, Non

VbYesNo

 

5

Répéter, Annuler

VbRetryCancel

 

 

En utilisant la constante VbYesNo comme style, on peut comparer la valeur renvoyée avec les valeurs suivantes : VbYes et VbNo. Pour choisir une sorte d'icône et un style de bouton, il faut additionner les deux valeurs correspondantes et passer cette somme au paramètre Style%. Par exemple pour obtenir une icône du point d'interrogation (identificateur = 32) avec deux boutons Oui ou Non (identificateur = 4), le paramètre Style% sera donc l'expression VbQuestion+VbYesNo (ou 32+4=36).

· Reponse% = MsgBox("Désirez-vous quitter le programme", 36, "Attention")

 

La valeur renvoyée par cette fonction stockée dans la variable Reponse% dépend du bouton enfoncé (Tab 5 en annexe donne la liste des valeurs renvoyées).

 

4. 2 Les Boîtes de saisie

 

Pour permettre à l'utilisateur de saisir des données simples, on peut utiliser la fonction InputBox$( ) qui recueille les données sous forme d'une chaîne de caractères. Sa syntaxe est la suivante :

· Resultat$ = InputBox (Massage$ [, Titre$] [, Default$] [, Xpos%] [, Ypos%]
[, FichierAide$, ContexteAide%])

 

Le message est passé dans le paramètre Message$, le contenu de la barre de titre dans le paramètre Titre$. A l'exception du paramètre Message$, tous les paramètres sont facultatifs. La boîte de saisie peut être remplie par une valeur  par défaut passée à la variable Default$. Cette valeur est prête à être modifiée. Les paramètres Xpos% et Ypos% permettent de définir la position de la boîte de saisie en pixel par rapport à l'angle supérieur gauche de l'écran. Le paramètre FichierAide$ définit un fichier d'aide et le paramètre ContexteAide% spécifie un numéro de rubrique de ce fichier d'aide. L'utilisation de ces deux paramètres implique l'existence automatique du bouton Aide permettant l'appel au fichier indiqué.

· Message$ = "Veuillez donner votre nom" : Titre$ = "Saisie d'un nom"

· MonNomt$ = InputBox (Massage$ , Titre$)

 

L'exemple suivant Montre l'utilisation de la fonction InputBox associée à l'instruction MsgBox. Ce programme sera  non événementiel ; donc on va supprimer la feuille obtenue par défaut en créant un nouveau projet. La 1re étape consiste à créer un nouveau projet de type EXE Standard en passant par Fichier/Nouveau projet. Ensuite, on crée un nouveau module de code source en faisant Projet/Ajouter un module qu'on va enregistrer en faisant Fichier/Enregistrer Module1 sous dans le fichier addition.bas. On sélectionne la feuille Form1 pour la supprimer à l'aide de Projet/Supprimer Form1. On tape toutes les instructions dans une procédure appelée Sub Main( ) dans le module 1. Pour cela, on va sélectionner le module dans la fenêtre de projet. Ensuite, on clique sur le bouton Code (ou double clic sur module1) et on tape les instructions dans la fenêtre de code. Pour exécuter le programme, on passe par Exécution/Exécuter.

· Option Explicit

· Sub Main()

· Dim A%, B%

· Dim c#

· A = InputBox("Donnez le premier entier", "saisie d'un entier")

· B = InputBox("Donnez le deuxième entier", "saisie d'un entier")

· c = A / B

· MsgBox c, vbInformation, "affichage du résultat"

· End Sub

 

Ce programme illustre, outre les boîtes de message et de saisie, la possibilité de développer avec VB des programmes non événementiels et sans faire appel aux objets.

 

 

5)    Les opérateurs mathématiques

 

Ces opérateurs sont classés dans différentes catégories.

 

5. 1 Opérateurs arithmétiques : Les priorités des opérateurs arithmétiques permettant d'effectuer des calculs mathématiques sont présentées ci-dessous. Pour inverser les priorités, il faut utiliser des parenthèses.

 

 

 

Les opérateurs arithmétiques

Priorité

Opérateur

Description

 

1

^

Puissance

 

2

-

Négation

 

3

*, /

Multiplication, Division

 

4

\

Division entière

 

5

Mod

Reste de la division entière

 

6

+, -

Addition (concaténation), soustraction

 

7

&

Concaténation de chaînes de caractères

 

 

5. 2 Opérateurs de comparaison : Pour comparer des données, il faut utiliser les opérateurs de comparaison. Le résultat est une valeur logique (True ou False).

Les opérateurs de comparaison sont les suivant : =, >, >=, <, <=, <>, Like (comparaison de chaînes de caractères) et Is (comparaison de variables objets). Ces opérateurs ont la même règle de priorité.

 

5. 3 Opérateurs logiques ou arithmétiques bit à bit : Ces Opérateurs permettent d'effectuer des relations logiques (booléens)  ou de travailler au niveau bit par bit.

 

 

Les opérateurs logiques ou arithmétiques bit à bit

Priorité

Opérateur

Description

 

1

Not

Négation logique

 

2

And

ET logique

 

3

Or

OU logique

 

4

Xor

OU exclusif

 

5

Eqv

équivalence logique

 

6

Imp

Implication

 

Le tableau tab6 en annexe montre les tables de vérité de ces opérateurs.

 

6)    Instructions de contrôle de l'exécution

 

Visual Basic dispose de toutes les structures de contrôle et de décision d'un langage de haut niveau. Les instructions de saut Goto et Gosub (à utiliser avec parcimonie) figurent encore sur la liste. VB conserve des reliques de l'ancien Basic pour faciliter l'importation d'anciens textes source. Les instructions en VB doivent donc être utilisées exclusivement dans des procédures.

 

6. 1 Les instructions de saut GOTO et GOSUB

Branchement simple, Goto : L'instruction Goto est la plus simple instruction de contrôle du programme en VB. Elle permet de créer un branchement vers une instruction quelconque à l'intérieur d'une procédure (une étiquette). Le branchement vers des lignes de procédures externes est impossible. Cette instruction met en péril l'aspect structurel d'un programme (pas de possibilité d'établir un algorithme). Le code source obtenu sera difficile à lire et éventuellement à modifier ou à corriger. En plus, Cette instruction est déconseillée sauf en liaison avec le traitement d'erreurs On error parce que le risque de l'apparition de boucles infinies est grand. Cette instruction peut être facilement remplacée par une boucle ou par un test if.

· On Error GoTo message_d_erreur : ' message_d_erreur est une étiquette

Branchement selon valeur - On Goto : Vous pouvez réduire plusieurs branchement Goto à l'aide de l'instruction :

· On Valeur Goto Etiquette

 

Selon la valeur obtenue avant On Goto, le programme sera aiguillé vers des lignes définies. Chacune des étiquettes sera suivie d'une virgule et éventuellement convertie en un entier.

· 'Sélection spéciale d'un bloc Goto

· Sub Nom_de_Procédure([Liste des paramètres)]

· 'éventuellement, d'autres instructions avec

· 'initialisation de la variable Valeur%

· On Valeur% Goto Etiquettel, Etiquette2, Etiquette3

· 'Intervalle de validité de Valeur% : 0-255

· 'Valeur% = 0 pas de branchement

· 'Valeur% = 1 branchement vers la première étiquette

· 'Valeur% = 2 branchement vers la deuxième étiquette

· 'Valeur% = 3 branchement vers la troisième étiquette

· 'Valeur% > 3 And Valeur% < 256 : pas de branchement

· 'Valeur% < 0 Or Valeur% > 255 : Erreur

· 'autres instructions éventuelles

· Exit Sub

· Etiquette1 : 'autres instructions

· Exit Sub

· Etiquette2 : 'autres instructions

· Etiquette3 : 'autres instructions

· End Sub

 

Dans le code ci-dessus, le branchement vers la première étiquette aboutit à la sortie de la procédure par l'instruction Exit sub. Le branchement vers la deuxième étiquette commande l'exécution de toutes les instructions suivantes, y compris celles qui se trouvent après Etiquette3. Le saut vers celle-ci conduit à exécuter seulement les instructions qui se trouvent après Etiquette3. Notez l'absence de retour à l'instruction qui suit la ligne Goto.

 

Branchement pour exécuter un bloc interne, Gosub : L'instruction Gosub permet, comme pour l'instruction Goto, de définir des branchements dans une procédure vers une étiquette. A la différence de l'instruction Goto, les instructions du code exécutées après le branchement sont terminées par le mot-clé Return. Notez que les instructions Gosub et Return doivent se trouver dans la même procédure, Après le traitement du bloc Gosub, le retour à la position d'appel dans le texte source et l'exécution des instructions suivant l'instruction Gosub se trouvent ainsi garantis.

 

L'avantage des blocs d'instructions internes par rapport aux procédures utilisateur est que vous n'avez pas à leur transmettre de paramètres, puisque ces blocs connaissent toutes les variables de la procédure (Cet avantage n'est pas vraiment convaincant).

 

La prolifération d'instructions Gosub dans une procédure a tôt fait de réduire considérablement la clarté du code source. Il faut réserver les instructions Gosub à des cas exceptionnels et donner la préférence aux procédures et fonctions personnalisées.

 

6. 2 Boucles avec incrémentation

 

Les boucles Sont les principales Structures de contrôle d'exécution des programmes dans les langages de haut niveau. Visual Basic propose les structures de boucles For ... Next, While ... Wend et Do... Loop. La boucle For Each parcourt les éléments d'un tableau ou d'une liste. Ces instructions simplifient le contrôle du déroulement de l'exécution d'un programme.

 

For... Next : Utilisez les boucles For ... Next pour définir une valeur de début, une valeur de fin et le pas de l'incrémentation. Cela permet par exemple d'initialiser les éléments d'un tableau de données ou d'une zone de liste ou de les mettre à jour. La syntaxe générale de la boucle For ... Next est la suivante :

· For VariableCompteur = ValeurInitiale To ValeurFinale [Step Pas]

· 'instructions

· Next [VariableCompteur]

 

La variable de comptage est le plus souvent de type Integer (nombre entier), les valeurs initiales et finales peuvent être définies en fonction des besoins. L'intervalle des valeurs initiales et finales dépend du type de données de la variable de comptage.

 

Si aucun pas n'est indiqué, la valeur 1 est automatiquement utilisée. Notez que le pas doit être négatif si la valeur finale est plus petite que la valeur initiale, car la boucle ne serait pas parcourue si le pas était positif.

· 'Une boucle For ... Next simple

· For x% = 1 To 100 'ici Step = 1

· D%(x%) = 0 : 'Remarque le tableau de données D% doit être déclaré

· Next x%

· 'boucle For ... Next imbriquée

· For i% = 1 To 100

·         For j% = 5 To 10

·                  For k%. = 10 To 1 Step –1

·                            Textl.Print "i%="; i%; "j%="; j%; "k%="; k%; Chr$(13)

·                  Next k%

·         Next j%

· Next i%

 

Pour une sortie prématurée d'une boucle For... Next, par exemple parce que vous avez trouvé la valeur cherchée, on peut utiliser l'instruction Exit For. Quitter une boucle avant terme peut réduire considérablement la durée de l'exécution d'un programme.

· 'Sortie prématurée d'une boucle For ... Next avec Exit For

· For x% = 1 To 1000 Step 2

· 'instructions

· If condition Then Exit For : 'L'instruction If est une instruction conditionnelle

· Next x%

 

Dans une structure de boucle, il est possible d'intégrer plusieurs instructions Exit For, en prévision des interruptions prématurées de la boucle. Cependant, pour limiter les risques d'erreur, il vaut mieux les regrouper à une seule instruction de sortie.

 

Pour parcourir les éléments d'un tableau, on peut utiliser la boucle suivante :

· Dim Tableaux%(5), i%

· For i = LBound(Tableaux()) To UBound(Tableaux())

·                msgbox Tableaux(i)

· Next i

 

Une boucle For Each est une manière simple de parcourir les éléments d'un tableau ou les objets d'une collection.

 

· For Each PrinterObject In Printers

· ' Printers est une collection d'objets

· 'Parcourir la liste des imprimantes et afficher leur nom

·    MsgBox PrinterObject.DeviceName, VbInformation, "Liste des imprimantes"

· Next PrinterObject

 

Il est également possible de quitter prématurément une boucle For Each par une instruction Exit For. Les éléments parcourus dans la boucle des exemples précédents sont gérés au moyen de la variable entière Variable% dans le cas du tableau, et par la variable objet Printerobject dans le cas de la collection d'objets. Il n'est pas nécessaire de préciser les indices qui seraient indispensables dans une boucle For ... Next. Les valeurs de début et de fin ne sont pas non plus à indiquer, ils sont définis dans les tableaux et les collections d'objets.

 

While... Wend (boucle conditionnelle) : Alors que la boucle For ... Next est commandée par des valeurs, la boucle While ... Wend peut être parcourue tant que une condition est vraie (True).

· While condition = True

· 'instructions du programme

· Wend

 

Les instructions de la boucle While ... Wend ne sont exécutées que si la condition est vraie avant de pénétrer dans la boucle. Si la condition est fausse dès le départ, la boucle While ... wend n'est pas exécutée. Dans ce cas, utilisez la boucle Do... Loop qui peut être écrite de manière à être parcourue au moins une fois.

· 'boucle While ... Wend simple

· A% = 2000

· While A% >= 500

·         'autres instructions du code source

·         A% = A% - 1

· Wend

· 'A% vaut maintenant 499

 

Les boucles While ... Wend peuvent être imbriquées, comme les boucles For ... Next, Mais elles sont généralement utilisées sans imbrication.

· 'boucle While... Wend imbriquée

· A% = 2000 : B% = 100

· While A% >= 500

·           'autres instructions du code source

·           A% = A% - 1

·           While B% < 1000

·                    'autres instructions du code source

·                    B% = B% + 1

·           Wend

· Wend

· 'A% vaut maintenant 499 et B% vaut 1000

 

 

 

 

 

 

Veuillez observer les retraits de chaque niveau d'imbrication destinés à améliorer la clarté du code. Ils permettent de trouver très facilement le début et la fin de chaque niveau.

 

Do ... Loop : La boucle Do... Loop est comparable à la boucle While ... Wend dans son principe, mais elle permet d'énoncer une condition commandant la sortie de la boucle et forçant au moins une itération de la boucle. Dans la première variante, la boucle Do... Loop est utilisée comme une boucle While ... Wend sachant qu'elle peut être quittée de manière prématurée à l'aide de l'instruction Exit Do. La syntaxe de cette instruction est la suivante :

· Do [While|until] condition = True

· 'instructions du programme

· [Exit Do]

· Loop

Les instructions de cette variante de boucle Do ... Loop ne seront exécutées que si la condition est vraie (True ) avant le début de la boucle. Si elle est fausse, la boucle n'est pas exécutée.

· 'boucle Do... Loop simple (1re  variante: syntaxe While ... Wend)

· A% = 2000

· Do While A% >= 500

·         'autres instructions du code source

·         A% = A% - 1

· Loop

· 'A% vaut maintenant 499

Comme les boucles For... Next et While ... Wend, la boucle Do... Loop peut être imbriquée, mais elle est généralement utilisée sur un seul niveau.

· 'boucle Do... Loop imbriquée (1re variante : syntaxe While ... Wend)

· A% = 2000 : B% = 100

· Do While A% > 500

·         'autres instructions du code source

·         A% = A% - 1

·         Do While B% < 1000

·                'autres instructions du code source

·                B% = B% + 1

·         Loop

· Loop

· 'A% vaut maintenant 500 et B% vaut 1000

Veuillez observer les retraits de chaque niveau d'imbrication destinés à améliorer la clarté du code. Le mot-clé while de la boucle Do ... Loop peut être remplacé par le mot-clé Until. Avec while, une boucle est exécutée tant que la condition indiquée est vraie. Avec Until, la boucle est exécutée jusqu'à ce que la condition indiquée soit vraie ou, autrement dit, tant que la condition n'est pas vraie. Vous venez de faire la connaissance d'une première extension de la structure While ... Wend.

 

Do ... Loop polyvalente : La deuxième variante de la boucle Do ... Loop a la syntaxe suivante :

 

· Do

· 'instructions du programme

· [Exit Do]

· Loop [While|Until] condition = True

Les instructions de cette variante de boucle Do... Loop sont exécutées au moins une fois, car la condition est vérifiée à la fin de la boucle. Sa valeur, vraie ou fausse, au début de la boucle est sans importance.

· 'autre boucle Do... Loop (deuxième variante : un parcours au moins)

· A% = 100

· Do

·                'autres instructions du code source

·                A% = A% - 1

· Loop While A% > 100

· 'A% vaut maintenant 99

Comme les boucles For ... Next et While ... Wend, les boucles Do ... Loop peuvent aussi être imbriquées. Elles sont pourtant utilisées en règles générales sans imbrication.

 

 

6. 3 Les tests : (If, Select … Case)

 

Les tests sont un moyen de contrôler le déroulement des programmes qui vient compléter les boucles. Les structures de test sont utilisées pour créer des branchements asservis à une comparaison entre deux valeurs (True ou False). Ces comparaisons font appel à des opérateurs logiques.

 

Test simple, If : La structure de test la plus simple est l'instruction If. Elle permet, selon la valeur d'une variable ou d'une certaine condition, d'exécuter ou de sauter une instruction. Sa syntaxe est la suivante :

· If Condition Then InstructionA [Else InstructionB]

 

La partie Else dans une instruction If simple est facultative :

· 'instruction If simple

· If Valeur% < 0 Then Valeur% = 1

 

 

On peut aussi dans un test affecter une valeur si la condition n'est pas remplie.

· 'instruction If simple

· If Valeur% < 0 Then Valeur% = 1 Else Valeur% = 2

 

Les possibilités des tests d'une ligne sont limitées. Pour définir des instructions de décision plus élaborées, il faut compléter le bloc If avec If ... Then ... Else ... End If.

· 'exemple de bloc If

· If a% = l Then

·                'instructions exécutées si la condition est vraie

· Else

·                'instructions exécutées si la condition n'est pas vraie

· End If

· 'Structure If ... Then ... ElseIf... End If

· If B% = 0 Then

·                'instructions exécutées si la condition est vraie

· ElseIf B% < 0 Then

·                'instructions

· ElseIf B% > 5  Then

·                'instructions

· Else

·                'instructions exécutées si aucune des conditions n'a été remplie

· End If

 

L'exemple suivant montre des imbrications de structures de décision :

· 'bloc If imbriqué

· If B% = 0 Then

·         'instructions exécutées si la condition est vraie

·         If C% > 0 Then D% = 0 : 'If sans une partie Else

· ElseIf B% < 0 Then

·         'instructions

·         If A% = 1 Then

·                  'instructions

·         ElseIf A% > 1 Then

·                  'instructions

·         Else

·                  'instructions

·         End If

· ElseIf B% > 5 Then

·         'instructions

· Else

·         'instructions

· End If

 

 

 

Il ne faut pas abuser des imbrications de boucles en général et de tests en particulier. Une bonne règle pour conserver un code concis et puissant consiste à limiter les imbrications au minimum indispensable. Dans cet exemple aussi, les retraits de chaque niveau d'imbrication permettent d'améliorer la clarté du code.

 

Choix multiple, Select Case : Dans les choix faisant intervenir de nombreuses possibilités, il est conseillé d'utilisez la structure Select ... Case qui permet de définir des blocs d'instructions réservés à des valeurs. La syntaxe de cette instruction est la suivante :

· Select Case Expression

· Case Valeur1

·                instructions

· [Case Valeur2

·                instructions]

· [...]

· [Case Else

·                instructions]

· End Select

 

Le mot-clé Is permet d'utiliser des opérateurs de comparaison. Les intervalles de valeurs sont définis à l'aide du mot-clé To.

· Select Case A%

· Case 1

·                'instructions

· Case 2 To 5

·                '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 2 To 5

·                '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 Somme (A%, Optional B%, Optional C%) As Long

· . . .

· 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 Somme (Resultat&, A%, Optional B%, Optional C%)

· . . .

· 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 = #09:15:23#

 

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