Récolter les données de fichiers externes en VBA Excel

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


Sujets que vous pourriez aussi aimer :


Traiter et consolider les données de fichiers externes

Nous proposons ici de débuter un développement que nous allons décomposer en trois volets. L'objectif à l'issue, sera de proposer des résultats de recherche purgés des données parasites, sur la base d'une saisie semi-automatique. Cette saisie intuitive sera rendue possible par la consolidation des informations contenues dans des fichiers de cache. Ces fichiers de cache ont été générés par le serveur d'un site Internet en fonction des recherches les plus fréquentes réalisées par les internautes. Ils font office de base de connaissance afin de restituer rapidement les résultats sans solliciter le serveur.



Dans cette première partie, nous proposons d'accéder à ces fichiers de cache, afin de consolider les informations qu'ils recèlent par le code Visual Basic Excel. Ainsi, nous pourrons construire deux nouveaux petits fichiers externes consistant en une concaténation des mots clés de recherche. Ces concaténations seront exploitées par la suite, afin de générer les propositions intuitives et pertinentes, au fil de la saisie des caractères, dans le moteur de recherche.

Sources et présentation
Pour travailler en conditions réelles, nous allons récupérer entre autres, de véritables fichiers de cache construits par le site www.bonbache.fr, au fur et à mesure des requêtes formulées par les internautes, par le biais du moteur de recherche.

• Télécharger le fichier consolider-donnees-fichiers.rar en cliquant sur son lien,
• Le décompresser dans le dossier de votre choix,
• Puis, double cliquer sur le fichier traitement-fichiers-externes.xlsm pour l'ouvrir dans Excel,
• Cliquer ensuite sur le bouton Activer la modification du bandeau de sécurité,

Ce classeur est constitué de deux feuilles : Consolidation et Recherche. La feuille Recherche est activée par défaut. Il s'agit de la finalité de l'application à créer. La consolidation doit se produire depuis l'autre feuille.

• Cliquer sur l'onglet Consolidation en bas de la fenêtre Excel pour activer sa feuille,

Une zone d'extraction est proposée à partir de la ligne 5 entre les colonnes B et D. Cette extraction doit intervenir au clic sur le bouton Récolter, en colonne F.

• Dans le dossier de décompression, double cliquer sur le sous dossier cache pour l'ouvrir,

Tous les fichiers de cache constitués par le serveur y sont présents. Ils correspondent aux demandes réalisées par les internautes au moment de la recherche. Chaque fichier est nommé en fonction des termes utilisés pour la requête. Ils consistent donc en un assemblage de mots clés séparés par un tiret (-), avec un suffixe supplémentaire, celui de l'extension du fichier (.txt). Leur contenu est la réponse Html fournie à l'instant t par le serveur. Il s'agit d'une partie de page mise en forme proposant les liens de redirection vers les rubriques pertinentes.

Notre code VBA Excel doit donc parcourir l'ensemble de ces fichiers dans le dossier cache pour restituer les mots clés en première colonne, le poids en Ko en deuxième colonne et le nombre de résultats (liens Href) fournis. Finalement, forts de ces informations, nous construirons deux fichiers externes, rassemblant ces chaînes de mots clés concaténés. Ils seront ainsi utilisés pour distiller des propositions pertinentes au cours de la frappe dans le moteur de recherche.

Purger les anciennes extractions
Notre développement doit se décomposer en deux étapes à matérialiser par deux procédures indépendantes à créer. La première doit se charger de vider les cellules de la zone d'extraction des potentiels précédents traitements. La seconde doit parcourir l'ensemble des fichiers contenus dans le sous dossier cache, afin de traiter et consolider les informations qu'ils détiennent. Pour la suite des opérations, le ruban Développeur doit être présent dans l'environnement. La formation pour débuter la programmation en VBA Excel rappelle comment l'afficher.

