Conflits d'affectation de nom

Un conflit d'affectation de nom se produit lorsque vous tentez de créer ou d'employer un identificateur ayant été déjà défini. Dans certains cas, des conflits d'affectation de nom génèrent des erreurs telles que "Nom ambigu détecté" ou "Déclaration existante dans la portée en cours". Les conflits d'affectation de nom non détectés peuvent créer des bogues dans votre code et l'obtention de résultats erronés, notamment si vous ne déclarez pas explicitement toutes les variables avant leur première utilisation.

Pour éviter la plupart des conflits d'affectation de nom, il convient de bien comprendre les caractéristiques de portée des identificateurs de données, d'objets et de procédures. Visual Basic comporte trois niveaux de portée : le niveau procédure, le niveau module privé et le niveau module public.

Un conflit d'affectation de nom peut se produire lorsqu'un identificateur :

•	est visible à plusieurs niveaux de portée ;

•	a deux significations différentes au même niveau.

Par exemple, des procédures peuvent porter le même nom dans des modules différents. Vous pouvez ainsi définir une procédure nommée MySub dans des modules nommés Mod1 et Mod2. Aucun conflit ne se produit si chaque procédure est appelée depuis d'autres procédures dans son propre module. Cependant, une erreur peut se produire si MySub est appelée depuis un troisième module, alors qu'aucune qualification n'est fournie pour établir une distinction entre les deux procédures MySub.

La plupart des conflits d'affectation de nom peuvent être résolus en faisant précéder chaque identificateur d'un qualificateur formé du nom du module et, au besoin, d'un nom de projet. Par exemple :

YourProject.YourModule.YourSub MyProject.MyModule.MyVar

Le code précédent appelle la procédure Sub YourSub et passe MyVar comme argument. Vous pouvez utiliser n'importe quelle combinaison de qualificateurs pour différencier les identificateurs identiques.

Visual Basic associe chaque référence à un identificateur avec la déclaration "la plus proche" de l'identificateur correspondant. Par exemple, si MyID est déclaré Public dans deux modules d'un objet (Mod1 et Mod2), vous pouvez spécifier le MyID déclaré dans Mod2 sans qualification dans de Mod2, mais vous devez le qualifier comme Mod2.MyID pour le spécifier dans Mod1. Cela est également vrai si Mod2 se trouve dans un projet différent, mais directement référencé. Cependant, si Mod2 est un projet référencé indirectement, c'est-à-dire, un projet référencé par le projet auquel vous faites directement référence, les références à la variable de Mod2 nommée MyID doivent toujours être qualifiées avec le nom du projet. Si vous faites référence à MyID depuis un troisième module directement référencé, la correspondance est établie avec la première déclaration rencontrée lors d'une recherche :

•	Dans des projets directement référencés, dans l'ordre d'occurrence dans la boîte de dialogue Références du menu Outils.

•	Les modules de chaque projet. Notez qu'il n'existe aucun ordre inhérent aux modules dans le projet.

Vous ne pouvez pas réutiliser de noms d'objet d'application hôte, par exemple R1C1 dans Microsoft Excel, à différents niveaux de portée.

Conseil   Parmi les erreurs classiques causées par des conflits d'affectation de nom, citons notamment les noms ambigus, les déclarations en double, les identificateurs non déclarés et les procédures introuvables. En commençant chaque module par une instruction Option Explicit pour forcer la déclaration explicite des variables avant leur emploi, vous pouvez éviter certains conflits d'affectation de nom potentiels et les bogues d'identificateur qui leur sont associés.


Appel de procédures ayant le même nom

Vous pouvez appeler une procédure se trouvant dans n'importe quel module du même projet que le module actif comme vous appelleriez une procédure du module actif. Cependant, si plusieurs modules contiennent une procédure portant le même nom, vous devez spécifier un nom de module dans l'instruction appelante, comme le montre l'exemple suivant :

Sub Main()

Module1.MyProcedure

End Sub

Si vous donnez le même nom à deux procédures différentes dans deux projets différents, vous devez spécifier un nom de projet lors de l'appel de cette procédure. Par exemple, la procédure suivante appelle la procédure Main dans le module MyModule du projet MyProject.vbp.

Sub Main()

[MyProject.vbp].[MyModule].Main

End Sub

Note   Les noms de projets varient en fonction de l'application. Par exemple, dans Microsoft Access, un projet se nomme une base de données (.mdb), dans Microsoft Excel, on parle plutôt de classeur (.xls).

Conseils concernant l'appel de procédures

•	Si vous renommez un module ou un projet, veillez à changer le nom du module ou du projet s'il apparaît dans des instructions d'appel ; sinon, Visual Basic ne pourra pas trouver la procédure appelée. Vous pouvez utiliser la commande Remplacer du menu Edition pour trouver et remplacer du texte dans un module.

•	Pour éviter les conflits d'affectation de noms entre projets référencés, donnez à chacune de vos procédures un nom qui lui est propre afin de pouvoir l'appeler sans devoir spécifier ni projet ni module.


Appel de procédures de propriété

Le tableau suivant présente la syntaxe des procédures de propriété :

Procédures de propriété	Syntaxe
Property Let	[object.]propname(arguments)] = argument
Property Get	varname = [object.]propname(arguments)]
Property Set	Set [object.]propname[.(arguments)] = varname
Lorsque vous appelez une procédure Property Let ou Property Set, un argument apparaît toujours à droite du signe égal (=).

Lorsque vous déclarez une procédure Property Let ou Property Set avec plusieurs arguments, Visual Basic passe l'argument du côté droit de l'appel au dernier argument de la déclaration Property Let ou Property Set. Par exemple, le schéma suivant indique comment les arguments dans l'appel de la procédure Property se rapportent aux arguments de la déclaration Property Let :

En pratique, la seule manière d'utiliser des procédures de propriété avec arguments multiples consiste à créer des tableaux de propriétés.


Appel de procédures Sub et Function

Pour appeler une procédure Sub depuis une autre procédure, tapez le nom de la procédure sans oublier les valeurs des arguments obligatoires. L'instruction Call n'est pas obligatoire, mais si vous l'utilisez, vous devez mettre les éventuels arguments entre parenthèses.

Vous pouvez utiliser une procédure Sub pour organiser d'autres procédures de manière à simplifier leur interprétation et leur débogage. Dans l'exemple suivant, la procédure Sub Main appelle la procédure Sub MultiBeep, passant la valeur 56 comme argument. Après l'exécution de MultiBeep, le système redonne la main à Main qui appelle la procédure Sub Message. Message affiche un message ; lorsque l'utilisateur clique sur OK, la main revient à Main qui se termine.

Sub Main()

MultiBeep 56

Message

End Sub

Sub MultiBeep(numbeeps)

For counter = 1 To numbeeps

Beep

Next counter

End Sub

Sub Message()

MsgBox "Il est temps de faire une pause!"

End Sub

Appel de procédures Sub avec plusieurs arguments

L'exemple suivant illustre deux manières d'appeler une procédure Sub avec plusieurs arguments. Lors du second appel de HouseCalc, les arguments doivent être mis entre parenthèses parce que l'instruction Call est employée.

Sub Main()

HouseCalc 99800, 43100

Call HouseCalc(380950, 49500)

End Sub

Sub HouseCalc(price As Single, wage As Single)

If 2.5 * wage <= 0.8 * price Then

MsgBox "Cette maison est trop chère."

Else

MsgBox "Cette maison est abordable."

End If

End Sub

Utilisation de parenthèses lors d'appel de procédures Function

Pour utiliser la valeur renvoyée d'une fonction, affectez la fonction à une variable et mettez les arguments entre parenthèses, comme le montre l'exemple suivant.

Answer3 = MsgBox("Votre salaire vous convient-il?", 4, "Question 3")

Si la valeur renvoyée d'une fonction ne vous intéresse pas, vous pouvez appeler une fonction de la même manière qu'une procédure Sub. Omettez les parenthèses, indiquez les arguments et n'affectez pas la fonction à une variable, comme le montre l'exemple suivant.

MsgBox "Tâche terminée!", 0, "Boîte de tâche"

Attention   Si vous incluez des parenthèses dans l'exemple précédent, l'instruction cause une erreur de syntaxe.

Passage d'arguments nommés

Une instruction dans une procédure Sub ou Function peut passer des valeurs à des procédures appelées en utilisant des arguments nommés. Vous pouvez indiquer les arguments nommés dans n'importe quel ordre. Un argument nommé est composé du nom de l'argument suivi des signes deux-points et égal (:=), puis de la valeur affectée à l'argument.

L'exemple suivant appelle la fonction MsgBox en utilisant les arguments nommés sans valeur renvoyée.

MsgBox Title:="Boîte de tâche", Prompt:="Tâche terminée!"

L'exemple suivant appelle la fonction MsgBox en utilisant des arguments nommés. La valeur renvoyée est affectée à la variable answer3.

answer3 = MsgBox(Title:="Question 3", _

Prompt:="Votre salaire vous convient-il?", Buttons:=4)


Création de variables objet

Vous pouvez traiter une variable objet exactement comme l'objet auquel elle se réfère. Vous pouvez définir ou renvoyer les propriétés de l'objet ou utiliser n'importe laquelle de ses méthodes.

Pour créer une variable objet :

1.	Déclarez la variable objet.

2.	Affectez la variable objet à un objet.

Déclaration d'une variable objet

Utilisez l'instruction Dim ou l'une des autres instructions de déclaration (Public, Private ou Static) pour déclarer une variable objet. Une variable qui fait référence à un objet doit être de type Variant, Object, ou un type spécifique d'objet. Par exemple, les déclarations suivantes sont correctes :

' Déclare MyObject comme type de données Variant.

Dim MyObject

' Déclare MyObject comme type de données Object.

Dim MyObject As Object

' Déclare MyObject comme type Font.

Dim MyObject As Font

Note   Si vous utilisez une variable objet sans l'avoir déclarée, elle prend par défaut le type de données Variant.

Vous pouvez déclarer une variable objet avec le type de données Object lorsque le type d'objet spécifique n'est pas connu avant l'exécution de la procédure. Utilisez le type de données Object pour créer une référence générique à n'importe quel objet.

Si vous connaissez le type d'objet spécifique, vous devez déclarer la variable objet avec ce type. Par exemple, si l'application contient le type d'objet Sample, vous pouvez déclarer une variable objet pour cet objet en utilisant l'une des instructions suivantes :

Dim MyObject As Object	' Déclaré comme objet générique.

Dim MyObject As Sample	' Déclaré seulement comme objet Sample.

La déclaration de types d'objet assure la vérification de type automatique, un code plus rapide et une meilleure lisibilité.

Affectation d'une variable objet à un objet

Utilisez l'instruction Set pour affecter une variable objet à un objet. Vous pouvez affecter une expression d'objet ou Nothing. Par exemple, les affectations de variable objet suivantes sont correctes :

Set MyObject = YourObject	' Affecte une référence d'objet.

Set MyObject = Nothing	' Interrompt l'association.

Vous pouvez combiner la déclaration d'une variable objet et l'affectation d'un objet en utilisant le mot clé New avec l'instruction Set. Par exemple :

Set MyObject = New Object	' Création et affectation

L'affectation de la valeur Nothing à une variable objet interrompt l'association de la variable objet avec un objet spécifique. Cela permet d'éviter de changer accidentellement l'objet en changeant la variable. Une variable objet prend toujours la valeur Nothing après la fermeture de l'objet associé pour vous permettre de tester si la variable objet désigne un objet valide. Par exemple :

If Not MyObject Is Nothing Then

