La déclaration de "Option Explicit" au début d'un module indique à Visual Basic que toutes les variables utilisées à l'intérieur de ce module devront être préalablement déclarées. Ainsi si vous vous trompez sur le nom d'une variable vous aurez une erreur à la compilation. Etre prévenu d'une erreur pendant la phase de compilation est un gros avantage : elle vous évite d'avoir à la retrouver par débuggage après avoir constaté un dysfonctionnement pendant l'exécution. De plus, déclarer vos variables vous permet de spécifier leur type, ce qui est préférable du point de vue des performances du programme.
Pour qu'"Option Explicit" soit ajouté automatiquement à la création d'un module, activez l'option "Déclaration des variables obligatoire" dans les options du projet (onglet "Editeur").

il s'agit, "caractères de déclaration de type" ajoutés à une valeur pour indiquer le type de donnée
qu'il faut lui attribuer. Il en existe quelques uns.
À l'origine, à l'époque du bon vieux code spaghetti, on déclarait une variable en y ajoutant ou non
le suffixe $ pour dire s'il s'agissait d'une valeur de chaîne ou d'une valeur numérique.
Au fil de l'évolution de Basic, il s'est ajouté d'autres types spécifiques avec leurs suffixes bien à eux.
Aujourd'hui, on les utilise encore dans quelques situations. En voici une liste:

• $ pour les valeurs de chaînes (variables seulement)
• % pour les entiers de type Integer
• & pour les entiers de type Long
• ! pour les réels de type Single
• # pour les réels de type Double
• @ pour les réels de type Currency

Les arguments d'une fonction ou d'une procédure peuvent être passés de deux façons différentes : par valeur ou par référence. Si un argument est précédé de Byval, il est passé par valeur, et s'il est précédé de ByRef, ou de ni l'un ni l'autre, il est passé par référence.

Passage par valeur (ByVal)
Consiste à passer la valeur de l'argument à la procédure, et non son adresse. La procédure utilise alors une copie de la variable. La valeur de la variable ne peut pas être modifiée par la procédure.

Passage par référence (ByRef)
Ici c'est l'adresse de la variable qui est passée à la procédure. La variable peut donc être modifiée par la procédure.

Private Sub Echange(ByVal a As Integer, ByVal b As Integer)
 
Dim temp As Integer
temp = a
a = b
b = temp
 
End Sub
 
Private Sub Echange2(a As Integer, b As Integer)
 
Dim temp As Integer
temp = a
a = b
b = temp
End Sub
 
Private Sub Test()
 
x = 5
y = 3
Echange x, y
MsgBox x & " " & y   'affiche "5 3", les valeurs n'ont pas été modifiées par la procédure
 
Echange2 x, y
MsgBox x & " " & y   'affiche "3 5", parce que les valeurs ont été modifiées
 
End Sub

Un ensemble de constantes liées par leur sens peut être définit par une énumération à l'aide du mot clé Enum. La déclaration de l'énumération est à placer dans le haut du module (partie déclaration)

Chaque ligne de l'énumération est déclarée ainsi : <Nom de la valeur> = <Valeur : Type entier>

Private Enum Couleurs
Bleu=1
Vert=3
Jaune=5
End Enum

Ainsi, si on déclare une variable de type Couleurs, on aura par exemple :

Dim MaCouleur as Couleurs
MaCouleur=Couleurs.Vert
Msgbox MaCouleur

Ceci affichera 3.

Le saut de ligne est représenté par la constante vbCrLf. Exemple pour afficher un message sur 2 lignes avec MsgBox :

 MsgBox "Opération terminée." & vbCrLf & "Cliquez sur OK."

En utilisant La propriété Path de l'objet App. Ajoutez le caractère "\" à la fin s'il n'y ait pas déjà.

Dim Path as String
 
Path = App.Path
If right(Path,1) <> "\" then Path = Path & "\"

L'exemple suivant affiche les éléments d'un tableau :

Private Sub AfficheElements(t() As Long)
 
Dim i As Long
For i = LBound(t) To UBound(t)
    MsgBox t(i)
Next
 
End Sub
 
Private Sub Form_Load()
 
Dim t(1 To 3) As Long
t(1) = 1
t(2) = 4
t(3) = 5
AfficheElements t()
 
End Sub

La fonction UBound() renvoie l'indice maximum autorisé pour un tableau donné. Si le tableau est vide, elle crée une erreur. La fonction suivante utilise ce principe. Elle renvoie vrai si le tableau passé en paramètre contient au moins un élément.

Public Function ContientElements(ByVal tableau As Variant) As Boolean
 
Dim indice As Long
 
On Error goto vide
indice = UBound(tableau)
ContientElements = True
Exit Function
 
vide:
 
End Function

La fonction suivante renvoie un booléen : Vrai si le nombre reçu en paramètre est pair, et faux sinon.

