La fonction Replace() de VBA est largement employée par les développeurs. Mais lorsqu’ils souhaitent faire une recherche moins statique, ils regardent avec envie l’opérateur Like sans pouvoir faire un mix des 2.

Etant confronté à des traitements de chaines de caractères, je me suis créé une petite fonction dérivée du Replace, avec une touche de VBScript.RegEx.

Voici ce que cela donne :

Function ReplaceReg(ByVal expression As String, ByVal findPattern As String, ByVal replace As String, _
                    Optional ByVal caseSensitive As Boolean = False) As String
'---------------------------------------------------------------------------------------
' Procedure : ReplaceReg
' Author    : Fabrice CONSTANS (C²ED - c2ed.software@gmail.com)
' Date      : 24/09/2024
' Purpose   : Un Replace() VBA avec du RegEx
' Parameters: expression à analyser, findPattern pattern regex, replace ce qui doit être
'             mis à la place du pattern, caseSensitive tenir compte de la casse. 
' Copyright : © L'intégralité du code ci-dessous est la propriété de son auteur (Author)
'             Son utilisation est strictement limitée au présent logiciel.
' Pattern regex : https://documentation.help/MS-VBScript-fr/vsproPattern.htm
' Exemple de patterns :
'LIKE      RegEx
'chaton*   ^chaton.
'chat*n    chat.n
'chat[A,E] chat[AE]
'chat=,    chat=.,
'chat      chat$
'---------------------------------------------------------------------------------------

    On Error GoTo Errsub
    Dim regEx As Object
    Set regEx = CreateObject(VBScript.RegExp)
    
    With regEx
        .pattern = pattern
        .Global = True
        .IgnoreCase = Not caseSensitive
    End With
    
    ReplaceReg = regEx.replace(expression, replace)
    Exit Function

Errsub
    ReplaceReg = inputText ' retourne le texte original en cas d’erreur
    
End Function

Le contrat d’utilisation

• expression : texte à modifier.
• findPattern : pattern RegEx conforme au standard VBScript.Regex
• replace : texte de remplacement
• caseSensitive indique si la casse doit être prise en compte.

Les patterns

Les expressions régulières RegEx sont bien plus puissant que le l’opérateur Like, mais plus complexe à maitriser.
En revanche, l’opérateur Like est disponible à la fois SQL et en VBA, où il fonctionne de la même manière.

Remplacement global

Comme le Replace dans son utilisation le plus basique, notre fonction remplace toutes les occurrences rencontrées. C’est la propriété Globle=True qui garantie se comportement. Si on utilise False, seule la première occurrence sera traitée.

Perfectible ? Toujours !

La fonction est perfectible : on pourrait y ajouter des options comme start ou count pour limiter les remplacements. Mais dans la majorité des cas, elle fait le job.

• start qui exclue les X premiers caractère de l’expression
• count qui opère X remplacement

Je n’utilise jamais le Start, par contre le Count peut s’avérer utile dans certains cas.

Exemple d’utilisation

? replaceReg("ODBC;DRIVER={MySQL ODBC 8.0 UNICODE Driver};SERVER=192.168.10.1;DATABASE=baseLocale;Option=43;charset=UTF8;",";SERVER=.*?;",";SERVER=azure.microsoft.com;")
ODBC;DRIVER={MySQL ODBC 8.0 UNICODE Driver};SERVER=azure.microsoft.com;DATABASE=baseLocale;Option=43;charset=UTF8;

On a remplacé n’importe quelle adresse du server par ;SERVER=azure.microsoft.com;

Conclusion

Si vous traitez des chaînes complexes en VBA, pensez RegEx. Et si vous aimez cette fonction, n’hésitez pas à l’utiliser — en conservant l’en-tête bien sûr.

Split() est une fonction pratique et largement utilisée. A partir d’une chaine de texte elle renvoie un objet Tableau (Array) composé de ses éléments en utilisant le séparateur désigné.

Par exemple :

Dim monTexte as String
Dim monTableau as Variant
montexte = "Bonjour je suis Sam"

monTableau = Split(montexte, " ")

Dans l’exemple ci-dessus le tableau monTableau contiendra :
montableau(0) >> « Bonjour »
montableau(1) >> « je »
montableau(2) >> « suis »
montableau(3) >> « Sam »