• Revenir sur la feuille Consolidation du classeur Excel,
• Cliquer sur l'onglet Développeur en haut de la fenêtre Excel pour activer son ruban,
• Dans la section Contrôles du ruban, cliquer sur le bouton Mode création,
• Puis, double cliquer sur le bouton Récolter situé sur la feuille Excel en colonne F,

Nous basculons ainsi dans l'éditeur de code VBA Excel, entre les bornes de la procédure événementielle recolter_Click. Le code que nous y ajouterons se déclenchera au clic sur ce bouton.

• Entre les bornes de la procédure, ajouter les deux appels suivants :

nettoyer
traiter_cache

Nous appelons les procédures nettoyer et traiter_cache qui doivent réaliser les actions que nous avons énoncées précédemment.



Nous avons volontairement anticipé. Car bien que nous les appelions, ces deux procédures de code n'existent pas encore. Sans plus attendre, nous devons donc les créer.

• Dans l'arborescence de l'explorateur de projet, sur la gauche de l'éditeur VBA, déployer l'affichage du dossier Modules,
• Puis, double cliquer sur l'élément Module1 pour afficher sa feuille de code vierge, au centre de l'écran,
• Dans cette feuille de code, créer les deux procédures, comme suit :

Sub nettoyer()

End Sub

Sub traiter_cache()

End Sub

Les deux procédures existent désormais et peuvent être appelées. La procédure nettoyer, doit parcourir l'ensemble des cellules de la colonne B (indice 2) à partir de la ligne 5, qui correspond au point de départ de l'extraction. Il n'est pas forcément nécessaire de désigner la feuille Consolidation dans le code puisque la procédure appelante, celle du bouton, lui appartient. Pour parcourir les cellules de la feuille, nous devons commencer par déclarer les variables permettant de faire varier ces indices.

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

Dim ligne As Integer: Dim colonne As Integer

ligne = 5

L'indice de colonne doit varier entre 2 et 4 (Colonnes B à D). Comme ces bornes sont fixes et connues, nous nous en chargerons à l'aide d'une boucle For Next. Le point de départ de l'indice de ligne est connu. Nous l'initialisons sur la cinquième. L'arrivée en revanche dépend du nombre de cellules remplies qu'il faut vider. Ce traitement récursif peut être réalisé grâce à une boucle While, qui continuera de s'exécuter tant que la cellule en cours de lecture est détectée comme non vide.

• A la suite du code, ajouter les bornes de la boucle While, comme suit :

While (Cells(ligne, 2).Value <> "")

ligne = ligne + 1
Wend

Le critère indique bien de poursuivre l'analyse tant qu'une cellule non vide est détectée (Cells(ligne,2).Value <> ""). Pour que chaque cellule de la colonne B soit passée en revue, nous n'oublions pas d' incrémenter la variable ligne avant de boucler (ligne = ligne + 1). A l'intérieur de cette boucle, nous devons vider les cellules de la rangée, donc de la colonne B à D. Plutôt que de les énumérer, nous préférons inclure l'instruction dans un traitement récursif, plus productif. Pour ce faire :

• Entre les bornes de la boucle et avant l'incrémentation de la variable ligne, ajouter les instructions suivantes :

For colonne = 2 To 4
Cells(ligne, colonne).Value = ""
Next colonne

Pour la ligne en cours, de la colonne B à la colonne D (For colonne = 2 To 4), nous vidons le contenu de chaque cellule. C'est la propriété Value de l'objet Cells qui permet de désigner le contenu d'une cellule pointée, grâce à sa référence de ligne et sa référence de colonne. Il est temps de tester ce bout de code Visual Basic.

• Enregistrer les modifications (CTRL + S),
• Basculer sur la feuille du classeur (ALT + F11),
• Sélectionner la plage de cellules B5:D12 par exemple,
• Saisir un texte à titre d'essai, comme test,
• Valider la saisie par le raccourci CTRL + Entrée pour le répliquer sur l'ensemble des cellules sélectionnées ,
• Dans le ruban Développeur, cliquer sur le bouton Mode création pour le désactiver,
• Puis, cliquer sur le bouton Récolter de la feuille Excel pour tester le code,