' La variable fait référence à un objet valide.

. . .

End If

Évidemment, ce test ne peut jamais déterminer avec une absolue certitude si un utilisateur a fermé l'application contenant l'objet auquel la variable objet se réfère.

Référence à l'instance en cours d'un objet

Utilisez le mot clé Me pour faire référence à l'instance en cours de l'objet où le code est exécuté. Toutes les procédures associées à l'objet en cours ont accès à l'objet référencé par Me. L'utilisation de Me est particulièrement pratique pour passer des informations sur l'instance en cours d'un objet à une procédure d'un autre module. Par exemple, supposons qu'un module comporte la procédure suivante :

Sub ChangeObjectColor(MyObjectName As Object)

MyObjectName.BackColor = RGB(Rnd * 256, Rnd * 256, Rnd * 256)

End Sub

Vous pouvez appeler la procédure et passer l'instance en cours de l'objet sous la forme d'un argument avec l'instruction suivante :

ChangeObjectColor Me


Création de procédures récursives

Les procédures disposent d'un espace limité pour les variables. Chaque fois qu'une procédure s'appelle elle-même, de l'espace est employé. Une procédure qui s'appelle elle-même est qualifiée de procédure récursive. Ce type de procédure répétée de façon continue peut provoquer une erreur. Par exemple :

Function RunOut(Maximum)

RunOut = RunOut(Maximum)

End Function

Cette erreur peut être moins évidente lorsque deux procédures s'appellent mutuellement indéfiniment, ou lorsqu'une condition limitant la récursivité n'est jamais satisfaite. Il convient parfois néanmoins d'avoir recours à la récursivité. Par exemple, la procédure suivante utilise une fonction récursive pour calculer des factorielles :

Function Factorial (N)

If N <= 1 Then	' Fin de la récursivité.

Factorial = 1	' (N = 0) retour vers l'appel précédent.

Else	' Appelle Factorial de nouveau si N > 0.

Factorial = Factorial(N - 1) * N

End If

End Function

Vous avez intérêt à tester vos procédures récursives pour vous assurer que le nombre d'appels récursifs n'épuise pas vos ressources mémoire. Si une erreur se produit, assurez-vous que votre procédure ne s'appelle pas elle-même indéfiniment. Essayez ensuite d'économiser vos ressources mémoire en procédant comme suit :

•	Supprimez les variables inutiles.

•	Utilisez des types de données autres que Variant.

•	Réévaluez la logique de la procédure. Les procédures récursives peuvent souvent être remplacées par des boucles imbriquées.


Déclaration de tableaux

Les tableaux se déclarent de la même façon que d'autres variables avec des instructions Dim, Static, Private ou Public. Contrairement aux variables scalaires (celles qui ne sont pas de tableaux), les variables tableau imposent généralement la spécification de leurs dimensions. Un tableau dont la taille est spécifiée est un tableau à taille fixe. Un tableau dont la taille peut être modifiée pendant l'exécution d'un programme est un tableau dynamique.

L'index d'un tableau peut commencer de 0 ou de 1 en fonction de la définition de l'instruction Option Base. Si Option Base 1 n'est pas spécifiée, tous les index de tableau commencent à zéro.

Déclaration d'un tableau fixe

Dans la ligne de code suivante, un tableau à taille fixe est déclaré comme un tableau de type Integer comportant 11 lignes et 11 colonnes :

Dim MyArray(10, 10) As Integer

Le premier argument représente les lignes, le second les colonnes.

Comme pour toute autre déclaration de variable, si vous ne spécifiez pas de type de données, les éléments du tableau déclaré prennent le type Variant. Chaque élément numérique Variant du tableau utilise 16 octets, chaque élément de chaîne 22 octets. Pour écrire un code le plus compact possible, déclarez explicitement vos tableaux avec un type de données autre que Variant. Les lignes de code suivantes comparent la taille de plusieurs tableaux :

' Un tableau de type Integer utilise 22 octets (11 éléments * 2 octets).

ReDim MyIntegerArray(10) As Integer

' Un tableau en double précision utilise 88 octets (11 éléments * 8 octets).

ReDim MyDoubleArray(10) As Double

' Un tableau de type Variant utilise au moins 176 octets (11 éléments * 16 octets).

ReDim MyVariantArray(10)

' Un tableau de type Integer utilise 100 * 100 * 2 octets (20 000 octets).

ReDim MyIntegerArray (99, 99) As Integer

' Un tableau en double précision utilise 100 * 100 * 8 octets (80 000 octets).

ReDim MyDoubleArray (99, 99) As Double

' Un tableau de type Variant utilise au moins 160 000 octets (100 * 100 * 16 octets).

ReDim MyVariantArray(99, 99)

La taille maximale d'un tableau varie en fonction de votre système d'exploitation et de la mémoire disponible. L'utilisation d'un tableau dépassant la quantité de RAM disponible ralentit le système parce que les données doivent être lues et écrites sur disque.

Déclaration d'un tableau dynamique

En déclarant un tableau dynamique vous pouvez dimensionner le tableau pendant l'exécution du code. Utilisez une instruction Static, Dim, Private ou Public pour déclarer un tableau, en laissant les parenthèses vides, comme le montre l'exemple suivant.

Dim sngArray() As Single

Note   Vous pouvez utiliser l'instruction ReDim pour déclarer un tableau implicitement avec une procédure. Veillez à ne pas faire de faute de frappe dans le nom du tableau lors de l'utilisation de l'instruction ReDim. Même si l'instruction Option Explicit est incluse dans le module, une faute de frappe créerait un deuxième tableau.

Dans une procédure incluse dans la portée du tableau, utilisez l'instruction ReDim pour changer le nombre de dimensions, pour définir le nombre d'éléments et pour établir les limites supérieures et inférieures de chaque dimension. Vous pouvez utiliser l'instruction ReDim pour modifier le tableau dynamique aussi souvent que nécessaire. Cependant, chaque fois que vous le faites, les valeurs existantes du tableau sont perdues. Utilisez ReDim Preserve pour étendre un tableau tout en conservant ses valeurs existantes. Par exemple, l'instruction suivante agrandit le tableau varArray de 10 éléments sans perdre les valeurs en cours des éléments d'origine.

ReDim Preserve varArray(UBound(varArray) + 10)

Note   Lorsque vous utilisez le mot clé Preserve avec un tableau dynamique, vous pouvez uniquement modifier la limite supérieure de la dernière dimension, et non le nombre de dimensions.


Déclaration de constantes

En déclarant une constante, vous pouvez attribuer un nom significatif à une valeur. L'instruction Const permet de déclarer une constante et de définir sa valeur. Une fois qu'une constante est déclarée, elle ne peut être modifiée ou recevoir une nouvelle valeur.

Vous pouvez déclarer une constante dans une procédure ou au début d'un module dans la section Déclarations. Les constantes de niveau module sont privées par défaut. Pour déclarer une constante de niveau module public, faites précéder l'instruction Const du mot clé Public. Vous pouvez déclarer explicitement une constante privée en faisant précéder l'instruction Const du mot clé Private pour simplifier la lecture et l'interprétation de votre code. Pour plus d'informations, recherchez la rubrique "Portée et visibilité" dans l'aide de Visual Basic.

L'exemple suivant déclare la constante Public conAge comme une constante de type Integer et lui attribue la valeur 34.

Public Const conAge As Integer = 34

Les constantes peuvent être déclarées avec les types de données suivants : Boolean, Byte, Integer, Long, Currency, Single, Double, Date, String ou Variant. Puisque vous connaissez déjà la valeur d'une constante, vous pouvez spécifier le type de données dans une instruction Const. Pour plus d'informations sur les types de données, recherchez "Types de données" dans l'aide de Visual Basic.

Vous pouvez déclarer plusieurs constantes dans une instruction. Pour spécifier un type de données, vous devez indiquer ce type pour chaque constante. Dans l'instruction suivante, les constantes conAge et conWage sont déclarées comme données de type Integer.

Const conAge As Integer = 34, conWage As Currency = 35000


Déclaration de variables

Lors de la déclaration de variables, vous employez généralement une instruction Dim. Une instruction de déclaration peut être placée dans une procédure pour créer une variable de niveau procédure. Elle peut être également placée au début d'un module, dans la section Déclarations, pour créer une variable de niveau module.

L'exemple suivant crée la variable strName et spécifie le type de données String.

Dim strName As String

Si cette instruction apparaît dans une procédure, la variable strName peut être utilisée uniquement dans cette procédure. Si l'instruction apparaît dans la section Déclarations du module, la variable strName est accessible dans toutes les procédures du module, mais pas dans les procédures des autres modules du projet. Pour faire en sorte que cette variable soit accessible dans toutes les procédures du projet, faites-la précéder de l'instruction Public, comme dans l'exemple suivant :

Public strName As String

Pour plus d'informations sur l'affectation de nom à vos variables, recherchez "Règles d'affectation de noms Visual Basic" dans l'aide de Visual Basic.

Les variables peuvent être déclarées dans les types de données suivants : Boolean, Byte, Integer, Long, Currency, Single, Double, Date, String (pour les chaînes à longueur variable), String * length (pour les chaînes à longueur fixe), Object ou Variant. Si vous ne spécifiez pas le type de données, Variant est pris par défaut. Vous pouvez également créer un type défini par l'utilisateur à l'aide de l'instruction Type. Pour plus d'informations sur les types de données, recherchez "Type de données" dans l'aide de Visual Basic.

Vous pouvez déclarer plusieurs variables dans une instruction. Pour spécifier un type de données, vous devez inclure le type de données pour chaque variable. Dans l'instruction suivante, les variables intX, intY et intZ sont déclarées avec le type Integer.

Dim intX As Integer, intY As Integer, intZ As Integer

Dans l'instruction suivante, intX et intY sont déclarés avec le type Variant ; seul intZ est déclaré avec le type Integer.

Dim intX, intY, intZ As Integer

Vous pouvez omettre le type de données de la variable dans l'instruction de déclaration. Dans ce cas, la variable prend le type Variant.

Utilisation de l'instruction Public

L'instruction Public permet de déclarer des variables publiques dans un module.

Public strName As String

Les variables publiques peuvent être utilisées dans n'importe quelle procédure du projet. Si une variable publique est déclarée dans un module standard ou dans un module de classe, elle peut également être employée dans n'importe quel projet faisant référence au projet où la variable publique est déclarée.

Utilisation de l'instruction Private

L'instruction Private permet de déclarer des variables privées dans un module.

Private MyName As String

Les variables privées peuvent être utilisées uniquement par les procédures du même module.

Note   Lorsqu'elle est utilisée au niveau module, l'instruction Dim équivaut à l'instruction Private. Il convient parfois d'utiliser l'instruction Private pour simplifier la lecture et l'interprétation de votre code.

Utilisation de l'instruction Static

Lorsque vous employez l'instruction Static à la place de l'instruction Dim, la variable déclarée conserve sa valeur entre les appels.

Utilisation de l'instruction Option Explicit

Vous pouvez déclarer implicitement une variable dans Visual Basic avec une simple instruction d'affectation. Toutes les variables ainsi déclarées sont de type Variant. Les variables de type Variant nécessitent plus de ressources mémoire que les autres. Vous améliorerez l'efficacité de votre application en déclarant les variables explicitement, avec un type de données spécifique. La déclaration explicite de toutes les variables réduit les risques de conflit d'affectation de nom et de faute de frappe.

