Nettoyer un document Word par les boucles VBA et les tableaux

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


Sujets que vous pourriez aussi aimer :


Nettoyer des documents

Nous avons déjà appris à réaliser des opérations consistant à corriger les défauts dans la globalité d'un document. Et pour cela, nous avions exploité la propriété Find et sa méthode Execute pour l'objet Selection. Ici, il est question de récidiver mais dans un modèle où les corrections à entreprendre sont plus nombreuses, voire très nombreuses. Dans ce contexte, il est important de pouvoir optimiser le code afin de ne pas répéter les instructions à chaque fois qu'un remplacement est à opérer.



Dans l'exemple illustré par la capture, de nombreuses anomalies de conception se sont glissées. Pour la plupart, il s'agit d'espaces insérés avant une virgule ou un point ou encore après un point alors qu'un saut de paragraphe ou un saut de ligne survient. On note même la présence de tabulations en entête de certains paragraphes. Ce type de décalage s'opère avec les retraits et nous l'avons déjà expliqué dans une précédente astuce. Pour nettoyer ce document, il convient de considérer tous ces contextes qui pourraient être bien plus importants, avec un code qui lui ne grossirait pas avec le nombre de défauts. L'intérêt de ce nouveau volet est d'apprendre des techniques optimisées de programmation.

Document source
Pour la démonstration de cette astuce VBA Word, nous proposons d'appuyer l'étude sur un document hébergeant ces curieuses anomalies.

• Télécharger le fichier compressé nettoyer-en-cascade.rar en cliquant sur ce lien,
• Puis, le décompresser dans le dossier de votre choix,

La décompression livre deux fichiers. Le premier est nommé nettoyer.vbs. Il offre une procédure de code VBA que nous exploiterons. Le second fichier se nomme nettoyer-en-cascade.docx. C'est lui qui abrite les défauts à corriger.

• Double cliquer sur ce second fichier pour l'ouvrir dans Word,
• Puis, cliquer sur le bouton Activer la modification du bandeau de sécurité,

Nous retrouvons le document de la présentation avec ses défauts. Des espaces figurent à des emplacements illicites que ce soit avant une virgule ou un point ou encore en début de paragraphe. De même, certaines tabulations sont effectivement injustement utilisées pour décaler la première ligne de certains paragraphes. Tous ces défauts ne se corrigent pas de la même façon. Certes, pour chacun il faut engager une recherche et un remplacement global. Mais les reconnaissances et les corrections diffèrent.

Procédure VBA commune
Pour un code VBA capable de corriger tous les défauts et d'évoluer en acceptant d'intégrer de nouvelles anomalies à contrôler, nous devons créer un traitement centralisé ajustable dynamiquement. Cette procédure doit se soucier de rechercher et de remplacer dans le document actif. Mais cette recherche et ce remplacement doivent pouvoir varier en fonction du défaut à corriger. Et pour cela, il suffit que la fonction attende des paramètres variables. C'est le cas de la routine offerte dans le fichier vbs. Elle est composée d'instructions que nous avons démontrées à plusieurs reprises dans les astuces précédentes. C'est pourquoi, il est de bon ton de récupérer son code.

• A la racine du dossier de décompression, cliquer droit sur le fichier nettoyer.vbs,
• Dans le menu contextuel, choisir de l'ouvrir avec un éditeur comme le Notepad,
• Dans l'éditeur, réaliser le raccourci clavier CTRL + A pour sélectionner tout le code,
• Ensuite, le copier à l'aide du raccourci clavier CTRL + C,
• Revenir sur le document Word,
• Dès lors, réaliser le raccourci clavier ALT + F11 pour basculer dans l'éditeur VBA Word,
• Dans l'explorateur de projet sur la gauche, cliquer sur l'élément Normal,

Nous le répétons à chaque occasion, il s'agit du modèle de Word. Grâce à lui, tout code VBA écrit en son sein est disponible pour n'importe quel document.

• En haut de la fenêtre de l'éditeur VBA, cliquer sur le menu Insertion,
• Dans les propositions, choisir l'option Module,

Cette action a pour effet de créer un nouveau module VBA. Sa feuille de code vierge doit apparaître au centre de l'écran. Si ce n'est pas le cas, il convient de double cliquer sur ce module dans l'arborescence pour forcer l'affichage de sa feuille de code.

• Dans cette feuille, coller (CTRL + V) le code VBA précédemment copié,