Comme vous le constatez, les données sont parfaitement purgées. Toutes les anciennes saisies disparaissent automatiquement. Le code complet de la procédure nettoyer est le suivant :

Sub nettoyer()
Dim ligne As Integer: Dim colonne As Integer

ligne = 5

While (Cells(ligne, 2).Value <> "")
For colonne = 2 To 4
Cells(ligne, colonne).Value = ""
Next colonne
ligne = ligne + 1
Wend
End Sub

Parcourir les fichiers d'un dossier en VBA
Pour récolter et consolider les informations des fichiers de cache, encore faut il être en mesure de bâtir un code récursif, capable de passer en revue chacun d'entre eux, dans le dossier qui les contient. La formation VBA Access sur l'accès aux fichiers externes, nous avait appris à instancier la classe permettant d'hériter des propriétés et méthodes nécessaires.

• Basculer dans l'éditeur de code Visual Basic Excel (ALT + F11),
• Entre les bornes de la procédure traiter_cache, ajouter les déclarations et affectations suivantes :

Dim nom_dossier As String: Dim fichier As Object
Dim le_dossier, chaque_fichier: Dim flux_lecture
Dim ligne As Integer: Dim expression As String
Dim memoire As String: Dim le_fichier As String
Dim contenu As String: Dim ligne_texte As String

nom_dossier = ThisWorkbook.Path & "\cache\"
ligne = 5

Nous déclarons notamment la variable nom_dossier en tant que chaîne de caractères afin de stocker le chemin d'accès au sous dossier contenant tous les fichiers de cache. Les variables objets et les variables non typées serviront à piloter les dossiers et fichiers sur le disque. La variable ligne bien sûr est à nouveau déclarée en vue de pointer sur les cellules de la feuille, afin de reconstituer l'information prélevée, ligne à ligne. La variable mémoire permettra de reconstituer tous les mots clés concaténés pour finalement les mémoriser dans des fichiers externes à créer. Nous réalisons ensuite les deux premières affectations. Tout d'abord, la propriété Path de l'objet ThisWorkbook retourne le chemin d'accès complet au dossier du classeur en cours. Nous le concaténons avec le sous dossier cache (& "\cache\") pour terminer la construction du chemin qui permettra d'atteindre les fichiers souhaités. Puis, nous initialisons la variable ligne à 5, soit la ligne à partir de laquelle nous produirons l'extraction des données sur la feuille Consolidation. Il s'agit maintenant d'instancier les classes permettant de piloter les fichiers et les dossiers, comme nous l'avons déjà réalisé dans de précédentes formations.

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

Set fichier = CreateObject("scripting.filesystemobject")
Set le_dossier = fichier.getfolder(nom_dossier)
Set flux_lecture = CreateObject("ADODB.Stream")

Nous exploitons de nouveau la précieuse fonction VBA CreateObject comme nous l'avions notamment fait dans la formation VBA Access pour archiver les données. Selon l'argument qui lui est passé en paramètre, elle permet d'instancier des classes stockées dans des librairies de code du système d'exploitation. Avec le paramètre scripting.filesystemobject, l'objet fichier hérite des propriétés et méthodes permettant de manipuler les fichiers et dossiers du disque. Avec le paramètre ADODB.Stream, l'objet flux_lecture hérite des propriétés et méthodes pour accéder au contenu des fichiers, tout en définissant l'encodage pour la réception des données. En exploitant donc la méthode héritée getfolder, nous initialisons l'objet le_dossier de manière à ce qu'il dispose des propriétés et méthodes pour manipuler précisément le dossier dont le chemin est passé en paramètre de la méthode. Ce chemin, mémorisé dans la variable nom_dossier, est celui que nous avons reconstruit pour pointer sur les fichiers de cache.