Si vous ne souhaitez pas que Visual Basic effectue des déclarations implicites, placez l'instruction Option Explicit dans un module avant toute procédure. Cette instruction impose la déclaration explicite de toutes les variables dans le module. Si un module inclut l'instruction Option Explicit, une erreur se produit au moment de la compilation si Visual Basic rencontre un nom de variable n'ayant pas été précédemment déclaré, ou lorsqu'une faute de frappe se glisse dans un nom de variable déclarée.

Vous pouvez définir une option dans votre environnement de programmation Visual Basic prévoyant l'inclusion automatique de l'instruction Option Explicit dans tous les nouveaux modules. Pour la modification des options d'environnement de Visual Basic, consultez la documentation de votre application. Notez que cette option ne change pas le code existant déjà écrit.

Note   Vous devez déclarer explicitement des tableaux fixes et des tableaux dynamiques.

Déclaration d'une variable objet pour Automation

Lorsque vous utilisez une application pour contrôler les objets d'autres applications, vous devez établir une référence à la bibliothèque de types de l'autre application. Une fois cette référence définie, vous pouvez déclarer des variables objet conformément à leur type spécifique. Par exemple, si vous êtes dans Microsoft Word lors de la définition d'une référence à la bibliothèque de types Microsoft Excel, vous pouvez déclarer une variable de type Worksheet à l'intérieur de Microsoft Word pour représenter un objet Worksheet Microsoft Excel.

Si vous utilisez une autre application pour contrôler des objets Microsoft Access, dans la plupart des cas vous pouvez déclarer des variables objet selon leur type le plus spécifique. Il est également possible d'utiliser le mot clé New pour créer automatiquement une nouvelle instance d'un objet. Cependant, vous devrez éventuellement indiquer qu'il s'agit d'un objet Microsoft Access. Par exemple, lors de la déclaration d'une variable objet pour représenter un formulaire Microsoft Access dans Microsoft Visual Basic, vous devez établir une distinction entre l'objet Form Microsoft Access et l'objet Form Visual Basic. Incluez le nom de la bibliothèque de types dans la déclaration de la variable comme dans l'exemple suivant :

Dim frmOrders As New Access.Form

Certaines applications ne reconnaissent pas les types d'objet Microsoft Access individuels. Même si vous définissez une référence à la bibliothèque de types Microsoft Access dans ces applications, vous devez déclarer toutes les variables objet Microsoft Access avec le type Object. Vous ne pouvez pas non plus utiliser le mot clé New pour créer une nouvelle instance de l'objet. L'exemple suivant indique comment déclarer une variable pour représenter une instance de l'objet Application Microsoft Access à partir d'une application ne reconnaissant pas les types d'objet Microsoft Access. L'application crée ensuite une instance de l'objet Application.

Dim appAccess As Object

Set appAccess = CreateObject("Access.Application")

Pour déterminer la syntaxe prise en charge par une application, consultez la documentation de cette application.


Exécution d'un code lors de la définition des propriétés

Vous pouvez créer des procédures Property Let, Property Set et Property Get partageant le même nom. Vous pouvez ainsi créer un groupe de procédures associées travaillant ensemble. Une fois qu'un nom est utilisé par une procédure Property, ce nom ne peut pas être utilisé pour nommer une procédure Sub ou Function, une variable, ou un type défini par l'utilisateur.

L'instruction Property Let permet de créer une procédure définissant la valeur de la propriété. Une procédure Property peut ainsi créer une propriété d'inversion pour une image bitmap sur un formulaire. L'exemple ci-dessous présente la syntaxe utilisée pour appeler la procédure Property Let :

Form1.Inverted = True

L'inversion proprement dite d'une image bitmap sur le formulaire est effectuée à l'intérieur de la procédure Property Let :

Private IsInverted As Boolean

Property Let Inverted(X As Boolean)

IsInverted = X

If IsInverted Then

…

(statements)

Else

(statements)

End If

End Property

La variable de niveau module IsInverted stocke la valeur de la propriété. En la déclarant Private, l'utilisateur peut uniquement la modifier à l'aide de la procédure Property Let. Utilisez un nom permettant de voir facilement que la variable est utilisée pour la propriété.

Cette procédure Property Get est utilisée pour renvoyer l'état courant de la propriété Inverted :

Property Get Inverted() As Boolean

Inverted = IsInverted

End Property

Les procédures de propriété simplifient l'exécution d'un code en même temps que la définition de la valeur d'une propriété. Vous pouvez utiliser des procédures de propriété pour effectuer le traitement suivant :

•	Avant la définition d'une valeur de propriété pour déterminer la valeur de la propriété.

•	Après la définition de la valeur d'une propriété, en fonction de la nouvelle valeur.


Itération dans le code

A l'aide d'instructions conditionnelles et d'instructions d'itération (également qualifiées de structures de contrôle), vous pouvez écrire un code Visual Basic prenant des décisions et répétant des actions. Une autre structure de contrôle pratique, l'instruction With, permet d'exécuter une série d'instructions sans devoir requalifier un objet.

Utilisation d'instructions conditionnelles pour prendre des décisions

Les instructions conditionnelles évaluent si une condition a la valeur True ou False, puis spécifie une ou plusieurs instructions à exécuter, selon le résultat. Généralement, une condition correspond à une expression qui utilise un opérateur de comparaison pour comparer une valeur ou une variable à une autre.

Choix d'une instruction conditionnelle à employer

•	If...Then...Else : Branchement lorsqu'une condition a la valeur True ou False.

•	Select Case : Sélection d'un branchement en fonction d'un ensemble de conditions.

Utilisation de boucles pour répéter un code

L'itération permet d'exécuter un groupe d'instructions de façon répétitive. Certaines boucles répètent des instructions jusqu'à ce qu'une condition prenne la valeur False ; d'autres répètent des instructions jusqu'à ce qu'une condition ait la valeur True. Il existe également des boucles qui répètent des instructions un certain nombre de fois ou pour chaque objet d'une collection.

Choix de la boucle à employer

•	Do...Loop : Itération pendant qu'une condition a la valeur True ou jusqu'à ce qu'elle l'ait.

•	For...Next : Utilisation d'un compteur pour exécuter des instructions un certain nombre de fois.

•	For Each...Next : Répétition d'un groupe d'instructions pour chaque objet d'une collection.

Exécution de plusieurs instructions sur le même objet

Dans Visual Basic, vous devez généralement spécifier un objet avant de pouvoir exécuter l'une de ses méthodes ou modifier l'une de ses propriétés. L'instruction With permet de spécifier en une fois un objet pour toute une série d'instructions.

•	With : Exécution d'une série d'instructions sur le même objet.


Création de boucles For...Next plus rapides

Les entiers utilisent moins de mémoire que les données de type Variant et sont mis à jour plus rapidement. Cependant, cette différence est significative uniquement si vous effectuez des milliers d'opérations. Par exemple :

Dim CountFaster As Integer	' Premier cas, utilise Integer.

For CountFaster = 0 to 32766

Next CountFaster

Dim CountSlower As Variant	' Second cas, utilise Variant.

For CountSlower = 0 to 32766

Next CountSlower

Le premier cas ci-dessus s'exécute plus rapidement que le second cas. Cependant, si CountFaster dépasse 32 767, une erreur se produit. Pour la corriger, attribuez le type de données Long à la variable CountFaster pour accepter une plage de nombres entiers plus large. En général, plus le type de données est petit, plus la mise à jour est rapide. Les variables de type Variant sont légèrement plus lentes que les types de données équivalents.


Passage efficace d'arguments

Tous les arguments sont passés aux procédures par référence, sauf indication contraire. Cette méthode est efficace en ce sens que le temps de passage des arguments et l'espace mémoire qu'ils occupent dans une procédure (4 octets) sont les mêmes quel que soit le type de données de l'argument.

Vous pouvez également passer un argument par valeur en incluant le mot clé ByVal dans la déclaration de la procédure. Un argument passé par valeur occupe de 2 à 16 octets dans la procédure, en fonction de son type de données. Les types de données plus importants impliquent un temps de traitement supérieur à celui des types de données moins volumineux. Les types de données String et Variant ne doivent donc généralement pas être passés par valeur.

Lorsqu'un argument est passé par valeur, la variable d'origine est copiée dans la procédure. Les modifications apportées ensuite à l'argument au sein de la procédure ne sont pas répercutées sur la variable d'origine. Par exemple :

Function Factorial (ByVal MyVar As Integer)	' Déclare la fonction.

MyVar = MyVar - 1

If MyVar = 0 Then

Factorial = 1

Exit Function

End If

Factorial = Factorial(MyVar) * (MyVar + 1)

End Function

' Appel de la fonction Factorial avec une variable S.

S = 5

Print Factorial(S)	' Affiche 120 (factorielle 5)

Print S	' Affiche 5.

En l'absence de ByVal dans la déclaration de fonction, les instructions Print de l'exemple précédent affichent les valeurs 1 et 0. En effet, MyVar fait alors référence à la variable S, qui est décrémentée de 1 jusqu'à ce qu'elle atteigne la valeur 0.

Dans la mesure où un argument passé par la méthode ByVal est copié dans la procédure, vous avez la possibilité de passer un variant à la fonction Factorial de l'exemple. En effet, vous ne pouvez pas passer un variant par référence si la procédure qui déclare l'argument est d'un type de données différent.


Renvoi de chaînes à partir de fonctions

Certaines fonctions existent en deux versions : une première renvoie un type de données Variant, une autre un type de données String. La première est plus pratique car les variants opèrent automatiquement des conversions entre différents types de données. Ce type de données permet également la propagation de Null dans une expression. La version String est plus efficace car elle utilise moins de mémoire.

Employez la version renvoyant un type de données String dans les cas suivants :

•	Votre programme est très long et fait intervenir un grand nombre de variables.

•	Vous écrivez des données directement dans des fichiers en accès aléatoire.

Les fonctions suivantes renvoient des valeurs dans des variables de type String si vous faites suivre leur nom du signe dollar ($). Leur utilisation et leur syntaxe sont les mêmes que pour leurs équivalents de type Variant sans signe dollar.

Chr$	ChrB$	*Command$
CurDir$	Date$	Dir$
Error$	Format$	Hex$
Input$	InputB$	LCase$
Left$	LeftB$	LTrim$
Mid$	MidB$	Oct$
Right$	RightB$	RTrim$
Space$	Str$	String$
Time$	Trim$	UCase$
* Peuvent ne pas être disponibles dans certaines applications.


Compilation conditionnelle

La compilation conditionnelle permet d'exécuter des blocs de code sélectivement, par exemple des instructions de débogage comparant la vitesse de différentes approches pour la même tâche de programmation, ou la localisation d'une application dans différentes langues.

Vous déclarez une constante de compilation conditionnelle avec la directive #Const, et vous précisez les blocs de code à compiler conditionnellement avec la directive #If...Then...#Else. L'exemple suivant exécute le code de débogage ou le code de production, selon la valeur de la variable conDebug.

' Déclare une constante de compilation publique dans la section 	'Déclarations.

#Const conDebug = 1

Sub SelectiveExecution()

#If conDebug = 1 Then

.	' Exécute un code avec instructions de débogage.

.

.

#Else

.	' Exécute le code normal.

.

.

#End If

End Sub


Durée de vie des variables

La période pendant laquelle une variable conserve sa valeur correspond à sa durée de vie. La valeur d'une variable peut changer pendant sa durée de vie, mais elle conserve une certaine valeur. Lorsqu'une variable perd sa portée, elle n'a plus de valeur.

