Extraire les mails des chaînes de textes en VBA Access

Pour partager cette vidéo sur les réseaux sociaux ou sur un site, voici son url :


Sujets que vous pourriez aussi aimer :


Isoler les mails des textes

Pour automatiser des traitements, il est intéressant de savoir extraire les adresses électroniques noyées dans des chaînes de textes, afin de les isoler dans un champ précis pour chaque enregistrement parcouru. De cette façon, un programme peut ensuite facilement robotiser l'envoi de courriers à destination de ces potentiels clients démasqués. C'est la solution que propose d'aboutir cette nouvelle astuce VBA Access.

Base de données Access à télécharger
Nous allons le voir, ce sont les expressions régulières qui vont nous permettre de résoudre le cas. Pour cela, nous suggérons d'appuyer l'étude sur une base de données offrant quelques enregistrements abritant des textes dans lesquels se trouvent noyées pêle-mêle, des adresses électroniques à débusquer.

• Télécharger le fichier compressé extraire-les-mails.rar en cliquant sur ce lien,
• Le décompresser dans le dossier de votre choix,
• Puis, double cliquer sur le fichier résultant pour l'ouvrir dans Access,

En consultant le volet de navigation sur la gauche de l'écran, vous remarquez que cette base est constituée d'une table nommée Infos et d'un formulaire, intitulé fExtraire.

• Double cliquer sur la table Info pour l'afficher en mode feuille de données,

Elle est faite de trois champs. Le premier est celui de la clé primaire. Il est auto-incrémenté. Le deuxième accueille des annotations sur des clients potentiels dans lesquelles fourmillent des adresses mails. Nous l'avons dit, il s'agit de les débusquer pour les regrouper et les isoler dans le troisième et dernier champ (info_mail), fort logiquement vide à ce stade.

• Double cliquer maintenant sur le formulaire fExtraire pour l'exécuter,

Ce formulaire est fait de deux zones de texte et de trois boutons. La première zone de texte embarque une annotation abritant des mails à débusquer. A titre d'essai dans un premier temps et pour bien comprendre le mécanisme, au clic sur le premier bouton (Essayer), toutes les adresses qu'elle renferme doivent être isolées et assemblées dans la seconde zone de texte, vide pour l'instant. Pour cela, nous créerons une fonction à appeler.

Sur ce principe, au clic sur le deuxième bouton (Traiter), nous exploiterons cette fonction pour analyser tous les enregistrements de la table et déloger les adresses mails que chacun recèle, afin de les isoler et de les assembler dans le dernier champ. Le dernier bouton permet simplement de fermer le formulaire en cours, par le biais d'une macro.

La fonction
Pour débuter, il est fort logique de créer la fonction dans un module indépendant.

• A droite du ruban Accueil, cliquer sur la flèche du bouton Affichage,
• Dans les propositions, choisir le mode Création,

Nous basculons ainsi sur la vue en conception du formulaire.

• Réaliser le raccourci clavier ALT + F11 pour afficher l'éditeur VBA Access,
• En haut de l'éditeur, cliquer sur le menu Insertion,
• Dans les propositions, choisir la commande Module,
• Dans la feuille de code du nouveau module, créer la fonction suivante :

Function trouver_adresses(texte As String) As String

End Function

Nous la typons comme un texte (As String) puisqu'elle doit retourner une chaîne de potentiels mails trouvés et assemblés. Nous la signons de même avec un paramètre textuel en attente (texte As String) pour recevoir la chaîne à analyser.

Les variables
Ensuite, nous avons besoin d'objets pour instancier la classe des expressions régulières, afin de récolter tous les résultats trouvés et de les parcourir tous dans une boucle. Mais, nous avons aussi besoin d'une variable classique pour représenter chaque adresse mail extirpée.

• Dans les bornes de la fonction, ajouter les déclarations et l'affectation suivantes :

...
Dim regExp As Object
Dim resultats As Object: Dim trouve As Object
Dim mail As String

Set regExp = CreateObject("vbscript.regexp")
...