• A la suite du code, ajouter les bornes de la boucle de traitement, comme suit :

For Each chaque_fichier In le_dossier.Files

Next chaque_fichier

Nous exploitons une boucle VBA For Each afin de parcourir l'ensemble des fichiers contenus dans le dossier, désigné par la propriété Files désormais proposée par l'objet le_dossier. Cette propriété correspond à une collection renfermant l'ensemble des fichiers ainsi pointés. Comme la variable chaque_fichier était déclarée mais non typée, son typage intervient au moment de l'initialisation de la boucle. Cette variable hérite donc des propriétés permettant d'accéder aux informations des fichiers. A chaque passage dans la boucle, nous devons commencer par récupérer le nom des fichiers, grâce à la propriété Name de l'objet chaque_fichier. Ces noms correspondent aux mots clés des recherches réalisées par les internautes. Nous devons donc les purger de leur extension et des tirets pour retrouver l'espace naturel entre chaque mot.

• Dans les bornes de la boucle For Each, ajouter les traitements VBA suivants :

expression = Replace(Replace(chaque_fichier.Name, ".txt", ""), "-", " ")
expression = LTrim(expression)
expression = RTrim(expression)

La fonction VBA Replace permet de remplacer une occurrence (".txt") par une autre (""), dans une chaîne de caractères (chaque_fichier.Name), passée en premier paramètre. En imbriquant deux fonctions Replace, nous remplaçons à la volée, l'extension .txt par une chaîne vide et le tiret par un espace. Puis nous exploitons les fonctions LTrim et RTrim qui permettent respectivement de supprimer les espaces potentiels en début et fin de chaîne.

Nous réceptionnons donc les mots clés parfaitement reconstitués dans la variable expression. S'il ne s'agit pas d'un doublon, nous devrons les restituer dans la zone d'extraction de la feuille Consolidation. Ils devront aussi figurer dans le fichier final externe qui servira aux suggestions de la saisie semi-automatique.

Nous proposons de poursuivre par la vérification de ce critère grâce à l'instruction VBA conditionnelle If.

• A la suite du code, ajouter le test suivant :

If (InStr(memoire, expression) = 0) Then
le_fichier = nom_dossier & chaque_fichier.Name
contenu = ""
End If

Nous avions déclaré la variable memoire que nous devons charger, à chaque passage dans la boucle, des nouveaux mots clés ayant passé le test avec succès. Grâce à la fonction VBA InStr, nous testons la présence des mots clés en cours d'analyse, dans la variable mémoire. Si la fonction retourne la valeur 0, cela signifie que les mots clés n'ont pas encore été ajoutés. Nous commençons donc par reconstituer le chemin d'accès complet au fichier en cours d'analyse (nom_dossier & chaque_fichier.Name). Ainsi nous pourrons y accéder pour réaliser certains tests sur son contenu. C'est la raison pour laquelle nous réinitialisons ensuite la variable qui servira à le récupérer (contenu = "").

Accéder aux données des fichiers externes
Comme nous l'avons évoqué plus haut, ces fichiers ont été construits et consolidés par un code serveur, selon les requêtes réalisées par les internautes. Ils sont donc encodés dans un format spécifique qui se nomme UTF-8. Nous devons respecter cet encodage pour permettre une lecture du fichier transcrite dans le bon format. C'est l'instanciation de la classe ADODB.Stream en début de code qui a fourni les propriétés et méthodes nécessaires à l'objet flux_lecture.

• A la suite du code, dans les bornes de l'instruction conditionnelle, ajouter les lignes suivantes :

flux_lecture.Charset = "utf-8"
flux_lecture.Open
flux_lecture.LoadFromFile (le_fichier)
contenu = flux_lecture.ReadText()
flux_lecture.Close