Private Function EstPaire(x As Long) As Boolean
    EstPaire = (x Mod 2 = 0)
End Function

Dans l'exemple ci-dessous, la fonction RGBparTableau() renvoie les composantes rouge, verte, bleue du code couleur passé en paramètre. Les composantes sont renvoyées sous la forme d'un tableau.

Public Function RGBparTableau(ByVal couleur As Long) As Long() 
 
Dim MonTab(0 To 2) As Long 
MonTab(2) = Int(couleur / 65536) 
MonTab(1) = Int((couleur - (65536 * MonTab(2))) / 256) 
MonTab(0) = couleur - ((MonTab(2) * 65536) + (MonTab(1) * 256)) 
RGBparTableau = MonTab 
 
End Function 
 
Private Sub Command1_Click() 
 
Dim TabCouleur() As Long, couleur As Long 
 
couleur = 9550940 
TabCouleur() = RGBparTableau(couleur) 
MsgBox "Le code " & couleur & " correspond en RGB à " & _ 
        TabCouleur(0) & " " & TabCouleur(1) & " " & TabCouleur(2) 
 
End Sub

Une fonction peut renvoyer une variable de type utilisateur comme n'importe quel autre type simple.
Cependant vous ne pouvez pas déclarer dans un module de classe, y compris dans le module d'une form, une fonction de portée publique renvoyant un type utilisateur. Dans un module standard, si vous déclarez un type utilisateur et une fonction de portée publique qui renvoie ce type, le type doit être aussi déclaré avec une portée publique.

Dans l'exemple ci-dessous, la fonction RGBparType() renvoie les composantes rouge, verte, bleue du code couleur passé en paramètre. Les composantes sont les champs du type CompCouleur.

Private Type CompCouleur
    Red As Long
    Green As Long
    Blue As Long
End Type
 
Private Function RGBparType(ByVal Couleur As Long) As CompCouleur
 
RGBparType.Blue = Int(Couleur / 65536)
RGBparType.Green = Int((Couleur - (65536 * RGBparType.Blue)) / 256)
RGBparType.Red = Couleur - ((RGBparType.Blue * 65536) + (RGBparType.Green * 256))
 
End Function
 
Private Sub Command1_Click()
 
Dim TypColor As CompCouleur
 
TypColor = RGBparType(9550940)
lblred.Caption = "Red = " & TypColor.Red
lblgreen.Caption = "Green = " & TypColor.Green
lblblue.Caption = "Blue = " & TypColor.Blue
 
End Sub

Instr(p,ch1,ch2) recherche la chaîne ch2 dans ch1 à partir de la position p. Si ch2 est trouvée, la valeur renvoyée est la position de son premier caractère dans ch1, sinon la fonction renvoie 0.

pos = InStr(4, "Nous sommes au mois de Juillet.", "Juillet")    'renvoie 24
pos = InStr(27, "Nous sommes au mois de Juillet.", "Juillet")   'renvoie 0

La fonction VBA StrConv permet de convertir des chaînes de caractères.

StrConv(String,Conversion)

Le premier paramètre correspond à la chaîne de caractères à convertir, le deuxième est le masque de conversion.
Utilisez la constante VbLowerCase pour convertir en minuscules, VbUpperCase pour convertir en majuscules,
VbProperCase pour convertir en noms propres : la première lettre de chaque mot est alors en majuscule, le reste en minuscules.

MsgBox StrConv("Ceci est un essai", vbProperCase)

Affiche : Ceci Est Un Essai

La ligne de commande et ses arguments vous est renvoyée par la fonction Command() sous la forme d'une chaîne de caractères. Pour transformer cette chaîne en un tableau dont chaque élément correspond à un argument, utilisez la fonction Split() :

Dim args() As String
args = Split(Command(), " ")

La fonction Rnd() renvoie une valeur aléatoire supérieure ou égale à 0 et strictement inférieure à 1.

Public Function NombreAleatoire(ByVal lngInf As Long,ByVal lngSup As Long) As Long
 
'Renvoie une valeur comprise entre les limites lngInf et lngSup
 
Randomize 'initialise le générateur pseudo-aléatoire
NombreAleatoire = Int(Rnd() * (lngSup - lngInf + 1)) + lngInf
 
End Function

Contrairement à d'autres langages, la constante Pi n'existe pas en VB. La meilleure façon de l'obtenir rapidement est d'utiliser le code suivant :

Dim Pi as Double
Pi=4*Atn(1)

Dans Visual Basic, le type Long représente un nombre entier, codé sur 4 octets, dont la valeur est comprise entre -2 147 483 648 et 2 147 483 647.
Il est possible de manipuler des nombres dépassant ces limites, en utilisant le type Decimal
Ce type de donnée peut stocker des nombres dans la plage de valeurs : +/-79 228 162 514 264 337 593 543 950 335
Le type Decimal est un sous-type de Variant. Il n'est donc pas possible de l'attribuer directement à une variable.
Pour contourner le problème, il faut créer une variable de type Variant et utiliser la fonction CDec, afin de créer un sous-type Decimal