Au début d'une procédure, toutes les variables sont initialisées. Une variable numérique est initialisée à zéro, une chaîne de longueur variable est initialisée à une chaîne de longueur nulle (""), et une chaîne de longueur fixe est remplie du caractère représentant le code de caractères ASCII 0, ou Chr(0). Les variables de type Variant prennent initialement la valeur Empty. Chaque élément d'une variable d'un type défini par l'utilisateur est initialisé comme s'il s'agissait d'une variable séparée.

Lorsque vous déclarez une variable objet, de l'espace est réservé en mémoire, mais elle prend la valeur Nothing jusqu'à ce que vous lui affectiez une référence d'objet à l'aide d'une instruction Set.

Si la valeur d'une variable n'est pas modifiée pendant l'exécution de votre code, elle conserve sa valeur initialisée jusqu'à ce qu'elle perde sa portée.

Une variable de niveau procédure déclarée avec l'instruction Dim conserve une valeur jusqu'à la fin de la procédure. Si la procédure appelle d'autres procédures, la variable conserve également sa valeur pendant l'exécution de ces procédures.

Si une variable de niveau procédure est déclarée avec le mot clé Static, elle conserve sa valeur tant que le code est exécuté dans un module. À la fin de l'exécution du code, la variable perd sa portée et sa valeur. Sa durée de vie est identique à celle d'une variable de niveau module.

Une variable de niveau module diffère d'une variable statique. Dans un module standard ou un module de classe, elle conserve sa valeur jusqu'à ce que vous arrêtiez le code. Dans un module de classe, elle conserve sa valeur tant qu'existe une instance de la classe. Les variables de niveau module utilisant des ressources mémoire jusqu'à la réinitialisation de leurs valeurs, il convient de les utiliser uniquement lorsque cela est nécessaire.

Si vous incluez le mot clé Static avant une instruction Sub ou Function, les valeurs de toutes les variables de niveau procédure dans la procédure sont conservées entre les appels.


Arguments nommés et facultatifs

Lorsque vous appelez une procédure Sub ou Function, vous pouvez fournir les arguments par position, dans leur ordre d'occurrence dans la définition de la procédure, ou les fournir par nom sans respecter cette position.

Par exemple, la procédure Sub suivante prend trois arguments :

Sub PassArgs(strName As String, intAge As Integer, dteBirth As Date)

Debug.Print strName, intAge, dteBirth

End Sub

Vous pouvez appeler cette procédure en fournissant ses arguments à la position appropriée, chacune séparée par une virgule, comme le montre l'exemple suivant :

PassArgs "Mary", 29, #2-21-69#

Vous pouvez également appeler cette procédure en fournissant des arguments nommés séparés par des virgules.

PassArgs intAge:=29, dteBirth:=#2/21/69#, strName:="Mary"

Un argument nommé est composé d'un nom d'argument suivi des signes deux-points et égal (:=), puis de la valeur de l'argument.

Les arguments nommés sont particulièrement pratiques lors de l'appel d'une procédure comportant des arguments facultatifs. Si vous utilisez des arguments nommés, il n'est pas nécessaire d'inclure des virgules pour signaler les arguments positionnels manquants. L'utilisation d'arguments nommés permet de voir plus facilement les arguments passés et omis.

Les arguments facultatifs sont précédés du mot clé Optional dans la définition de la procédure. Vous pouvez également préciser une valeur par défaut pour l'argument facultatif dans la définition de la procédure. Par exemple :

Sub OptionalArgs(strState As String, Optional strCountry As String = "USA")

. . .

End Sub

Lorsque vous appelez une procédure avec un argument facultatif, vous pouvez préciser ou non l'argument facultatif. Si vous ne le précisez pas, la valeur par défaut, le cas échéant, est employée. Si aucune valeur par défaut n'est spécifiée, l'argument prend la valeur par défaut de la variable du type spécifié.

La procédure suivante inclut un argument facultatif, la variable varCountry. La fonction IsMissing détermine si un argument facultatif a été passé à la procédure.

Sub OptionalArgs(strState As String, Optional intRegion As Integer, _

Optional strCountry As String = "USA")

If IsMissing(intRegion) And IsMissing(strCountry) Then

Debug.Print strState

ElseIf IsMissing(strCountry) Then

Debug.Print strState, intRegion

ElseIf IsMissing(intRegion) Then

Debug.Print strState, strCountry

Else

Debug.Print strState, intRegion, strCountry

End If

End Sub

Vous pouvez appeler cette procédure en utilisant des arguments nommés comme le montrent les exemples suivants :

OptionalArgs strCountry:="USA", strState:="MD"

OptionalArgs strState:= "MD", intRegion:=5


Objets, propriétés, méthodes et événements

Un objet représente un élément d'une application, tel qu'une feuille de calcul, une cellule, un graphique, un feuille ou un état. Dans un code Visual Basic, vous devez identifier un objet avant de pouvoir appliquer l'une des méthodes de l'objet ou modifier la valeur de l'une de ses propriétés.

Une collection est un objet contenant plusieurs autres objets, généralement, mais pas toujours, du même type. Dans Microsoft Excel, par exemple, l'objet Workbooks contient tous les objets Workbook. Dans Visual Basic, la collection Forms contient tous les objets Form d'une application.

Les éléments d'une collection peuvent être identifiés par numéro ou par nom. Par exemple, dans la procédure suivante, Workbooks(1) identifie le premier objet Workbook ouvert.

Sub CloseFirst()

Workbooks(1).Close

End Sub

La procédure suivante utilise un nom spécifié sous forme de chaîne pour identifier un objet Form.

Sub CloseForm()

Forms("MyForm.frm").Close

End Sub

Vous pouvez également manipuler toute une collection d'objets si les objets partagent des méthodes communes. Par exemple, la procédure suivante ferme tous les formulaires ouverts.

Sub CloseAll()

Forms.Close

End Sub

Une méthode est une action qu'un objet peut exécuter. Par exemple, Add est une méthode de l'objet ComboBox qui ajoute une nouvelle entrée à une liste modifiable.

La procédure suivante utilise la méthode Add pour ajouter un nouvel élément à ComboBox.

Sub AddEntry(newEntry as String)

Combo1.Add newEntry

End Sub

Une propriété est un attribut d'un objet définissant l'une des caractéristiques de l'objet telle que la taille, la couleur ou la position à l'écran, ou un aspect de son comportement, par exemple s'il est activé ou visible. Pour changer les caractéristiques d'un objet, changez les valeurs de ses propriétés.

Pour définir la valeur d'une propriété, faites suivre la référence d'un objet d'un point, du nom de la propriété, d'un signe égal (=) et de la nouvelle valeur de propriété. Par exemple, la procédure suivante change la légende d'une feuille Visual Basic en définissant la propriété Caption.

Sub ChangeName(newTitle)

myForm.Caption = newTitle

End Sub

Certaines propriétés ne peuvent pas être définies. La rubrique d'aide de chaque propriété indique si vous pouvez la définir (lecture-écriture), seulement la lire (lecture seule) ou seulement y écrire (écriture seule).

Vous pouvez extraire des informations sur un objet en renvoyant la valeur de l'une de ses propriétés. La procédure suivante utilise un message pour afficher le titre apparaissant en haut de la feuille actuellement active.

Sub GetFormName()

formName = Screen.ActiveForm.Caption

MsgBox formName

End Sub

Un événement est une action reconnue par un objet, telle qu'un clic de la souris ou la frappe d'une touche, et pour laquelle vous pouvez écrire un code de réponse. Les événements peuvent être déclenchés par une action de l'utilisateur, par le code d'un programme ou par le système.

Renvoi d'objets

À chaque application correspond un mode de renvoi des objets qu'elle contient. Ce mode étant variable, reportez-vous à la rubrique d'aide de l'objet ou de la collection utilisé dans l'application pour savoir comment renvoyer l'objet.


Automation

Automation (anciennement OLE Automation) est une fonction du modèle d'objet composant (COM, Component Object Model), technologie normalisée utilisée par les applications pour exposer leurs objets aux outils de développement, aux langages de macro et autres applications supportant Automation. Par exemple, une application de tableur peut exposer une feuille de calcul, un graphique, une cellule ou une plage de cellules (chacun des ces éléments sous la forme d'un type d'objet différent). Un programme de traitement de texte peut exposer des objets, tels qu'une application, un document, un paragraphe, une phrase, un signet ou une sélection.

Lorsqu'une application supporte Automation, les objets que l'application expose sont accessibles par Visual Basic. Utilisez Visual Basic pour manipuler ces objets en invoquant des méthodes sur l'objet, ou en obtenant ou en définissant les propriétés de l'objet. Par exemple, vous pouvez créer un objet Automation nommé MyObj et écrire le code suivant pour y accéder :

MyObj.Insert "Bonjour à tous."	' Place le texte.

MyObj.Bold = True	' Formate le texte.

If Mac = True then	' Vérifie la constante de votre plate-forme

MyObj.SaveAs "HD:\WORDPROC\DOCS\TESTOBJ.DOC"	' Enregistre l'objet (Macintosh).

Else

MyObj.SaveAs  "C:\WORDPROC\DOCS\TESTOBJ.DOC"	' Enregistre l'objet (Windows).

Utilisez les fonctions suivantes pour accéder à un objet Automation :

Fonction	Description
CreateObject	Crée un nouvel objet du type spécifié.
GetObject	Extrait un objet d'un fichier.
Pour obtenir des informations détaillées sur les propriétés et méthodes gérées par une application, consultez la documentation de cette dernière. Les objets, fonctions, propriétés et méthodes gérés par une application sont généralement définis dans sa bibliothèque d'objets.


Tableaux de paramètres

Un tableau de paramètres peut être utilisé pour passer un tableau d'arguments à une procédure. Il n'est pas nécessaire de connaître le nombre d'éléments du tableau lors de la définition de la procédure.

Vous utilisez le mot clé ParamArray pour déclarer un tableau de paramètres. Le tableau doit être déclaré comme un tableau de type Variant, et il doit être le dernier argument de la définition de la procédure.

L'exemple suivant illustre la définition d'une procédure comportant un tableau de paramètres.

Sub AnyNumberArgs(strName As String, ParamArray intScores() As Variant)

Dim intI As Integer

Debug.Print strName; "    Résultats"

' Utilise la fonction UBound pour déterminer la limite supérieure du 	'tableau.

For intI = 0 To UBound(intScores())

Debug.Print "    "; intScores(intI)

Next intI

End Sub

Les exemples suivants indiquent comment appeler cette procédure.

AnyNumberArgs "Jamie", 10, 26, 32, 15, 22, 24, 16

AnyNumberArgs "Kelly", "Haut", "Bas", "Moyen", "Haut"


Portée et visibilité

La portée se réfère à la disponibilité d'une variable, d'une constante ou d'une procédure en vue d'une utilisation par une autre procédure. Il existe trois niveaux de portée : niveau de procédure, niveau de module privé et niveau de module public.

Vous choisissez la portée d'une variable lors de sa déclaration. Il convient de déclarer toutes les variables explicitement pour éviter les erreurs de conflit d'affectation de nom entre variables de différentes portées.

Définition d'une portée de niveau procédure

Une variable ou une constante définie dans une procédure n'est pas visible à l'extérieur de celle-ci. Seule la procédure contenant la déclaration de variable peut l'utiliser. Dans l'exemple suivant, la première procédure affiche un message contenant une chaîne. La deuxième procédure affiche un message vide puisque la variable strMsg est locale dans la première procédure.

Sub LocalVariable()

Dim strMsg As String

strMsg = "Cette variable ne peut pas être utilisée en dehors de " & "cette procédure."

MsgBox strMsg

End Sub

Sub OutsideScope()