Tout d'abord, la propriété Charset de l'objet flux_lecture permet de définir l'encodage à utiliser pour la lecture à suivre. Sa méthode Open permet alors de réserver un emplacement en mémoire pour le chargement du contenu. Et c'est ensuite la méthode LoadFromFile qui réalise le chargement du fichier dont le chemin d'accès est passé en paramètre. La méthode ReadText() permet de récupérer l'intégralité du contenu qui est affecté à la variable contenu. Enfin, nous n'oublions pas de libérer la mémoire grâce à la méthode Close de l'objet.

A chaque passage dans la boucle, c'est en effet un nouveau fichier texte qui est ouvert en mémoire afin de prélever son contenu. Nous devons désormais exploiter ce contenu afin de renseigner les colonnes C et D du tableau d'extraction. Nous avons déjà récupéré les mots clés. Nous devons connaître le poids du fichier et le nombre de réponses qu'il offre à la demande client. Certains fichiers de cache existent bien mais ne proposent pas de réponse pertinente. Leur objectif est simplement de restituer une information depuis la base de connaissance plutôt que de resolliciter à tort le serveur. Par exemple, lorsque les fragments de texte suivants sont trouvés : Nous n'avons pas trouvé et logos/, nous savons que la réponse n'est pas pertinente et que les mots clés ne doivent pas être considérés. C'est encore une fois la fonction VBAInStr qui va nous permettre de tester leur présence.

• A la suite du code, toujours dans les bornes de l'instruction If, ajouter les traitements suivants :

If (InStr(contenu, "Nous n'avons pas trouvé") = 0 And InStr(contenu, "logos/") = 0) Then
memoire = memoire + "|" + expression
Cells(ligne, 2).Value = expression
Cells(ligne, 3).Value = Round(FileLen(le_fichier) / 1024, 1)

Dim chaine_tab() As String
chaine_tab = Split(contenu, "<img")
Cells(ligne, 4).Value = UBound(chaine_tab())
ligne = ligne + 1
End If

Nous imbriquons donc une nouvelle instruction conditionnelle à l'intérieur de la première afin de restreindre les propositions pertinentes au plus juste. La double condition vérifiée par l'instruction conditionnelle permet de vérifier l'absence des deux termes à exclure. Si le fichier est jugé comme pertinent, la chaîne des mots clés est concaténée aux précédents qui avaient été jugés eux aussi comme pertinents (memoire = memoire + "|" + expression). De fait, nous restituons tout d'abord ces mots clés en colonne B de la zone d'extraction pour la ligne en cours (Cells(ligne,2).Value = expression). Ensuite, la fonction VBA FileLen permet de retourner en octets, la taille du fichier dont le chemin d'accès lui est passé en paramètre. Nous convertissons ce résultat en Kilo-Octets en le divisant par 1024. La fonction VBARound permet alors de limiter le nombre de décimales en fonction de l'information qui lui est passée en second paramètre. Nous inscrivons ce calcul dans la colonne C pour la ligne en cours (Cells(ligne, 3).Value).

A ce stade, nous avons donc déjà récupéré et inscrit les mots clés et le poids du fichier correspondant. Il reste à indiquer combien de réponses pertinentes offre ce fichier de cache. Comme nous l'avons constaté en début de formation, ces fichiers proposent le code HTML complet de la rubrique à restituer. Dans ce code, nous pouvons déceler la présence d'un élément remarquable pour faciliter le décompte, celui de la balise img. La balise img permet d'afficher une image sur la page Web. Cette balise est associée à chaque rubrique correspondant à une formation répondant à la demande internaute. Si nous pouvons compter ces balises, nous pouvons déduire le nombre de réponses. Et pour cela nous proposons d'exploiter une astuce, grâce à la fonction VBA Split pour découper le contenu complet sur cette balise. Nous obtiendrons ainsi un tableau de variables dont la dimension sera équivalente au résultat à retourner. C'est pourquoi nous déclarons un tableau de variables (Dim chaine_tab() As String), dans la boucle. Il est ainsi redimensionné au plus juste à chaque passage par la fonction Split (Split(contenu, "< img")), qui découpe le fichier sur la balise Img. La fonction UBound permet alors de retourner la borne supérieure de ce tableau ainsi dimensionné, soit le nombre d'éléments qu'il contient. Nous affichons ce résultat en colonne D (4) de la ligne en cours par affectation (Cells(ligne, 4).Value). Enfin et surtout, nous n'oublions pas d'incrémenter la variable ligne pour inscrire les prochains résultats à la suite, dans le tableau d'extraction. Il est temps de réaliser un test.