Dim d As Variant
    d = CDec("79 228 162 514 264 337 593 543 950 000")
    MsgBox d + 335 'Maxi possible !

Toutes les opérations arithmétiques s'effectuent normalement, sous réserve, bien sûr, comme pour tous les types de variables, de ne pas dépasser les valeurs limites.

La compilation conditionnelle vous permet de compiler et donc d'inclure dans l'exécutable un bloc de code source uniquement si une condition est vérifiée.

Syntaxe :

#If expression Then
    statements
[#ElseIf expression-n Then
    [elseifstatements]]
[#Else
    [elsestatements]]
#End If

expression est ici une ou plusieurs comparaisons entre une constante de compilation conditionnelle et une valeur.

Initialiser une constante de compilation conditionnelle peut se faire de plusieurs manières. Vous pouvez utiliser la directive #Const :

#Const nomconstante = expression

En utilisant cette directive, la constante déclarée est accessible uniquement à l'intérieur du module où elle est déclarée. Vous pouvez aussi indiquer la valeur d'une constante dans le deuxième onglet de la fenêtre des propriétés du projet. Avec cette méthode, la constante sera accessible dans tous les modules du projet. Et pour donner la valeur True à une valeur booléenne, il faut spécifier la valeur ?1.

Voici quelques cas où la compilation conditionnelle peut être intéressante :

• enregistrer dans un fichier log tout ce qui se passe pendant l'exécution du programme, mais uniquement avec une version compilée spécialement pour le débogage ou bien tout au long de la phase de développement.
• compiler un code source différent suivant la version de Windows visée.
• compiler certains codes sources selon les fonctionnalités à inclure dans la version de l'application qui est compilée. La compilation conditionnelle permet ici de n'inclure dans l'exécutable que le code source nécessaire; un pirate ne pourra donc pas bidouiller l'exécutable afin d'activer les autres fonctionnalités.

Voici un petit exemple où l'on active les menus que si les fonctions correspondantes sont incluses dans la version compilée :

#Const module_stats = True
#Const module_export = True
 
Private Sub Form_Load()
 
#If module_stats Then
    menuStats.Enabled = True
#End If
 
#If module_export Then
    menuExport.Enabled = True
#End If
 
End Sub

Avec la fonction CallByName.

Private Sub Form_Load()
 
'Ici CallByName renvoie la valeur de la propriété Caption de la form
Msgbox CallByName(Me, "Caption", VbGet)
 
'modifie la propriété Caption de la form
CallByName Me, "Caption", VbLet, "Test de callbyname"
 
End Sub

Avec la fonction CallByName.

Private Sub Form_Load()
 
    'Déplace la form à la position 5000,150
    CallByName Me, "Move", VbMethod, "5000,150"
 
End Sub

La librairie Microsoft VBScript Regular Expressions permet d'utiliser des expressions régulières dans Visual Basic. Il faut l'ajouter dans les références du projet.

Le principe consiste à créer un objet RegExp, à le paramétrer en modifiant ses propriétés, puis à lancer la recherche en appelant la méthode Execute(). Vous devez passer en paramètre la chaîne de caractères dans laquelle vous souhaitez faire une recherche. La méthode Execute vous renvoie les occurrences dans une collection. Si vous avez donné la valeur True à la propriété Global de l'objet RegExp, cette collection contiendra toutes les occurrences, sinon seulement la première.

Voici comment vérifier la validité d'une adresse email. Ce code a été écrit avec la version 5.5 de la librairie.

Public Function EmailValide(ByVal email As String) As Boolean
 
    Dim regEx As RegExp, occurrences As MatchCollection
 
    Set regEx = New RegExp
    regEx.Pattern = "^[a-z0-9_.-]+@[a-z0-9.-]{2,}\.[a-z]{2,3}$"
    regEx.IgnoreCase = True 'Ne pas distinguer les minuscules des majuscules
    regEx.Global = False 'Renvoyer seulement la première occurrence
    Set occurrences = regEx.Execute(email)
    EmailValide = (occurrences.Count = 1)
 
End Function

Si vous travaillez uniquement en VBScript :

Dim toto As String 
 
toto = "SUPER * 10" 
MsgBox Eval(Replace(toto, "SUPER", 500))

Si vous travaillez en VB6, il faut cocher le composant Microsoft Script Control dans Projet -> Composants et placer ce code :

Dim r As New ScriptControl 
 
  Dim toto As String 
 
  toto = "SUPER * 10" 
 
  toto = Replace(toto, "SUPER", 500) 
 
  r.Language = "vbscript" 
  Debug.Print r.Eval(toto)