MsgBox strMsg

End Sub

Définition d'une portée de niveau module privée

Vous pouvez définir des variables et constantes de niveau module dans la section Déclarations d'un module. Les variables de niveau module peuvent être publiques ou privées. Les variables publiques sont accessibles dans toutes les procédures de tous les modules d'un projet ; les variables privées sont disponibles uniquement dans les procédures de ce module. Par défaut, les variables déclarées avec l'instruction Dim dans la section Déclarations ont une portée privée. Vous pouvez toutefois faire précéder la variable du mot clé Private pour améliorer la lisibilité de votre code.

Dans l'exemple suivant, la variable de chaîne strMsg est accessible dans toutes les procédures définies dans le module. Lorsque la deuxième procédure est appelée, elle affiche le contenu de la variable de chaîne strMsg dans une boîte de dialogue.

' Ajoute ce qui suit dans la section  Déclarations du module.

Private strMsg sAs String

Sub InitializePrivateVariable()

strMsg = "Cette variable ne peut pas être utilisée à l'extérieur " & " de ce module."

End Sub

Sub UsePrivateVariable()

MsgBox strMsg

End Sub

Note   Les procédures publiques dans un module standard ou dans un module de classe sont accessibles dans n'importe quel projet référant. Pour limiter au projet en cours la portée de toutes les procédures d'un module, ajoutez une instruction Option Private Module dans la section Déclarations du module. Les variables et les procédures publiques seront toujours accessibles dans les autres procédures du projet en cours, mais pas dans les projets référants.

Définition d'une portée de niveau module publique

Si vous déclarez une variable de niveau module comme publique, elle est accessible dans toutes les procédures du projet. Dans l'exemple suivant, la variable de chaîne strMsg peut être utilisée par n'importe quelle procédure de n'importe quel module du projet.

' Inclut dans la section Déclarations du module.

Public strMsg As String

Toutes les procédures sont publiques par défaut, à l'exception des procédures d'événement. Lorsque Visual Basic crée une procédure d'événement, le mot clé Private est automatiquement inséré avant la déclaration de la procédure. Pour toutes les autres procédures, vous devez explicitement déclarer la procédure avec le mot clé Private si vous ne souhaitez pas la rendre publique.

À partir de projets référants, vous pouvez utiliser des procédures, des variables et des constantes publiques définies dans des modules standard ou des modules de classe. Cependant, vous devez d'abord définir une référence au projet dans lequel elles sont définies.

Les procédures, les variables et les constantes publiques définies dans des modules autres que des modules standard ou de classe, tels que des modules de feuilles ou des modules d'état, ne sont pas accessibles dans des projets référants, puisque ces modules sont privés dans leur projet de résidence.


Variants

Le type de données Variant est automatiquement spécifié si vous ne précisez pas de type de données lors de la déclaration d'une constante, d'une variable ou d'un argument. Les variables déclarées avec le type de données Variant peuvent contenir une chaîne, une date, une heure, une valeur booléenne ou numérique et peuvent convertir automatiquement les valeurs qu'ils contiennent. Les valeurs numériques de type Variant nécessitent 16 octets de mémoire (caractéristique à prendre en compte dans les grandes procédures ou les modules complexes) et offrent un accès plus lent que les variables déclarées explicitement avec un autre type. Le type de données Variant est rarement employé pour une constante. Les valeurs de chaîne de type Variant nécessitent 22 octets de mémoire.

Les instructions suivantes créent des variables Variant :

Dim myVar

Dim yourVar As Variant

theVar = "Voici du texte."

La dernière instruction ne déclare pas la variable theVar explicitement, mais plutôt implicitement ou automatiquement. Les variables déclarées implicitement prennent le type de données Variant.

Conseil   Si vous spécifiez un type de données pour une variable ou un argument, puis n'utilisez pas le bon type de données, une erreur de type de données se produit. Pour éviter cet incident, utilisez uniquement des variables implicites (de type Variant) ou déclarez explicitement toutes les variables et spécifiez un type de données. La dernière méthode est préférable.


Syntaxe de Visual Basic

La syntaxe présentée dans une rubrique d'aide Visual Basic pour une méthode, une instruction ou une fonction indique les éléments nécessaires pour utiliser correctement chaque élément. Les exemples de cette rubrique illustrent les éléments de syntaxe employés le plus fréquemment.

Syntaxe de la méthode Activate

object.Activate

Dans la syntaxe de la méthode Activate, le mot en italique "object" est un espace réservé pour les informations à fournir (dans ce cas, code renvoyant un objet). Les mots en gras doivent être tapés tels quels. Par exemple, la procédure suivante active la deuxième fenêtre du document actif.

Sub MakeActive()

Windows(2).Activate

End Sub

Syntaxe de la fonction MsgBox

MsgBox(prompt[, buttons] [, title] [, helpfile, context])

Dans la syntaxe de la fonction MsgBox, les mots en italique sont des arguments nommés de la fonction. Les arguments entre crochets sont facultatifs. Ne tapez pas les crochets dans votre code Visual Basic. Pour la fonction MsgBox, le seul argument à fournir est le texte de l'invite.

Les arguments des fonctions et des méthodes peuvent être spécifiés dans le code par position ou par nom. Pour spécifier des arguments par position, suivez l'ordre présenté dans la syntaxe, en séparant les arguments par des virgules, par exemple :

MsgBox "Votre réponse est correcte!",0,"Réponse"

Pour spécifier un argument par nom, utilisez le nom de l'argument suivi des signes deux-points et égal (:=), puis de la valeur de l'argument. Vous pouvez spécifier des arguments nommés dans n'importe quel ordre, par exemple :

MsgBox Title:="Réponse", Prompt:="Votre réponse est correcte!"

La syntaxe des fonctions et de certaines méthodes présente les arguments entre parenthèses. Ces fonctions et ces méthodes renvoyant des valeurs, vous devez mettre les arguments entre parenthèses pour attribuer la valeur à une variable. Si vous ignorez la valeur renvoyée ou si vous ne passez pas d'arguments, omettez les parenthèses. Pour les méthodes ne renvoyant pas de valeurs, il n'est pas nécessaire de mettre les arguments entre parenthèses. Ces directives s'appliquent aussi bien aux arguments positionnels qu'aux arguments nommés.

Dans l'exemple suivant, la valeur renvoyée par la fonction MsgBox est un nombre indiquant le bouton sélectionné, stocké dans la variable myVar. La valeur renvoyée étant utilisée, les parenthèses sont nécessaires. Un autre message affiche la valeur de la variable.

Sub Question()

myVar = MsgBox(Prompt:="J'aime mon travail.", _

Title:="Zone de réponse", Buttons:="4")

MsgBox myVar

End Sub

Syntaxe de l'instruction Option

Option Compare {Binary | Text | Database}

Dans la syntaxe de l'instruction Option Compare, les accolades et les barres verticales indiquent un choix obligatoire entre trois options. Ne tapez pas les accolades dans l'instruction Visual Basic. Par exemple, l'instruction suivante précise qu'à l'intérieur du module, les chaînes seront comparées dans un ordre de tri ne respectant pas la casse.

Option Compare Text

Syntaxe de l'instruction Dim

Dim varname[([subscripts])] [As type] [, varname[([subscripts])] [As type]] . . .

Dans la syntaxe de l'instruction Dim, le mot Dim est un mot clé obligatoire. Le seul élément requis est varname (le nom de la variable). Par exemple, l'instruction suivante crée trois variables : myVar, nextVar et thirdVar. Celles-ci sont automatiquement déclarées comme variables de type Variant.

Dim myVar, nextVar, thirdVar

L'exemple suivant déclare une variable de type String. L'inclusion d'un type de variable économise de la mémoire et diminue les risques d'erreurs.

Dim myAnswer As String

Pour déclarer plusieurs variables dans une instruction, incluez le type de données pour chaque variable. Les variables déclarées sans type de données prennent automatiquement le type Variant.

Dim x As Integer, y As Integer, z As Integer

Dans l'instruction suivante, x et y prennent le type de données Variant. Seul z prend le type de données Integer.

Dim x, y, z As Integer

Si vous déclarez une variable tableau, vous devez inclure des parenthèses. Les indices sont facultatifs. L'instruction suivante dimensionne un tableau dynamique, myArray.

Dim myArray()


Utilisation des tableaux

Vous pouvez déclarer un tableau pour traiter un ensemble de valeurs du même type de données. Un tableau est une variable simple comportant de nombreux compartiments permettant de stocker autant de valeurs, par opposition à une variable classique dotée d'un compartiment destiné à une seule valeur. Vous pouvez faire référence au tableau globalement lorsque vous souhaitez faire référence à toutes les valeurs qu'il contient, ou faire référence à ses éléments individuels.

Par exemple, pour stocker les dépenses quotidiennes de chaque jour de l'année, vous pouvez déclarer une variable tableau comportant 365 éléments plutôt que de déclarer 365 variables. Chaque élément du tableau contient une valeur. L'instruction suivante déclare la variable de tableau curExpense avec 365 éléments. Par défaut, un tableau étant indexé à partir de zéro, la limite supérieure de ce tableau est 364 et non 365.

Dim curExpense(364) As Currency

Pour définir la valeur d'un élément individuel, spécifiez l'index de l'élément. L'exemple suivant attribue une valeur initiale de 20 à chaque élément du tableau.

Sub FillArray()

Dim curExpense(364) As Currency

Dim intI As Integer

For intI = 0 to 364

curExpense(intI) = 20

Next

End Sub

Modification de la limite inférieure

L'instruction Option Base placée au début d'un module permet de changer l'index par défaut du premier élément de 0 à 1. Dans l'exemple suivant, l'instruction Option Base change l'index du premier élément, et l'option Dim déclare la variable de tableau curExpense avec 365 éléments.

Option Base 1

Dim curExpense(365) As Currency

Vous pouvez également définir explicitement la limite inférieure d'un tableau avec une clause To, comme le montre l'exemple suivant.

Dim curExpense(1 To 365) As Currency

Dim strWeekday(7 To 13) As String

Stockage de valeurs de type Variant dans les tableaux

Vous pouvez créer des tableaux de valeurs de type Variant de deux manières. La première consiste à déclarer un tableau du type de données Variant, comme le montre l'exemple suivant :

Dim varData(3) As Variant

varData(0) = "Claudia Bendel"

varData(1) = "4242 Maple Blvd"

varData(2) = 38

varData(3) = Format("06-09-1952", "Date, général")

L'autre méthode consiste à affecter le tableau renvoyé par la fonction Array à une variable de type Variant, comme le montre l'exemple suivant.

Dim varData As Variant

varData = Array("Ron Bendel", "4242 Maple Blvd", 38, _

Format("06-09-1952", "Date, général"))

Les éléments d'un tableau de valeurs de type Variant sont identifiés par index, quelle que soit la technique de création du tableau employée. Par exemple, l'instruction suivante peut être ajoutée à n'importe lequel des exemples précédents.

MsgBox "Les données de " & varData(0) & " ont été enregistrées."

Utilisation de tableaux multidimensionnels

Dans Visual Basic, vous pouvez déclarer des tableaux comportant jusqu'à 60 dimensions. Par exemple, l'instruction suivante déclare un tableau bidimensionnel 5 par 10.

Dim sngMulti(1 To 5, 1 To 10) As Single

Si vous comparez le tableau à une matrice, le premier argument représente les lignes, le second les colonnes.

Utilisez des instructions For...Next imbriquées pour traiter des tableaux multidimensionnels. La procédure suivante remplit un tableau bidimensionnel avec des valeurs de type Single.