• Enregistrer les modifications (CTRL + S) et basculer sur la feuille Excel (ALT + F11),
• Cliquer sur le bouton Récolter situé en colonne F,

Vous remarquez que la consolidation des données se réalise au fur et à mesure que le code VBA Excel parcourt l'ensemble des fichiers situés dans le sous dossier cache de l'application. Nous restituons ainsi les mots clés jugés comme pertinents, associés à la taille du fichier et le nombre de réponses proposées. Vous notez la présence d'un résultat de synthèse en cellule F2. Le calcul existait déjà. Il exploite la fonction NbVal pour compter le nombre de cellules inscrites et donc le nombre de résultats extraits en temps réel. Deux unités lui sont retranchées pour ne pas considérer les deux cellules de titre dans la colonne du décompte.

Exporter les résultats consolidés
Nous devons désormais exploiter les résultats de cette consolidation afin d'exporter les mots clés, sous forme de chaîne concaténée, dans deux fichiers externes. Ils permettront de les proposer aux applications qui souhaitent les exploiter afin de fournir des propositions pertinentes au cours de la recherche. Nous devons construire un fichier texte pour les applications de bureau ainsi qu'un fichier Javascript pour les applications Web clientes.

Mais avant cela, comme toujours, nous devons décharger les objets dont nous n'avons plus besoin afin de libérer les ressources.

• Revenir dans l'éditeur de code VBA Excel (ALT + F11),
• Après la boucle parcourant l'ensemble des fichiers contenus dans le sous dossier, soit après l'instruction Next chaque_fichier, ajouter les affectations suivantes :

Set flux_lecture = Nothing
Set le_dossier = Nothing
Set fichier = Nothing

Grâce au mot clé Set, nous réinitialisons chacune des trois variables objet. En les affectant à Nothing, nous les détruisons et donc, nous les vidons de la mémoire.

Ensuite, comme nous l'avait appris la formation VBA Excel pour importer et exporter des données, nous devons exploiter l'instruction Open en mode écriture, afin de créer les deux fichiers externes.

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

Open ThisWorkbook.Path & "\consolidation\mem_cherche.txt" For Output As #1
Print #1, memoire
Close #1

Open ThisWorkbook.Path & "\consolidation\mem_cherche.js" For Output As #1
Print #1, "function mots_cles()" & Chr(13) & "{" & Chr(13) & Chr(9) & "var chaine='" & memoire & "';" & Chr(13) & Chr(9) & "return chaine;" & Chr(13) & "}"
Close #1

memoire = ""