On peut donc utiliser un boucle (Do, While, For) pour parcourir le tableau, comme on peut utiliser l’indice comme c’est fait dans la liste précédente. Ci-dessous un exemple avec une boucle For.

Dim i As Long
Dim vArray As Variant
vArray = Split("Bonjour je suis Sam", " ")
For i = 0 To UBound(vArray)
    Debug.Print vArray(i)
Next

Split renvoie un objet tableau, Split() est un tableau

Si Split est un tableau on peut l’utiliser en tant que tel sans l’affecter à une variable.
Dans l’exemple suivant on récupère directement l’item du tableau.

Dim monPrenom as String
monPrenom = Split(montexte, " ")(3)

La variable monPrenom vaudra :
monPrenom >> « Sam »

Le paramètre (3) accolé directement à la fonction Split() peut vous paraitre étrange à première vue pourtant ce n’est ni plus ni moins que l’indice du tableau.

Conclusion

Lorsqu’on veut récupérer une valeur et que l’on connait avec certitude sa position, utiliser cette syntaxe est plus rapide, cependant lorsqu’on veut utiliser plus d’une valeur, l’utilisation classique est plus performante.

Lorsque vous développez en VBA, êtes-vous plutôt Bang (!) ou plutôt Dot (.) ou mélangez-vous allégrement les deux formes de syntaxe Dang/Bot ?

Pour savoir où vous vous situez, voici un exemple de chaque syntaxe.

'Bang
Forms!monformulaire!maliste

'Dot
Forms.monformulaire.maliste

'Dang ou Bot :)
Forms.monformulaire!macolonne

Le Bang

C’est la syntaxe originelle de VBA quand il apparut pour la première fois sur Ms Access 1.1. On retrouve de nombreux exemples sur Internet et dans des applications anciennes ou développez à grand coup de copier/coller issu du net, et sans surprise dans le code remonté par les IA.

Le Bang a une signification particulière depuis l’apparition du Dot. Prenons par exemple l’objet Recordset de la bibliothèque DAO (Microsoft Office xx.0 Object Library) dans l’Explorateur d’Objets (F2) de VBE.

On voit dans l’Explorateur d’Objets qu’un élément de la classe bénéficie d’une icône particulière et qu’en le sélectionnant il apparait comme Membre par défaut. Le Bang désigne cet objet (ou propriété) implicitement sans pour autant qu’on spécifie sa nature.

Partant du modèle indiquant que Fields est le membre par défaut de Recordset et que Value est le membre par défaut de Field on crée l’exemple de manipulation Bang/Dot suivant :

Sub test()
Dim rs As DAO.Recordset
Set rs = CurrentDb.OpenRecordset("select * FROM matable", dbOpenSnapshot)

'renvoi le nom de la colonne Nom
Debug.Print rs!nom.Name  'bang/dot
Debug.Print rs.Fields("nom").Name  'équivalent dot

'renvoi la valeur de la colonne Nom
Debug.Print rs!nom    'bang ou Value est le membre par défaut de Field
Debug.Print rs.Fields("nom")  'dot avec bang implicite
Debug.Print rs.Fields("nom").value  'dot explicite

'provoque une erreur
Debug.Print rs!nom!Name     'bang non maitrisé
Debug.Print rs.Fields("nom")!Name  'dot/bang non maitrisé

rs.Close
Set rs = Nothing

End Sub

Alors pourquoi le Dot ? Quels avantages ?

L’utilisation de Dot, même si elle est plus verbeuse, permet l’affichage de l’autocomplétion à la touche du point (Dot) appuyée.

L’autocomplétion pour ceux qui ne sont pas habitués à l’utilisation des EDI (Environnement de Développement Intégré) sont des listes très utiles qui recenses les propriétés, méthodes et objets des classes invoquées.

Outre sont coté pratique d’aide à la saisie, il y a, pour les plus curieux, un tremplin de découverte et d’exploration de classe.

Le côté verbeux de Dot ne doit pas rebuter le développeur car à première lecture du code et sans forcément connaitre la classe utilisée, il n’y a pas de doute sur ce que le concepteur fait.

Conclusion

Si la forme Dot peut remplacer la forme Bang, il faut être vigilant lors de l’utilisation du Bang et le mélange des deux doit être effectué dans la plus grande connaissance de la classe.

Etes-vous Dot, Bang ou Dang/Bot ?
Si vous voyez du Bang, éprouvez-vous le besoin de le transformer en Dot ?
Donnez moi votre point de vue sur le sujet.