Un petit exemple avec un RichTextBox :

Private Const EM_UNDO = &HC7 
Private Const EM_CANUNDO = &HC6 
Private Const WM_USER As Long = &H400 
Private Const EM_REDO As Long = (WM_USER + 84) 
Private Const EM_CANREDO As Long = (WM_USER + 85) 
Private Const WM_COPY = &H301 
Private Const WM_CUT = &H300 
Private Const WM_CLEAR = &H303 
Private Const WM_PASTE = &H302 
Private Declare Function SendMessage Lib "user32" Alias "SendMessageA" (ByVal _ 
        hWnd As Long, ByVal wMsg As Long, ByVal wParam As Long, lParam As Any) As Long 
 
Private Sub mnuEditSubRedo_Click() 
    SendMessage txtTerm.hWnd, EM_REDO, 0, ByVal 0& 
End Sub 
 
Private Sub mnuEditSubUndo_Click() 
    SendMessage txtTerm.hWnd, EM_UNDO, 0, ByVal 0& 
End Sub 
 
Private Sub mnuEditSubCopy_Click() 
    Clipboard.Clear 
    SendMessage txtTerm.hWnd, WM_COPY, 0, 0 
End Sub 
 
Private Sub mnuEditSubCut_Click() 
    Clipboard.Clear 
    SendMessage txtTerm.hWnd, WM_CUT, 0, 0 
End Sub 
 
Private Sub mnuEditSubPaste_Click() 
    SendMessage txtTerm.hWnd, WM_PASTE, 0, 0 
End Sub 
 
Private Sub RichText1_Change() 
    mnuEditSubUndo.Enabled = SendMessage(txtTerm.hWnd, EM_CANUNDO, 0, ByVal 0&)      
    mnuEditSubRedo.Enabled = SendMessage(txtTerm.hWnd, EM_CANREDO, 0, ByVal 0&) 
End Sub

Pour qu'une fonction, procédure, ou variable soit accessible à partir d'un autre module que celui où elle est déclarée, sa déclaration doit débuter par le mot clé Public. Voici les déclarations d'une variable de type long et d'une procédure publiques dans la form nommée Form1 :

Public Variable As Long
 
Public Sub Afficher()
    'code
End Sub

Et voici comment les appeler depuis un autre module :

Form1.Variable = 3
Form1.Afficher

Le Me désigne en fait l'instance du formulaire sur lequel on se trouve.
Ainsi la ligne suivante fait référence à une zone de texte se trouvant dans le formulaire actuel :

Me.txtNom = "Dupond"

Deux syntaxes sont possibles :

Dim obj as new clToto
obj.mamethode

Ou

Dim obj as clToto
Set obj= New clToto
obj.mamethode

Pourtant, il existe une différence fondamentale entre les deux syntaxes. En Visual Basic, dès qu'une méthode est appelée, une vérification interne est réalisée. Celle-ci consiste à vérifier que l'objet n'est pas vide avant l'appel. Le mot clé SET permet d'outrepasser cette vérification et de dire explicitement au système que l'objet a été instancié. Ainsi, on gagne de nombreuses opérations qui auraient dues être effectuées à chaque fois que l'objet aurait été référencé. La syntaxe 2 consomme donc une ligne de code de plus mais est beaucoup plus performante.

Pour tester si deux variables correspondent au même objet, il faut utiliser l'opérateur IS :

Dim a As Object
Dim b As Object
Set a = CurrentDb
Set b = a
If b Is a Then
 MsgBox "Le même objet"
Else
 MsgBox "Objet différent"
End If
Set b = CurrentProject
 
If b Is a Then
 MsgBox "Le même objet"
Else
 MsgBox "Objet différent"
End If

Ceci affiche respectivement :

1. Le même objet
2. Objet différent

Un paramètre est optionnel s'il est précédé du mot clé Optional. Les paramètres placés après doivent être également optionnels. Vous pouvez également spécifier une valeur par défaut :

Private Sub Affiche(Optional x As Long=10)
 
End Sub

Pour les paramètres de type Variant et sans valeur par défaut, vous avez le moyen de savoir si une valeur a été spécifiée lors de l'appel en utilisant IsMissing :

Private Sub Affiche(Optional x As Variant)
 
If IsMissing(x) Then
    'pas de valeur spécifiée
Else
    'une valeur a été spécifiée pour x
End If
 
End Sub

Dans la déclaration de votre fonction déclarez l'argument facultatif de cette façon :

 ...Optional ByVal strArg1 as String="<empty>"...

Puis dans votre fonction regardez la valeur de strArg1 :

Dim flagNonRenseigné As Boolean
flagNonRenseigné = False
 
If strArg1 = "<empty>" Then
 flagNonRenseigné = True
 strArg1 = ""
End If