Nous déclarons trois objets au sens large (As Object). Le premier (regExp) doit instancier la classe des expressions régulières. Et c'est d'ailleurs ce que nous faisons dans l'enchaînement des déclarations grâce à la fonction VBA CreateObject. Le suivant (resultats) doit générer une collection des résultats trouvés, soit des adresses électroniques débusquées. Le dernier (trouve) est là, à l'aide d'une boucle que nous engagerons, pour parcourir chaque résultat extrait et consolider chaque mail extirpé, les uns à la suite des autres. Enfin, la variable mail, typée comme un texte, doit recevoir tour à tour les adresses débusquées pour les consolider dans la zone de texte prévue à cet effet sur le formulaire.

Optimiser le code VBA
L'objet regExp a désormais hérité de propriétés et méthodes que nous proposons d'exploiter dans un bloc With pour simplifier et optimiser le code VBA. Il est question de définir le motif représentant la forme remarquable d'une adresse mail à déterrer au milieu de nul part, pour lancer la recherche et stocker les résultats dans la collection prévue à cet effet. Elle est nommée résultats.

• A la suite du code VBA, créer le bloc With suivant :

...
With regExp

End With
...

Chercher la forme remarquable
Nous devons maintenant construire la forme remarquable d'une adresse mail nécessairement composée du symbole de l'arobase (@), d'un point (.) et de deux ou trois lettres pour le domaine (.fr, Com etc...). Puis, nous devons engager une recherche de cette forme remarquable dans la chaîne passée en paramètre pour isoler toutes les potentielles adresses électroniques répondant favorablement à cette structure.

• Dans le bloc With, ajouter les instructions VBA suivantes :

...
.Pattern = "([a-z0-9._-]+@[a-z0-9._-]+\.[a-z]{2,3})"
.Global = True
.IgnoreCase = True
.MultiLine = True
Set resultats = .Execute(texte)
...