Il s'agit donc d'une procédure qui attend deux paramètres : texteC et texteR. Il s'agit respectivement du texte ou de la forme cherchée et du texte ou de la forme de remplacement. Tout le reste est bien connu. Le point d'insertion est tout d'abord replacé en haut du document grâce à la méthode HomeKey de l'objet VBA Selection. Ensuite la propriété Find de l'objet Selection est engagée dans un bloc With pour optimiser le code. Puis, sont paramétrés tous les réglages de la recherche et du remplacement, donc le texte cherché (.Text = texteC) et le texte de remplacement (.Replacement.Text = texteR).

Tableaux de variables
Pour un traitement capable d'évoluer et de considérer n'importe quel nouveau défaut, l'astuce consiste à utiliser deux tableaux de variables. Le premier doit recenser toutes les anomalies à corriger. Le second et dans le même ordre, doit lister toutes les occurrences de remplacement. Dès lors, il suffira d'engager une boucle sur la hauteur des tableaux pour appeler récursivement la procédure de remplacement (Remplacer) en lui passant les éléments de recherche et de remplacement en cours lecture. A ce titre, vous notez la déclarative de la procédure avec le mot clé Private. Comme nous l'avons dit, elle est destinée à être appelée et non à être exécutée seule. De fait, elle n'apparaîtra pas dans la liste des macros.

• Sous la procédure Remplacer, créer la procédure Nettoyer comme suit :

Sub Nettoyer()

End Sub

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

Sub Nettoyer()
Dim Defauts As Variant: Dim Corrections As Variant
Dim Compteur As Byte: Dim Borne As Byte

End Sub

Les deux premières variables sont déclarées comme des Variant. En d'autres termes, elles ne sont pas typées. Et pour cause, nous allons les transformer en tableaux de variables grâce à la fonction VBA Array. Les deux variables suivantes sont typées comme des entiers courts. La première (compteur) doit être la variable de boucle destinée à passer en revue toutes les formes de recherche et toutes les formes de remplacement. La seconde (Borne) doit représenter la limite supérieure de la boucle. Elle doit être calibrée sur la dimension des tableaux de variables qu'il nous reste à créer.

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

Sub Nettoyer()
Dim Defauts As Variant: Dim Corrections As Variant
Dim Compteur As Byte: Dim Borne As Byte

Defauts = Array(" ,", ".", "^p ", " ^p", "^l ", " ^l")
Corrections = Array(",", ".", "^p", "^p", "^l", "^l")

End Sub

Grâce à la fonction VBA Array, nous énumérons respectivement les défauts et les corrections. Dans le premier tableau, attention de bien respecter les espaces tantôt avant la virgule, avant le point, après un saut de paragraphe (^p) ou avant, après un saut de ligne (^l) ou avant. Naturellement, dans le tableau des corrections, ces espaces n'apparaissent plus.

Désormais, avant d'engager la boucle destinée à parcourir tous ces termes de recherche et de remplacement, faut-il encore savoir sur combien d'occurrences elle doit tourner. Pour cela, il suffit de prélever la dimension des tableaux. Et cette information est retournée par la fonction VBA UBound à appliquer sur l'un des tableaux de variables. La borne inférieure est connue quant à elle. Elle doit débuter à l'indice zéro (0), soit la première rangée des tableaux.

• A la suite du code, ajouter l'instruction VBA suivante :

Sub Nettoyer()
Dim Defauts As Variant: Dim Corrections As Variant
Dim Compteur As Byte: Dim Borne As Byte

Defauts = Array(" ,", " .", "^p ", "^p", "^l ", " ^l")
Corrections = Array(",", ".", "^p", "^p", "^l", "^l")

Borne = UBound(Defauts)

End Sub

Nous stockons donc dans la variable borne l'indice supérieur à ne pas dépasser pour la boucle. Et pour cela, nous passons à la fonction UBound l'un des deux tableaux, le premier en l'occurrence ici.

Maintenant que nous connaissons les repères, nous pouvons initialiser la boucle.

• A la suite du code, créer les bornes de la boucle For Next comme suit :

Sub Nettoyer()
Dim Defauts As Variant: Dim Corrections As Variant
Dim Compteur As Byte: Dim Borne As Byte

Defauts = Array(" ,", " .", "^p ", "^p", "^l ", " ^l")
Corrections = Array(",", ".", "^p", "^p", "^l", "^l")

Borne = UBound(Defauts)

For Compteur = 0 To Borne

Next Compteur

End Sub

Il reste donc un traitement à définir et il sera récursif. A chaque passage dans la boucle, la variable compteur s'incrémente jusqu'à atteindre la limite supérieure des tableaux. Nous devons l'utiliser pour passer chaque défaut et chaque correction de la position en cours d'analyse à la fonction Remplacer. C'est ainsi, dans un traitement optimisé et dans un code épuré que toutes les anomalies pourront être corrigées.