Sub FillArrayMulti()

Dim intI As Integer, intJ As Integer

Dim sngMulti(1 To 5, 1 To 10) As Single

' Remplit le tableau de valeurs.

For intI = 1 To 5

For intJ = 1 To 10

sngMulti(intI, intJ) = intI * intJ

Debug.Print sngMulti(intI, intJ)

Next intJ

Next intI

End Sub


Utilisation des constantes

Vous remarquerez sans doute que votre code contient des valeurs constantes qui réapparaissent fréquemment ou que votre code se compose de certains nombres difficiles à retenir en raison de leur apparente complexité. Dans ce cas, l'utilisation de constantes facilitera la lecture et la maintenance de votre code. Une constante est un nom évocateur qui remplace un nombre ou une chaîne qui ne change pas. Vous ne pouvez pas modifier une constante ou lui attribuer une nouvelle valeur comme pour une variable.

Il existe trois types de constantes :

Les constantes intrinsèques ou les constantes définies par le système sont fournies par les applications et les contrôles. D'autres applications qui disposent de bibliothèques d'objets, telles que Microsoft Access, Microsoft Excel, Microsoft Project et Microsoft Word fournissent également la liste des constantes que vous pouvez utiliser avec leurs objets, méthodes et propriétés. Vous pouvez obtenir la liste des constantes fournies pour différentes bibliothèques d'objets l'Explorateur d'objets.

Les constantes Visual Basic sont répertoriées dans la bibliothèque de types Visual Basic pour Applications et dans la bibliothèque d'objets d'accès aux données (DAO).

Note   Visual Basic reconnaît toujours les constantes dans les applications créées dans des versions antérieures de Visual Basic ou Visual Basic pour Applications. Vous pouvez mettre à jour vos constantes avec celles répertoriées dans l'Explorateur d'objets. Il n'est pas nécessaire de déclarer dans votre application les constantes répertoriées dans l'Explorateur d'objets.

•	Les constantes symboliques ou définies par l'utilisateur sont déclarées avec l'instruction Const.

•	Les constantes de compilation conditionnelle sont déclarées avec l'instruction #Const.

Dans les versions précédentes de Visual Basic, les noms de constante étaient généralement en majuscules, avec traits de soulignement. Par exemple :

TILE_HORIZONTAL

Les constantes intrinsèques sont maintenant qualifiées pour éviter toute confusion lorsque des constantes homonymes existent dans plusieurs bibliothèques d'objets qui peuvent leur avoir affecté différentes valeurs. Il existe deux méthodes pour qualifier des noms de constante :

•	Par préfixe

•	Par référence de bibliothèque

Qualification de constantes par préfixe

Les constantes intrinsèques fournies par tous les objets apparaissent dans un format majuscules-minuscules, avec un préfixe à deux caractères indiquant la bibliothèque d'objets définissant la constante. Les constantes des bibliothèques d'objets de Visual Basic pour Applications ont le préfixe "vb" ; les constantes de la bibliothèque d'objets Microsoft Excel ont le préfixe "xl". Les exemples suivants illustrent les différents préfixes des contrôles personnalisés en fonction de la bibliothèque de types.

•	vbTileHorizontal

•	xlDialogBorder

Qualification de constantes par référence de bibliothèque

Vous pouvez également qualifier la référence à une constante avec la syntaxe suivante :

[libname.] [modulename.]constname

La syntaxe de qualification des constantes comprend les éléments suivants :

Élément	Description
libname	Facultatif. Nom de la bibliothèque de types définissant la constante. Pour la plupart des contrôles personnalisés (non disponible sur Macintosh), il correspond également au nom de classe du contrôle. Si vous ne vous souvenez pas du nom de classe du contrôle, positionnez le pointeur de la souris sur le contrôle dans la boîte à outils. Le nom de classe s'affiche dans l'Info-bulle.
modulename	Facultatif. Nom du module dans la bibliothèque de types définissant la constante. Vous pouvez trouver le nom du module avec l'Explorateur d'objets.
constname	Nom défini pour la constante dans la bibliothèque de types.
Par exemple :

Threed.LeftJustify


Utilisation efficace des types de données

Sauf indication contraire, les variables non déclarées prennent le type de données Variant. Ce type de données simplifie l'écriture des programmes, mais n'est pas toujours le plus efficace.

Il convient d'utiliser d'autres types de données dans les cas suivants :

•	Votre programme est très volumineux et utilise de nombreuses variables.

•	La vitesse de votre programme doit être optimisée.

•	Vous devez écrire des données directement dans des fichiers à accès aléatoire.

Outre le type Variant, vous pouvez utiliser les types Byte, Boolean, Integer, Long, Single, Double, Currency, Decimal, Date, Object et String. Utilisez l'instruction Dim pour déclarer une variable d'un type spécifique, par exemple :

Dim X As Integer

Cette instruction déclare qu'une variable X est de type Integer (un nombre entier compris entre -32 768 et 32 767). Si vous tentez d'attribuer à X une valeur en dehors de cette plage, une erreur se produit. Si vous tentez d'attribuer une fraction à X, le nombre est arrondi. Par exemple :

X = 32768	' Provoque une erreur.

X = 5.9	' x prend la valeur 6.


Utilisation d'instructions Do...Loop

Les instructions Do...Loop permettent d'exécuter un bloc d'instructions un nombre de fois indéfini, tant qu'une condition a la valeur True ou jusqu'à ce qu'elle prenne la valeur True.

Répétition d'instructions tant qu'une condition a la valeur True

Vous pouvez utiliser le mot clé While de deux manières pour vérifier une condition dans une instruction Do...Loop. Vous pouvez contrôler la condition avant d'entrer dans la boucle, ou le faire après au moins une exécution de la boucle.

Dans la procédure ChkFirstWhile, vous vérifiez la condition avant d'entrer dans la boucle. Si myNum prend la valeur 9 et non 20, les instructions à l'intérieur de la boucle ne sont jamais exécutées. Dans la procédure ChkLastWhile, les instructions à l'intérieur de la boucle ne sont exécutées qu'une seule fois avant que la condition prenne la valeur False.

Sub ChkFirstWhile()

counter = 0

myNum = 20

Do While myNum > 10

myNum = myNum - 1

counter = counter + 1

Loop

MsgBox "La boucle a effectué " & counter & " itérations."

End Sub

Sub ChkLastWhile()

counter = 0

myNum = 9

Do

myNum = myNum - 1

counter = counter + 1

Loop While myNum > 10

MsgBox "La boucle a effectué " & counter & " itérations."

End Sub

Répétition d'instructions jusqu'à ce qu'une condition devienne True

Le mot clé Until s'utilise de deux manières pour vérifier une condition dans une instruction Do...Loop. Vous pouvez contrôler la condition avant d'entrer dans la boucle (comme dans la procédure ChkFirstUntil), ou le faire après au moins une exécution de la boucle (comme dans la procédure ChkLastUntil). La boucle se poursuit tant que la condition conserve la valeur False.

Sub ChkFirstUntil()

counter = 0

myNum = 20

Do Until myNum = 10

myNum = myNum - 1

counter = counter + 1

Loop

MsgBox "La boucle a effectué " & counter & " itérations."

End Sub

Sub ChkLastUntil()

counter = 0

myNum = 1

Do

myNum = myNum + 1

counter = counter + 1

Loop Until myNum = 10

MsgBox "La boucle a effectué " & counter & " itérations."

End Sub

Sortie d'une instruction Do...Loop à l'intérieur de la boucle

Il est possible de quitter une instruction Do...Loop avec une instruction Exit Do. Par exemple, pour sortir d'une boucle sans fin, utilisez l'instruction Exit Do dans le bloc d'instructions True d'une instruction If...Then...Else ou d'une instruction Select Case. Si la condition prend la valeur False, la boucle s'exécute normalement.

Dans l'exemple suivant, myNum prend une valeur créant une boucle sans fin. L'instruction If...Then...Else vérifie cette condition, puis sort de la boucle pour éviter la création d'une boucle sans fin.

Sub ExitExample()

counter = 0

myNum = 9

Do Until myNum = 10

myNum = myNum - 1

counter = counter + 1

If myNum < 10 Then Exit Do

Loop

MsgBox "La boucle a effectué " & counter & " itérations."

End Sub

Note   Pour terminer une boucle sans fin, appuyez sur ESC ou sur CTRL+ATTN.


Utilisation d'instructions For...Next

Les instructions For...Next permettent de répéter un bloc d'instructions un certain nombre de fois. Les boucles For utilisent une variable de compteur dont la valeur est incrémentée ou décrémentée à chaque itération.

La procédure suivante provoque l'émission de 50 bips. L'instruction For spécifie la variable de compteur x et ses valeurs de début et de fin. L'instruction Next incrémente la variable de compteur de 1.

Sub Beeps()

For x = 1 To 50

Beep

Next x

End Sub

Le mot clé Step permet d'incrémenter ou de décrémenter la variable de compteur d'un pas spécifié. Dans l'exemple suivant, la variable de compteur j est incrémentée de 2 à chaque itération. A la fin de la boucle, total correspond à la somme de 2, 4, 6, 8 et 10.

Sub TwosTotal()

For j = 2 To 10 Step 2

total = total + j

Next j

MsgBox "Le total est de " & total

End Sub

Pour décrémenter la variable du compteur, utilisez une valeur Step négative. Dans ce cas, vous devez spécifier une valeur de fin inférieure à la valeur de début. Dans l'exemple suivant, la variable de compteur myNum est décrémentée de 2 à chaque itération. Une fois la boucle terminée, total correspond à la somme de 16, 14, 12, 10, 8, 6, 4 et 2.

Sub NewTotal()

For myNum = 16 To 2 Step -2

total = total + myNum

Next myNum

MsgBox "Le total est de " & total

End Sub

Note   Il n'est pas nécessaire d'inclure le nom de la variable du compteur après l'instruction Next. Dans les exemples précédents, ce nom était inclus pour simplifier la lecture de l'exemple.

Une instruction Exit For permet de quitter l'instruction For...Next avant que le compteur n'atteigne sa valeur de fin. Par exemple, lorsqu'une erreur se produit, utilisez l'instruction Exit For dans le bloc d'instructions True d'une instruction If...Then...Else ou Select Case qui vérifie spécifiquement cette erreur. Si l'erreur ne se produit pas, l'instruction If…Then…Else prend la valeur False, et la boucle se poursuit normalement.


Utilisation d'instructions For Each...Next

Les instructions For Each...Next répètent un bloc d'instructions pour chaque objet d'une collection ou pour chaque élément d'un tableau. Visual Basic définit automatiquement une variable à chaque itération de la boucle. Par exemple, la procédure suivante ferme toutes les feuilles à l'exception de celle contenant la procédure exécutée.

Sub CloseForms()

For Each frm In Application.Forms

If frm.Caption <> Screen.ActiveForm.Caption Then frm.Close

Next

End Sub

Le code suivant effectue une boucle parcourant tous les éléments d'un tableau et attribue à chacun la valeur de la variable d'index I.

Dim TestArray(10) As Integer, I As Variant

For Each I In TestArray

TestArray(I) = I

Next I

Itération sur une plage de cellules

Utilisez une boucle For Each...Next pour parcourir toutes les cellules d'une plage. La procédure suivante initialise une boucle dans la plage A1:D10 sur Sheet1 et met à zéro tout nombre dont la valeur absolue est inférieure à 0,01.

Sub RoundToZero()

For Each myObject in myCollection

If Abs(myObject.Value) < 0.01 Then myObject.Value = 0