Cette fonction détermine si la valeur (value) passée appartient à la liste (listvalue).

Public Function isIn(value As Variant, listValue As String, _
                     Optional sep As String = ";") As Boolean
'------------------------------------------------------------------------------------
' Procedure : isIn
' Author    : Fabrice CONSTANS (MVP)
' Date      : 10/08/2023
' Purpose   : renvoi VRAI si value transmise fait partie de la liste listValue
' Parameters: listValue est une liste d'éléments séparés par sep
'             value peut être un élément de la liste listValue
' Return    : Boolean
' Copyright : © L'intégralité du code ci-dessous est la propriété de son auteur (Author)
'             
'------------------------------------------------------------------------------------

    Dim tbl As Variant
    Dim i As Long
    If isNullOuVide(value) Then Exit Function

    tbl = Split(listValue, sep)
    For i = 0 To UBound(tbl)
        If tbl(i) = CStr(value) Then
            isIn = True
            Exit Function
        End If
    Next
End Function

2 paramètres obligatoires :

• value pour la valeur à chercher
• listvalue pour la liste des valeurs à explorer

1 paramètre facultatif :

• sep pour le séparateur de la liste à explorer.

On l’utilise de cette manière avec le séparateur par défaut.

If isIn(1,"2;5;8;6") Then
   Msgbox "1 fait bien parti de la liste
Else
   Msgbox "1 ne fait pas parti de la liste"
Endif

Ou encore en précisant le séparateur.

mavar = 1
maliste = "1|2|3|8|94|100|15|50"

If isIn(mavar, maliste, "|") then
   Msgbox "1 fait bien parti de la liste
Else
   Msgbox "1 ne fait pas parti de la liste"
Endif  

Cette fonction peut être modifiée pour traiter le Null. J’ai également créé des variantes avec des Array et ParamArray pour le paramètre listvalue.

Vous utilisez une autre méthode ?
Vous souhaitez échanger sur ce sujet ?
N’hésitez pas à laisser un commentaire.

Dans cette série de billets nous allons délivrer des conseils, détailler des techniques et mettre en pratique le débogage au travers d’exemples simples.

Introduction

Le débogage est l’action de suivre le déroulement du code pour en observer le comportement et corriger des problèmes ou bugs. Tout développement passe par cette phase dont la durée varie suivant la maîtrise du langage. La facilité de débogage est proportionnelle à la simplicité du code. Faites un code simple, efficace et vous aurez d’autant plus de facilité à le déboguer.

Qu’est-ce que VBE ?

VBE est l’acronyme de Visual Basic Editor, soit l’éditeur Visual Basic Application commun à tous les produits de la suite Office et autre produit intégrant le langage de programmation VBA. C’est avec lui que nous allons travailler tout au long de ces billets.

On y accède au choix après l’ouverture d’un fichier Access :

• Avec la combinaison de touches Alt + F11,
• En ouvrant un nouveau module ou un existant,
• En ouvrant ou créant un événement du type [Procédure Evènementielle] d’un formulaire/état.
• Pour les versions récentes via le ruban Créer/ Autre /Menu Macro/ Module ou Module de classe.

Cet éditeur comporte un menu, des barres d’outils ainsi que plusieurs fenêtres.

Nous allons aborder tour à tour chacune d’elles au fur et à mesure de notre besoin.

Premiers réglages : Réduire les risques d’erreurs

Le débogage commence avant l’écriture de la moindre ligne de code. En effet, au-delà de la bonne connaissance du produit il existe quelques précautions à prendre pour limiter le risque d’erreurs de codage. Il faut en premier lieu utiliser les meilleurs réglages de l’éditeur VB (Visual Basic Editeur, VBE).

Les réglages de VBE

Avant de commencer l’écriture de la moindre ligne de code vous devez vous assurer des réglages des options de l’éditeur VB.

Vérification automatique de syntaxe

Cette option est intéressante lorsque vous débutez car elle vous signale les erreurs lors du changement de ligne et vous propose un accès à la rubrique d’aide la plus adéquate pour résoudre le problème.
Dans le cas d’une erreur sur la ligne, la ligne apparait en rouge. Si la vérification automatique de syntaxe est active, le mot clef posant problème est signalé et un message d’erreur s’affiche.