Nous débutons par la création du fichier texte. Nous désignons son chemin d'accès complet juste après l'instruction Open. Nous le nommons arbitrairement (mem_cherche.txt). Nous y accédons en écriture (For Output). Cette méthode permet de créer le fichier s'il n'existe pas et d'écraser son contenu s'il existe. Nous lui attribuons une adresse mémoire libre (As #1). Tout accès séquentiel se réalise en mémoire. C'est à la fermeture que les données sont inscrites sur le disque dur, plus précisément dans le fichier désigné. L'instruction Print permet alors d'écrire l'information qui lui est passée en paramètre, soit la chaîne des mots clés concaténés (memoire). Cette inscription se réalise bien dans la RAM, c'est la raison pour laquelle nous accompagnons l'instruction Print du numéro d'allocation sur lequel agir. Une fois l'inscription terminée, nous libérons la mémoire par l'instruction Close. C'est elle qui déclenche l'écriture physique.

Nous faisons de même pour la consolidation des informations dans le fichier Javascript (mem_cherche.js). La différence ici est que nous construisons une fonction (function mots_cles()) qui mémorise ces mots clés dans une variable (var chaine=) pour les retourner (return chaine), lorsqu'elle est appelée par un code Javascript d'une page Web cliente. Vous notez l'emploi de la fonction VBA Chr qui permet de simuler des actions clavier, comme le retour chariot (13) et la tabulation (9). Enfin, nous prenons soin de vider la variable mémoire (memoire = "") qui était chargée de nombreuses données, afin de libérer les ressources. Il ne reste plus qu'à tester pour vérifier la présence des deux fichiers.

• Enregistrer les modifications (CTRL + S) et basculer sur la feuille du classeur Excel (ALT + F11),
• Cliquer sur le bouton Récolter pour déclencher de nouveau le code Visual Basic,
• Une fois le traitement terminé, dans le dossier de décompression, double cliquer sur le sous dossier Consolidation,

Vous y notez effectivement la présence des deux fichiers créés par le code VBA.



Les deux sont parfaitement construits et nous avons donc rempli la mission de ce premier volet. Tel un code serveur, notre application Visual Basic Excel a récolté et consolidé les données externes afin de fabriquer les outils nécessaires à la mise en oeuvre de la saisie semi-automatique. Il s'agit de la réalisation que nous traiterons dans le prochain volet sur la base de ces travaux.

Le code complet qui a permi de parcourir l'ensemble des fichiers de cache pour consolider l'information, est le suivant :

Sub traiter_cache()
Dim nom_dossier As String: Dim fichier As Object
Dim le_dossier, chaque_fichier: Dim flux_lecture
Dim ligne As Integer: Dim expression As String
Dim memoire As String: Dim le_fichier As String
Dim contenu As String: Dim ligne_texte As String

nom_dossier = ThisWorkbook.Path & "\cache\"
ligne = 5

Set fichier = CreateObject("scripting.filesystemobject")
Set le_dossier = fichier.getfolder(nom_dossier)
Set flux_lecture = CreateObject("ADODB.Stream")

For Each chaque_fichier In le_dossier.Files
expression = Replace(Replace(chaque_fichier.Name, ".txt", ""), "-", " ")
expression = LTrim(expression)
expression = RTrim(expression)

If (InStr(memoire, expression) = 0) Then
le_fichier = nom_dossier & chaque_fichier.Name
contenu = ""

flux_lecture.Charset = "utf-8"
flux_lecture.Open
flux_lecture.LoadFromFile (le_fichier)
contenu = flux_lecture.ReadText()
flux_lecture.Close

If (InStr(contenu, "Nous n'avons pas trouvé") = 0 And InStr(contenu, "logos/") = 0) Then
memoire = memoire + "|" + expression
Cells(ligne, 2).Value = expression
Cells(ligne, 3).Value = Round(FileLen(le_fichier) / 1024, 1)

Dim chaine_tab() As String
chaine_tab = Split(contenu, "< img")
Cells(ligne, 4).Value = UBound(chaine_tab())
ligne = ligne + 1
End If
End If
Next chaque_fichier

Set flux_lecture = Nothing
Set le_dossier = Nothing
Set fichier = Nothing

Open ThisWorkbook.Path & "\consolidation\mem_cherche.txt" For Output As #1
Print #1, memoire
Close #1

Open ThisWorkbook.Path & "\consolidation\mem_cherche.js" For Output As #1
Print #1, "function mots_cles()" & Chr(13) & "{" & Chr(13) & Chr(9) & "var chaine='" & memoire & "';" & Chr(13) & Chr(9) & "return chaine;" & Chr(13) & "}"
Close #1

memoire = ""
End Sub