Next

End Sub

Sortie anticipée d'une boucle For Each...Next

L'instruction Exit For permet de sortir d'une boucle For Each...Next. Par exemple, lorsqu'une erreur se produit, utilisez l'instruction Exit For dans le bloc d'instructions True d'une instruction If...Then...Else ou d'une instruction Select Case contrôlant spécifiquement cette erreur. Si l'erreur ne se produit pas, l'instruction If…Then…Else prend la valeur False et la boucle se poursuit normalement.

L'exemple suivant recherche la première cellule de la plage A1:B5 ne contenant pas un nombre. Dès qu'une telle cellule est trouvée, un message s'affiche et Exit For sort de la boucle.

Sub TestForNumbers()

For Each myObject In MyCollection

If IsNumeric(myObject.Value) = False Then

MsgBox "L'objet contient une valeur non numérique."

Exit For

End If

Next c

End Sub


Utilisation d'instructions If...Then...Else

L'instruction If...Then...Else permet d'exécuter une instruction spécifique ou un bloc d'instructions, selon la valeur d'une condition. Les instructions If...Then...Else peuvent être imbriquées au nombre de niveaux désiré. Cependant, pour favoriser la lisibilité du code, il est préférable d'utiliser une instruction Select Case plutôt que plusieurs niveaux d'instruction If...Then...Else imbriqués.

Exécution d'instructions si une condition a la valeur True

Pour exécuter une instruction uniquement lorsqu'une condition a la valeur True, utilisez la syntaxe à une ligne de l'instruction If...Then...Else. L'exemple suivant illustre cette syntaxe, omettant le mot clé Else :

Sub FixDate()

myDate = #2/13/95#

If myDate < Now Then myDate = Now

End Sub

Pour exécuter plusieurs lignes de code, vous devez utiliser la syntaxe multiligne. Cette syntaxe inclut l'instruction End If, comme le montre l'exemple suivant :

Sub AlertUser(value as Long)

If value = 0 Then

AlertLabel.ForeColor = "Rouge"

AlertLabel.Font.Bold = True

AlertLabel.Font.Italic = True

End If

End Sub

Exécution de certaines instructions si une condition a la valeur True, d'autres instructions si elle a la valeur False

Utilisez une instruction If...Then...Else pour définir deux blocs d'instructions exécutables : un bloc s'exécute si la condition à la valeur True, l'autre si la condition a la valeur False.

Sub AlertUser(value as Long)

If value = 0 Then

AlertLabel.ForeColor = vbRed

AlertLabel.Font.Bold = True

AlertLabel.Font.Italic = True

Else

AlertLabel.Forecolor = vbBlack

AlertLabel.Font.Bold = False

AlertLabel.Font.Italic = False

End If

End Sub

Test d'une deuxième condition si la première condition a la valeur False

Vous pouvez ajouter des instructions ElseIf à une instruction If...Then...Else pour tester une deuxième condition si la première a la valeur False. Par exemple, la procédure Function suivante calcule une prime basée sur une catégorie de travail. L'instruction qui suit l'instruction Else s'exécute si les conditions dans toutes les instructions If et ElseIf ont la valeur False.

Function Bonus(performance, salary)

If performance = 1 Then

Bonus = salary * 0.1

ElseIf performance = 2 Then

Bonus = salary * 0.09

ElseIf performance = 3 Then

Bonus = salary * 0.07

Else

Bonus = 0

End If

End Function


Utilisation de parenthèses dans du code

Les procédures Sub, les instructions imbriquées et certaines méthodes ne renvoyant pas de valeur, les arguments ne sont pas mis entre parenthèses. Par exemple :

MySub "stringArgument", integerArgument

Les procédures Function, les fonctions intégrées et certaines méthodes renvoient une valeur, mais vous pouvez ne pas en tenir compte. Dans ce cas, n'incluez pas de parenthèses. Appelez la fonction comme s'il s'agissait d'une procédure Sub. Omettez les parenthèses, indiquez les arguments et n'affectez pas la fonction à une variable. Par exemple :

MsgBox "Tâche terminée!", 0, "Boîte de tâche"

Pour utiliser la valeur renvoyée d'une fonction, mettez les arguments entre parenthèses, comme dans l'exemple suivant.

Answer3 = MsgBox("Votre salaire vous convient-il?", 4, "Question 3")

Une instruction dans une procédure Sub ou Function peut passer des valeurs à une procédure appelée à l'aide d'arguments nommés. Les directives d'utilisation de parenthèses s'appliquent que vous utilisiez ou non des arguments nommés. Lorsque vous employez ce type d'argument, vous pouvez les indiquer dans n'importe quel ordre et omettre des arguments facultatifs. Les arguments nommés sont toujours suivis des signes deux points et égal (:=), puis de leur valeur.

L'exemple suivant appelle la fonction MsgBox utilisant des arguments nommés, mais ignore la valeur renvoyée :

MsgBox Title:="Boîte de tâche", Prompt:="Tâche terminée!"

L'exemple suivant appelle la fonction MsgBox utilisant des arguments nommés et affecte la valeur renvoyée à la variable answer3 :

answer3 = MsgBox(Title:="Question 3", _

Prompt:="Votre salaire vous convient-il?", Buttons:=4)


Utilisation d'instructions Select Case

Utilisez l'instruction Select Case en remplacement de ElseIf dans des instructions If...Then...Else lors de la comparaison d'une expression à plusieurs valeurs différentes. Par opposition aux instructions If...Then...Else pouvant évaluer une expression différente pour chaque instruction ElseIf, l'instruction Select Case évalue une expression une seule fois, au début de la structure de contrôle.

Dans l'exemple suivant, l'instruction Select Case évalue l'argument performance passé à la procédure. Notez que chaque instruction Case peut contenir plusieurs valeurs, une plage de valeurs ou une combinaison de valeurs et d'opérateurs de comparaison. L'instruction Case Else facultative s'exécute si l'instruction Select Case ne correspond à aucune des valeurs des instructions Case.

Function Bonus(performance, salary)

Select Case performance

Case 1

Bonus = salary * 0.1

Case 2, 3

Bonus = salary * 0.09

Case 4 To 6

Bonus = salary * 0.07

Case Is > 8

Bonus = 100

Case Else

Bonus = 0

End Select

End Function


Utilisation d'instructions With

L'instruction With permet de spécifier un objet ou un type défini par l'utilisateur pour une série d'instructions. Les instructions With accélèrent l'exécution des procédures et permettent d'éviter des saisies répétitives.

L'exemple suivant remplit une plage de cellules du nombre 30, applique un formatage de caractères gras et choisit la couleur jaune pour l'intérieur des cellules.

Sub FormatRange()

With Worksheets("Sheet1").Range("A1:C10")

.Value = 30

.Font.Bold = True

.Interior.Color = RGB(255, 255, 0)

End With

End Sub

Vous pouvez imbriquer des instructions With pour en améliorer l'efficacité. L'exemple suivant insère une formule dans la cellule A1, puis formate la police.

Sub MyInput()

With Workbooks("Book1").Worksheets("Sheet1").Cells(1, 1)

.Formula = "=SQRT(50)"

With .Font

.Name = "Arial"

.Bold = True

.Size = 8

End With

End With

End Sub


Règles d'affectation de noms Visual Basic

Utilisez les règles suivantes pour nommer des procédures, des constantes, des variables et des arguments dans un module Visual Basic :

•	Utilisez une lettre comme premier caractère.

•	N'utilisez pas d'espace, de point (.), de point d'exclamation (!) ou les caractères @, &, $, # dans le nom.

•	Un nom ne peut compter plus de 255 caractères.

•	Généralement, vous ne devriez pas utiliser des noms identiques aux noms de fonction, d'instruction et de méthode de Visual Basic. Vous feriez double emploi des mots clés du langage. Pour utiliser une fonction, une instruction ou une méthode du langage intrinsèque en conflit avec un nom attribué, vous devez l'identifier explicitement. Faites précéder la fonction, l'instruction ou la méthode intrinsèque du nom de la bibliothèque de types associée. Par exemple, si vous avez une variable nommée Left, pour invoquer la fonction Left, vous devez employer VBA.Left.

•	Vous ne pouvez pas employer deux fois le même nom au même niveau de portée. Par exemple, vous ne pouvez pas déclarer deux variables nommées age dans la même procédure. Cependant, vous pouvez déclarer une variable privée nommée age et une variable de niveau procédure nommée age dans le même module.

Note   Visual Basic ne différencie pas les majuscules des minuscules, mais conserve la casse dans l'instruction de déclaration du nom.


Traitement inter-applications

Visual Basic peut créer de nouveaux objets et extraire des objets existants de nombreuses applications Microsoft. D'autres applications peuvent également fournir des objets que vous pouvez créer avec Visual Basic. Pour plus d'informations, reportez-vous à la documentation de l'application.

Pour créer un nouvel objet ou obtenir un objet existant d'une autre application, utilisez la fonction CreateObject ou la fonction GetObject :

' Lance Microsoft Excel et crée un nouvel objet Worksheet.

Set ExcelWorksheet = CreateObject("Excel.Sheet")

' Lance Microsoft Excel et ouvre un objet Worksheet existant.

Set ExcelWorksheet = GetObject("SHEET1.XLS")

' Lance Microsoft Word.

Set WordBasic = CreateObject("Word.Basic")

La plupart des applications comportent une méthode Exit ou Quit qui ferme l'application qu'elle soit visible ou non. Pour plus d'informations sur les objets, les méthodes et les propriétés offerts par une application, consultez la documentation de cette dernière.

Certaines applications permettent d'utiliser le mot clé New pour créer un objet d'une classe existant dans sa bibliothèque de types. Par exemple :

Dim X As New Field

Dans ce cas, Field est un exemple d'une classe de la bibliothèque de types d'accès aux données. Une nouvelle instance d'un objet Field est créée avec cette syntaxe. Pour plus d'informations sur les classes d'objets pouvant être créées de cette manière, consultez la documentation de l'application.


Écriture d'une procédure Function

Une procédure Function est une série d'instructions Visual Basic délimitée par les instructions Function et End Function. Une procédure Function est similaire à une procédure Sub, mais une fonction peut également renvoyer une valeur. Une procédure Function peut prendre des arguments, tels que les constantes, les variables ou les expressions qui lui sont passées par une procédure appelante. Si une procédure Function n'a aucun argument, son instruction Function doit comporter des parenthèses vides. Une fonction renvoie une valeur en affectant une valeur à son nom dans une ou plusieurs instructions de la procédure.

Dans l'exemple suivant, la fonction Celsius convertit des degrés Fahrenheit en degrés Celsius. Lorsque la fonction est appelée depuis la procédure Main, une variable contenant la valeur de l'argument est passée à la fonction. Le résultat du calcul est renvoyé à la procédure appelante et affiché dans un message.

Sub Main()

temp = Application.InputBox(Prompt:= _

"Veuillez entrer la température en degrés F.", Type:=1)

MsgBox "La température équivaut à " & Celsius(temp) & " degrés C."

End Sub

Function Celsius(fDegrees)

Celsius = (fDegrees - 32) * 5 / 9

End Function


Écriture d'une procédure Property

Une procédure Property est une série d'instructions Visual Basic permettant à un programmeur de créer et de manipuler des propriétés personnalisées.

•	Les procédures Property peuvent être utilisées pour créer des propriétés en lecture seule pour des feuilles, des modules standard et des modules de classe.

•	Les procédures Property doivent être utilisées à la place des variables Public dans un code devant être exécuté lors de la définition de la valeur de la propriété.