Avec la vérification automatique de syntaxe :

Lorsque le curseur n’est plus sur la ligne comportant l’erreur.

Sans la vérification :

Activée ou non la ligne apparaitra en rouge si elle comporte une erreur, la différence est uniquement sur l’affichage ou non du message.

Lorsque vous faites de la concaténation de texte, comme des requêtes SQL dans le code (les plus intégristes me traiteront d’hérétique), ou de la copie de code cette option peut vite devenir agaçante. Personnellement je désactive cette option.

Déclaration des variables obligatoires

Vivement conseillée en toute circonstance, cette option permet d’ajouter sur tous les nouveaux modules, l’instruction Option Explicit en en-tête. Cela oblige le développeur à déclarer chaque variable avant son utilisation. Vous réduisez ainsi les erreurs liées aux mauvais noms de variables souvent causées par des fautes de frappe.
Très fréquente, cette erreur conduit à un code qui ne plante pas mais qui ne fait pas ce qu’on lui demande. C’est souvent le plus difficile à déboguer.
Si vous avez déjà commencé à coder lorsque vous lisez ces lignes, il n’est pas trop tard pour ajouter cette option dans tous vos modules y compris ceux des formulaires et des états, cependant vous devrez le faire manuellement.
Cette instruction vient immédiatement après Option Compare.

Option Compare Database 
Option Explicit

Notez qu’en l’absence de déclaration, une variable est de type Variant comme une variable déclaré sans type. Le type Variant est  très gourmand en mémoire.

Complément automatique des instructions

Cette option ajoute un confort et une rapidité en mettant à disposition la complétion de code. La complétion, souvent désignée sous le terme d’auto-complétion ou intellisense, se comporte de différentes manières.

1er cas d’utilisation

Lorsque vous saisissez un début d’instruction et que vous appuyez simultanément sur CTRL+Espace  plusieurs cas de figure peuvent se produire.
INFORMATION : Les cas sont ceux rencontrés avec les références standards.

Une seule correspondance

Il n’existe qu’une instruction possible, votre saisie est automatique complétée.
Entrez Doc et CTRL+Espace, le mot clé DoCmd s’affiche.

Plusieurs correspondances possibles

Il existe plusieurs instructions qui répondent à cette saisie. Une liste déroulante s’affiche, l’instruction choisie est celle qui correspond à la saisie.
Entrez Do et CTRL+Espace et la liste s’affiche.

Utilisez les touches de déplacement et la tabulation pour valider ou la souri ou encore compléter le mot clef.
Pour annuler utilisez la touche Echap.

2ème cas d’utilisation

Lorsque vous utilisez le nom d’un objet ou d’une classe et que vous saisissez le point, la même liste déroulante s’ouvre avec les choix possibles pour cet objet.

3ème cas d’utilisation

Dans certains cas, comme la déclaration de variables typées, la complétion entre en action après avoir entré le mot clé AS.

On rencontre aussi ce fonctionnement lorsque l’instruction saisie nécessite un paramètre Enum, La méthode OpenRecordset de DAO en est un parfait exemple. Voir le billet sur les déclarations Enum ici.

Conclusion
Avec la complétion vous n’aurez plus d’excuses pour avoir inventé des noms de méthodes ou propriétés farfelues. Si vous êtes un peu curieux vous pourrez explorer les composants d’un objet, en action avec l’aide vous découvrirez ainsi de nouvelles méthodes et propriétés.

La complétion fonctionne également avec vos bibliothèques de fonctions, procédures et classes ainsi qu’avec les contrôles, propriétés et méthodes des formulaires et états.
La complétion ne fonctionne pas dans les cas suivants :
• Quand il y a une erreur identifiée (ligne en rouge) non corrigée.
• L’objet que vous utilisez n’existe pas (bibliothèque non référencée, nom farfelu…)
• L’objet n’est pas typé précisément (Late Binding) c’est le cas pour Variant et Object par exemple.

Notez que dans ce dernier cas vous pouvez utilisez la méthode « Early Binding » durant la conception, puis le transformer en « Late Binding » par la suite. Cette technique est décrite dans le billet traitant du Binding.

La complétion est donc essentielle pour éviter les fautes de frappe et l’utilisation de propriétés ou méthodes inexistantes mais également dans le perfectionnement de votre apprentissage d’une bibliothèque.

Bon utilisation !