Nous définissons le motif de la forme remarquable : lettres, chiffres, points, \ et tiret plusieurs fois possibles (+) ( "([a-zA-Z0-9._-]+@ . Nous intercalons le symbole de l'arobase (@). De nouveau, nous autorisons des lettres, chiffres, points, \ et tirets plusieurs fois possibles (+). Nous ajoutons un point (.) avant l'extension que bous échappons (\.), car il s'agit d'un caractère spécial des expressions régulières. Enfin des lettres de l'alphabet exclusivement [a-z] sur 2 ou 3 caractères (fr, com, be etc...) sont imposées pour définir le suffixe de l'adresse.

Ensuite, nous définissons la propriété héritée Global à True pour chercher toutes les occurrences dans la chaîne et pas seulement la première. Nous réglons la propriété IgnoreCase à True pour ne pas considérer les différences de casse dans la recherche. Nous ajustons la propriété Multiline à True pour que la correspondance du motif se fasse à travers les sauts de ligne. Enfin, nous initialisons l'objet resultats avec la méthode héritée Execute par l'objet regExp pour répertorier la collection des adresses mail décelées dans la chaîne passée en paramètre de la fonction.

Parcourir les résultats
C'est maintenant que nous devons engager notre variable trouve dans une boucle For Each pour parcourir la collection des adresses mails isolées par l'exécution de notre expression régulière sur la chaîne passée en paramètre de la fonction.

• Après le bloc With, créer la boucle For Each suivante :

...
For Each trouve In resultats
mail = trouve.Value & "," & mail
Next trouve
If Right(mail, 1) = "," Then mail = Left(mail, Len(mail) - 1)
...

A chaque passage, nous assemblons les mails trouvés en les séparant d'une virgule (trouve.Value & "," & mail). Une fois la consolidation de tous les mails débusqués terminée, donc après la boucle For Each, nous éliminons la dernière virgule résiduelle, celle qui est placée à la toute fin (Right(mail, 1) = ",") et qui attendait un nouveau mail à assembler mais qui n'est jamais venu.

Retourner les adresses
A l'issue du traitement, la fonction doit répondre par son propre nom pour retourner tous les mails trouvés et assemblés, stockés dans la variable mail. Pour cela et comme vous le savez, nous devons affecter le nom même de la fonction sur cette variable résultante.

• A la toute fin de la fonction, créer l'affectation suivante :

...
Next trouve
If Right(mail, 1) = "," Then mail = Left(mail, Len(mail) - 1)

trouver_adresses = mail

End Function
...

Tester la fonction
Le code de la fonction est terminé. Avant de l'exploiter pour extraire tous les mails de la table pour les isoler dans le dernier champ prévu à cet effet, nous souhaitons l'essayer sur la chaîne qui est prédéfinie dans la première zone de texte du formulaire. Un clic sur le bouton Essayer doit l'appeler en lui passant le contenu de cette zone à analyser.

• Enregistrer les modifications (CTRL + S) et revenir sur le formulaire (ALT + Tab),
• Cliquer sur le bouton Essayer pour le sélectionner,
• Activer l'onglet Evénement de sa feuille de propriétés,
• Cliquer sur le petit bouton associé à son événement Au clic,
• Dans la boîte de dialogue, choisir le Générateur de code et valider par le bouton Ok,

De fait, nous sommes de retour dans l'éditeur VBA Access, mais cette fois entre les bornes de la procédure événementielle essai_Click. De plus, elle est écrite dans la feuille de code associée au formulaire et non dans un module indépendant, comme c'est le cas pour notre fonction, nommée trouver_adresses.

• Dans les bornes de la procédure, réaliser l'appel suivant :

adresse.Value = trouver_adresses(chaine.Value)

La première zone de texte se nomme chaine. La seconde se nomme adresse. En passant le contenu de la première à la foncion trouver_adresses que nous venons de de construire, nous réceptionnons son résultat dans la seconde.

• Enregistrer les modifications (CTRL + S) et basculer sur le formulaire (ALT + Tab),
• Exécuter ce dernier, par exemple en enfonçant la touche F5 du clavier,
• Puis, cliquer sur le bouton Essayer,

Comme vous pouvez l'apprécier, tous les mails contenus dans cette première zone sont aussitôt isolés et regroupés dans la seconde. Et si vous modifiez le contenu, au clic sur le bouton Essayer, la fonction extraira sans souci, toutes les nouvelles potentielles adresses électroniques ajoutées.

Traiter les enregistrements
Forts de ces acquis, c'est maintenant que nous devons passer aux choses sérieuses. L'idée est la suivante : Au clic sur le bouton intitulé Traiter, nous devons déclencher l'exécution d'un code VBA analysant tous les enregistrements de la table Infos. Nous l'avons dit, pour chaque ligne, les adresses électroniques doivent être dénichées et regroupées dans le champ nommé info_mail. Cela signifie que la fonction trouver_adresses doit être appelée récursivement, tant que le dernier enregistrement n'est pas atteint.

• A gauche du ruban Accueil, cliquer sur la flèche du bouton Affichage,
• Dans les propositions, choisir le mode Création,
• Sur le formulaire en conception, cliquer sur le bouton Traiter,
• Activer alors l'onglet Evénement de sa feuille de propriétés,
• Cliquer sur le petit bouton associé à son événement Au clic,
• Dans la boîte de dialogue, choisir le Générateur de code et valider par Ok,

C'est ainsi que nous sommes de retour dans l'éditeur VBA Access mais cette fois, entre les bornes de la procédure événementielle traiter_Click.

Les variables
Nous devons piloter les enregistrements dans la base de données en cours. Donc, nous avons besoin d'objets mais aussi de variables plus classiques.

• Dans les bornes de la procédure, ajouter les déclarations suivantes :

...
Dim base As Database: Dim enr As Recordset
Dim lesMails As String: Dim requete As String: Dim lId As Integer
...

Nous typons l'objet base comme un objet de base de données (Database). Son rôle sera de représenter la base active. Nous typons l'objet enr de manière à ce qu'il représente un jeu d'enregistrements (Recordset). Dans la variable lesMails, pour chaque enregistrement, nous regrouperons les adresses trouvées. C'est pourquoi, nous la typons comme un texte (As String). Nous stockerons la syntaxe de la requête de mise à jour dans la variable requete. En effet, il est question d'isoler les mails trouvés pour chaque enregistrement, dans le dernier champ (info_mail). Pour que cette update se fasse sur le bon numéro d'enregistrement, nous aurons besoin de le stocker préalablement dans la variable lId. C'est la raison pour laquelle nous la typons comme un entier (As Integer).

Piloter la base active
Maintenant que les objets existent, nous pouvons les initialiser pour prendre possession de la base de données et pour piloter les enregistrements de sa table.

• Après les variables, ajouter les deux affectations suivantes :

...
Set base = CurrentDb()
Set enr = base.OpenRecordset("Infos")
...

Grâce à la fonction VBA Access CurrentDb, nous initialisons (Set) l'objet base sur la base de données en cours. C'est ainsi qu'il hérite de propriétés et méthodes pour la piloter. Et précisément dans l'enchaînement, nous exploitons sa méthode héritée OpenRecordset pour initialiser (Set) l'objet enr sur les enregistrements de la table Infos.

Pointer sur le premier enregistrement
Grâce à cette seconde affectation, l'objet enr a lui aussi hérité de propriétés et méthodes spécifiques. Nous allons en exploiter certaines, notamment pour naviguer au travers des enregistrements de la table Infos.

• A la suite du code, ajouter les instructions VBA suivantes :

...
enr.MoveFirst
Do

enr.MoveNext
Loop While Not enr.EOF
...

Avec la méthode MoveFirst héritée par l'objet enr, nous plaçons tout d'abord le pointeur de lecture sur le premier enregistrement de la table. Puis, nous engageons une boucle (Do) destinée à les parcourir tous jusqu'au dernier (Loop While Not enr.EOF). A chaque passage et après les traitements qu'il nous reste encore à entreprendre, nous n'oublions pas de déplacer le pointeur sur l'enregistrement suivant (MoveNext).

Trouver et ajouter les mails
A chaque passage dans cette boucle, nous devons engager la fonction trouver_adresses sur le contenu du champ info_notes. Tous les mails ainsi isolés doivent ensuite être ajoutés dans le champ info_mail. Donc il est question d'exécuter une requête de mise à jour, autant de fois qu'il y a d'enregistrements à analyser.

• Dans la boucle, avant le MoveNext, ajouter les instructions VBA suivantes :

...
Do
lesMails = trouver_adresses(enr.Fields("info_note").Value)
lId = enr.Fields("info_num").Value
requete = "UPDATE Infos SET info_mail = '" & lesMails &"' WHERE info_num=" & lId
base.Execute requete
enr.MoveNext
Loop While Not .EOF
...

Grâce à notre fonction, nous regroupons donc les mails trouvés dans la variable lesMails. Nous prélevons l'identifiant de l'enregistrement en cours d'analyse, dans la variable LId. Ensuite nous construisons la syntaxe de la requête de mise à jour (Update) dans la variable requete. Nous insérons les adresses isolées (lesMails), dans le champ info_mail, pour l'enregistrement en cours (WHERE info_num=" & lId). Attention de bien respecter l'alternance des simples et doubles côtes (= '" & lesMails & "'), pour l'insertion des mails.

Décharger et tester
Pour finir, nous devons décharger les objets de programmation afin de libérer proprement la mémoire de l'ordinateur.

• Après la boucle, ajouter les instructions VBA suivantes :

...
Loop While Not enr.EOF

MsgBox "Les adresses mails ont correctement été isolées.", vbInformation

base.Close
Set enr = Nothing
Set base = Nothing

End Sub
...

Tout d'abord nous adressons un message de confirmation à l'utilisateur avec la fonction MsgBox. Nous exploitons la méthode Close de l'objet base pour fermer l'instance d'Access. Enfin, nous réinitialisons (Set), les deux objets à Nothing pour les détruire et donc, pour les sortir de la mémoire.

• Enregistrer les modifications (CTRL + S) et revenir sur le formulaire (ALT + Tab),
• Exécuter ce dernier, par exemple avec la touche F5 du clavier,
• Puis, cliquer sur le bouton Traiter,

Et si vous ouvrez la table Infos, vous avez le plaisir de constater que tous les mails ont parfaitement été extraits de chaque enregistrement et qu'ils ont été regroupés dans le champ info_mail.