•	Contrairement aux variables Public, des chaînes d'aide peuvent être affectées aux procédures Property dans l'Explorateur d'objets.

Lorsque vous créez une procédure Property, elle devient une propriété du module contenant la procédure. Visual Basic offre les trois types de procédure Property suivantes :

Procédure	Description
Property Let	Procédure définissant la valeur d'une propriété.
Property Get	Procédure renvoyant la valeur d'une propriété.
Property Set	Procédure définissant une référence à un objet.
Syntaxe de déclaration d'une procédure Property :

[Public | Private] [Static] Property {Get | Let | Set} propertyname_ [(arguments)] [As type]

statements

End Property

Les procédures Property sont généralement employées par paires : Property Let avec Property Get et Property Set avec Property Get. La déclaration d'une procédure Property Get seule équivaut à la déclaration d'une propriété en lecture seule. L'utilisation simultanée des trois types de procédure Property n'est adaptée qu'aux variables de type Variant, puisque ce type de variable peut contenir un objet ou tout autre type de données. Property Set est destinée aux objets, Property Let ne l'est pas.

Les arguments requis dans les déclarations des procédures Property sont présentés dans le tableau suivant :

Procédure	Syntaxe de déclaration
Property Get	Property Get propname(1, …, n) As type
Property Let	Property Let propname(1, …,,,, n, n+1)
Property Set	Property Set propname(1, …, n, n+1)
Du premier à l'avant-dernier (1, …, n), les arguments doivent tous partager les mêmes noms et les mêmes types de données dans toutes les procédures Property portant le même nom.

Une déclaration de procédure Property Get prend un argument de moins que les déclarations Property Let et Property Set associées. Le type de données de la procédure Property Get doit correspondre à celui du dernier argument (n+1) des déclarations Property Let et Property Set associées. Par exemple, si vous déclarez la procédure Property Let suivante, la déclaration Property Get doit utiliser des arguments portant le même nom et ayant le même type de données que les arguments de la procédure Property Let.

Property Let Names(intX As Integer, intY As Integer, varZ As Variant)

‘ Instruction ici.

End Property

Property Get Names(intX As Integer, intY As Integer) As Variant

‘ Instruction ici.

End Property

Le type de données de l'argument final d'une déclaration Property Set doit être soit un type Object, soit un type Variant.


Écriture d'une procédure Sub

Une procédure Sub est une série d'instructions Visual Basic délimitée par les instructions Sub et End Sub exécutant des actions mais ne renvoyant pas de valeurs. Une procédure Sub prend des arguments tels que des constantes, des variables ou des expressions passées par une procédure appelante. Si une procédure Sub n'a pas d'argument, l'instruction Sub doit comporter une paire de parenthèses vide.

La procédure Sub suivante comporte des commentaires expliquant chaque ligne.

' Déclare une procédure nommée GetInfo

' Cette procédure Sub ne prend aucun argument

Sub GetInfo()

' Déclare une variable de chaîne nommée answer

Dim answer As String

' Affecte la valeur renvoyée de la fonction InputBox à answer

answer = InputBox(Prompt:="Quel est votre nom?")

' Instruction conditionnelle If...Then...Else

If answer = Empty Then

' Appelle la fonction MsgBox

MsgBox Prompt:="Vous n'avez pas entré de nom."

Else

' Fonction MsgBox concaténée avec la variable answer

MsgBox Prompt:="Votre nom est " & answer

' Ends the If...Then...Else statement

End If

' Termine la procédure Sub

End Sub


Écriture d'instructions d'affectation

Les instructions d'affectation attribuent une valeur ou une expression à une variable ou une constante. Les instructions d'affectation comportent toujours un signe égal (=). L'exemple suivant attribue la valeur renvoyée de la fonction InputBox à la variable yourName.

Sub Question()

Dim yourName As String

yourName = InputBox("Quel est votre nom?")

MsgBox "Votre nom est " & yourName

End Sub

L'instruction Let est facultative et généralement omise. Par exemple, l'instruction d'affectation précédente peut être écrite de la façon suivante :

Let yourName = InputBox("Quel est votre nom?").

L'instruction Set est utilisée pour affecter un objet à une variable ayant été déclarée comme objet. Le mot clé Set est obligatoire. Dans l'exemple suivant, l'instruction Set affecte une plage sur Sheet1 à la variable objet myCell:

Sub ApplyFormat()

Dim myCell As Range

Set myCell = Worksheets("Sheet1").Range("A1")

With myCell.Font

.Bold = True

.Italic = True

End With

End Sub

Les instructions qui définissent des valeurs de propriété sont également des instructions d'affectation. L'exemple suivant définit la propriété Bold de l'objet Font de la cellule active :

ActiveCell.Font.Bold = True


Écriture d'instructions de déclaration

Les instructions de déclaration permettent de nommer et de définir des procédures, des variables, des tableaux et des constantes. Lorsque vous déclarez une procédure, une variable ou une constante, vous définissez également sa portée, en fonction de l'endroit où vous placez la déclaration et des mots clés employés pour la déclarer.

L'exemple suivant contient trois déclarations.

Sub ApplyFormat()

Const limit As Integer = 33

Dim myCell As Range

' Autres instructions

End Sub

L'instruction Sub (avec l'instruction appariée End Sub) déclare une procédure nommée ApplyFormat. Toutes les instructions délimitées par les instructions Sub et End Sub sont exécutées lorsque la procédure ApplyFormat est appelée ou exécutée.

•	Écriture d'une procédure Sub

L'instruction Const déclare la constante limit, spécifiant le type de données Integer et une valeur 33.

•	Déclaration de constantes

L'instruction Dim déclare la variable myCell. Les données sont de type Object, un objet Range Microsoft Excel. Vous pouvez déclarer qu'une variable correspond à n'importe quel objet exposé dans l'application utilisée. Les instructions Dim constituent un type d'instruction de déclaration de variables. Les mots clés ReDim, Static, Public, Private et Const sont également utilisés dans les déclarations.

•	Déclaration de variables


Écriture d'instructions exécutables

Une instruction exécutable initialise une action. Elle peut exécuter une méthode ou une fonction, et peut effectuer une boucle ou des branchements dans des blocs de code. Les instructions exécutables contiennent souvent des opérateurs mathématiques ou conditionnels.

L'exemple suivant utilise une instruction For Each...Next pour effectuer une itération sur chaque cellule d'une plage nommée MyRange dans Sheet1 d'un classeur Microsoft Excel actif. La variable c est une cellule dans la collection de cellules contenues dans MyRange.

Sub ApplyFormat()

Const limit As Integer = 33

For Each c In Worksheets("Sheet1").Range("MyRange").Cells

If c.Value > limit Then

With c.Font

.Bold = True

.Italic = True

End With

End If

Next c

MsgBox "Terminé"

End Sub

L'instruction If...Then...Else dans l'exemple vérifie la valeur de la cellule. Si cette valeur est supérieure à 33, l'instruction With définit les propriétés Bold et Italic de l'objet Font de cette cellule. Les instructions If...Then...Else se terminent par End If.

L'instruction With peut vous épargner de la saisie puisque les instructions qu'elle contient sont automatiquement exécutées sur l'objet qui suit le mot With.

L'instruction Next appelle la cellule suivante de la collection de cellules contenue dans MyRange.

La fonction MsgBox (qui affiche une boîte de dialogue Visual Basic intégrée) affiche un message indiquant que la procédure Sub est terminée.


Écriture de données dans des fichiers

Lors du traitement de grandes quantités de données, il est souvent pratique d'écrire et de lire des données dans un fichier. L'instruction Open vous permet de créer des fichiers et d'y accéder directement. Open offre trois types d'accès aux fichiers :

•	L'accès séquentiel (modes Input, Output et Append) est utilisé pour écrire des fichiers texte, tels que des journaux d'erreurs et des états.

•	L'accès aléatoire (mode Random) est utilisé pour lire et écrire des données dans un fichier sans le fermer. Dans les fichiers en accès aléatoires, les données sont placées dans des enregistrements pour accélérer la localisation des informations.

•	L'accès binaire (mode Binary) permet de lire ou d'écrire dans n'importe quelle position d'octet d'un fichier, notamment pour stocker ou afficher une image bitmap.

Note   L'instruction Open ne doit pas être utilisée pour ouvrir les types de fichier spécifiques d'une application. Par exemple, n'utilisez pas Open pour ouvrir un document Word, une feuille de calcul Microsoft Excel ou une base de données Microsoft Access. Ce type d'ouverture pourrait compromettre l'intégrité du fichier et endommager ce dernier.

Le tableau suivant présente les instructions généralement employées lors de l'écriture et de la lecture de données dans les fichiers.

Type d'accès	Écriture de données	Lecture de données
Séquentiel	Print #, Write #	Input #
Aléatoire	Put	Get
Binaire	Put	Get


Écriture d'instructions Visual Basic

Les instructions Visual Basic sont complètes. Elles contiennent des mots clés, des opérateurs, des variables, des constantes et des expressions. Chaque instruction appartient à l'une des trois catégories suivantes :

•	Les instructions de déclaration, qui nomment une variable, une constante ou une procédure et peuvent également spécifier un type de données.

Écriture d'instructions de déclaration

•	Les instructions d'affectation qui attribuent une valeur ou une expression à une variable ou à une constante.

Écriture d'instructions d'affectation

•	Instructions exécutables qui initialisent des actions. Ces instructions peuvent exécuter une méthode ou une fonction, elles peuvent également effectuer une boucle ou des branchements dans des blocs de code. Les instructions exécutables contiennent souvent des opérateurs mathématiques ou conditionnels.

Écriture d'instructions exécutables

Continuité d'une instruction sur plusieurs lignes

Une instruction tient généralement sur une ligne, mais vous pouvez la continuer sur la ligne suivante à l'aide d'un caractère de continuité de ligne. Dans l'exemple suivant, l'instruction exécutable MsgBox se poursuit sur cinq lignes :

Sub DemoBox() 	'Cette procédure déclare  une variable de chaîne,

' lui attribue la valeur John, puis affiche

' un message concaténé.

Dim myVar As String

myVar = "John"

MsgBox Prompt:="Bonjour " & myVar, _

Title:="Zone d'accueil", _

Buttons:=vbExclamation

End Sub

Ajout de commentaires

Les commentaires peuvent expliquer une procédure ou une instruction particulière au lecteur de votre code. Visual Basic ne tient pas compte des commentaires lors de l'exécution de vos procédures. Les lignes de commentaire commencent par une apostrophe (') ou par le mot Rem suivi d'un espace, et peuvent être insérées n'importe où dans une procédure. Pour ajouter un commentaire sur la même ligne qu'une instruction, insérez une apostrophe après l'instruction, suivie du commentaire. Par défaut, les commentaires s'affichent en vert.

Vérification des erreurs de syntaxe

Si une ligne s'affiche en rouge (avec un éventuel message d'erreur) après sa saisie et la frappe de la touche ENTRÉE, l'instruction correspondante comporte une erreur. Identifiez celle-ci et corrigez-la.


Utilisation du Gestionnaire de compléments

Servez-vous de la boîte de dialogue Gestionnaire de compléments pour charger ou décharger un complément. Si vous fermez uniquement les portions visibles d'un complément (en cliquant deux fois sur la case du menu Système ou sur le bouton de fermeture, par exemple), sa feuille disparaît de l'écran mais le complément réside en mémoire. L'objet complément lui-même reste chargé en mémoire tant que vous ne déconnectez pas le complément au moyen de la boîte de dialogue Gestionnaire de compléments.