• Dans les bornes de la boucle, ajouter l'appel à la fonction Remplacer, comme suit :

Sub Nettoyer()
Dim Defauts As Variant: Dim Corrections As Variant
Dim Compteur As Byte: Dim Borne As Byte

Defauts = Array(" ,", " .", "^p ", "^p", "^l ", " ^l")
Corrections = Array(",", ".", "^p", "^p", "^l", "^l")

Borne = UBound(Defauts)

For Compteur = 0 To Borne
Remplacer Defauts(Compteur), Corrections(Compteur)
Next Compteur

End Sub

Pour chaque terme recensé dans les tableaux, nous appelons la fonction Remplacer qui se charge de trouver le premier pour le remplacer par le second toutes les fois où il est présent.

Il convient maintenant de tester ce code VBA de nettoyage. Pour cela, nous pouvons créer un bouton de macro à disposer dans l'un des rubans en haut de la fenêtre Word. Les précédentes astuces ont démontré comment y parvenir. Mais nous pouvons aussi choisir d'exécuter directement cette macro depuis la bibliothèque qui les référence toutes.

• Enregistrer les modifications (CTRL + S) et revenir sur le document Word (ALT + Tab),
• En haut de la fenêtre Word, cliquer sur l'onglet Développeur pour afficher son ruban,

S'il n'est pas disponible dans votre environnement, vous devez l'ajouter. Pour cela, vous devez premièrement cliquer droit n'importe où sur le ruban actif. Puis, dans le menu contextuel, vous devez choisir la commande Personnaliser le ruban. Ensuite, dans la liste de droite de la boîte de dialogue qui apparait, vous devez cocher la case Développeur. Enfin, vous devez valider par le bouton Ok en bas de la boîte de dialogue.

• Dès lors, dans la section Code à gauche du ruban Développeur, cliquer sur le bouton Macros,
• Dans la boîte de dialogue qui suit, sélectionner la macro Nettoyer,
• Puis, cliquer sur le bouton Exécuter pour lancer le traitement,

Comme vous pouvez le voir, tous les défauts ont été corrigés ou presque. En effet, c'est volontairement que nous avons omis de préciser le remplacement des tabulations afin de constater à quel point il est simple de faire évoluer cette procédure de nettoyage. Mais tous les espaces illicites ont disparu, qu'ils s'agissent de ceux situés avant un point ou une virgule ou de ceux situés avant un saut de paragraphe ou un saut de ligne ou encore en début de paragraphe.

Pour finir et pour démontrer la simplicité d'implémentation de cette procédure, il convient tout d'abord de fermer le document sans l'enregistrer puis de le rouvrir. Ainsi, nous le retrouvons dans son état originel avec ses défauts. Dès lors, il convient de revenir dans le code pour ajouter la recherche et le remplacement manquants dans les tableaux de variables. Une tabulation est jugée illicite lorsqu'elle intervient en tout début de paragraphe. Elle est donc nécessairement préfixée par un saut de paragraphe matérialisé par le code ^p. Souvenez-vous, la tabulation est quant à elle matérialisée par le code ^t.

• Ajouter les nouveaux éléments aux tableaux de variables, comme suit :

Sub Nettoyer()
Dim Defauts As Variant: Dim Corrections As Variant
Dim Compteur As Byte: Dim Borne As Byte

Defauts = Array(" ,", " .", "^p ", "^p", "^l ", " ^l", "^p^t")
Corrections = Array(",", ".", "^p", "^p", "^l", "^l", "^p")

Borne = UBound(Defauts)

For Compteur = 0 To Borne
Remplacer Defauts(Compteur), Corrections(Compteur)
Next Compteur

End Sub

Nous cherchons donc à remplacer chaque tabulation précédée d'un saut de paragraphe par un simple saut de paragraphe. En d'autres termes, nous cherchons à supprimer ces tabulations spécifiques. Et comme la boucle est engagée sur la hauteur des tableaux, ces nouveaux éléments vont être considérés automatiquement.

• Enregistrer les modifications (CTRL + S) et basculer sur le document Word (ALT + Tab),
• Dans la section Code du ruban Développeur, cliquer sur le bouton Macros,
• Dans la boîte de dialogue, sélectionner la macro Nettoyer et cliquer sur le bouton Exécuter,

Cette fois et toujours aussi instantanément, plus aucune anomalie ne persiste. L'intégralité du document a été purgé de ses défauts à l'aide d'un traitement VBA parfaitement optimisé et évolutif.