Discussion :

[droliprane]

Bonjour à tous, je vous soumets un problème tout bête, que je peux certainement résoudre via une fonction pas très performante, mais je me demande s'il n'existerait pas une fonction WinDev ou une ruse de sioux qui me permettrait d'optimiser cela.

En fait je veux réduire une chaine qui peut potentiellement contenir des espaces consécutifs (dans la chaine et non à ses extrémités) à une même chaine réduite avec des espaces simples.

Exemple : 'A B C D' serait réduit à 'A B C D'

A part faire un replace(chaine, " ", " ") tant qu'il y a des remplacements, que pourrait-on écrire de plus élégant ?

Merci à vous

[serendib]

En quoi n'est-ce point élégant ?

[droliprane]

hé bien certainement qu'avec une expression régulière on pourrait faire mieux non ?

je ne suis pas fortiche pour composer une expression régulière, mais si on était capable de dire "tu me remplace toutes les séquences de n espaces, n >= 2, par un espace unique" je pense que ce serait plus élégant, et de complexité algorithmique moindre

[serendib]

Penses à DateVersChaine()
C'est peut-être plus élégant (à la lecture du code) que de le coder soit-même,
mais le résultat est le même.
Pourquoi crois-tu que le framework de windev soit aussi énorme ?

[droliprane]

je développe un peu le besoin : je mets au point les modules d'importation de données en provenance d'une vieille gpao appelée à être remplacée par mon programme
Et dans cette vieille gpao en mode texte, les gens ont introduit des espaces en veux-tu en voilà pour aligner les désignations à l'impression
Là je récupère ces champs textes, et je veux les nettoyer avant de les injecter dans ma base
Et des articles par exemple, j'en ai plus de 8 000, donc faire une petite moulinette de remplacement d'espaces, 8 000 fois, c'est long !
Donc si j'ai la possibilité de diviser le temps par deux, je le ferai

[serendib]

Tu écris un petit algo qui transforme une date en chaine.
Et tu testes :
Dateverschaine() sur 8000 enregistrements.
Ton petit algo sur les même 8000 enr.
Tu verras.

[Hemgé]

Et des articles par exemple, j'en ai plus de 8 000, donc faire une petite moulinette de remplacement d'espaces, 8 000 fois, c'est long !

Bonjour,

Au lieu d'appeler la fonction WDdePCsoft_retire_espaces_internes, faites appel à la procédure globale bvadam_StripInternal_Multiples_Char(Chaîne_à_nettoyer, caractère_à_retirer), laquelle offrira plus de flexibilité puisqu'on pourra choisir le caractère, voire la chaîne dont la répétition doit être supprimée.

Vous développez une fois votre moulinette et vous l'avez pour toujours.
Après cela, vous l'appelez une fois dans votre routine d'import-conversion, où elle tournera 8.000 fois.

Avec Position() et ChaineOccurence() ou les expressions régulières.

Allez, courage !

Hemgé

Psttt : quand vous l'aurez testée, vous pouvez toujours la publier. Déjà merci.

[droliprane]

Ce n'est pas une question de courage, il n'y a aucune difficulté à écrire ce genre de fonction. Mais vraiment j'aurais cru que ce serait possible avec un regexp, et nettement plus performant. Merci néanmoins ;-)

[jurassic pork]

hello,
voici un exemple pour enlever les espaces superflus en regexp. Je n'utilise pas le VérifierExpressionRégulière de windev qui me semble bien limité mais l'objet COM Vbscript.regexp.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
regEx est un objet Automation "VBScript.RegExp"
sourceStr est une chaîne = "Ceci              est       un                                       test  pour enlever les     espaces superflus               entre les         mots."
retStr est une chaîne
regEx>>Pattern = "[ ]{2,}"
regEx>>IgnoreCase=Vrai
regEx>>Global = Vrai
regEx>>MultiLine = Vrai
Trace(regEx>>Replace(sourceStr," "))

Ami calmant, J.P

[droliprane]

Un grand merci jurassic pork.

Je pensais bien que tu interviendrais !!!

[serendib]

Certes, mais d'une part je ne vois pas bien en quoi c'est "plus élégant".
D'autre part je ne suis pas convaincu que ce soit plus performant.
A vérifier.

[Hemgé]

Bonjour,

Nous attendions tous jurassic porc et l'objet COM Vbscript.regexp.

Mais il y a moyen de le faire avec un peu de WLangage dont VérifieExpressionRégulière.
Tout le problème vient du fait que VérifieExpressionRégulière ne connaît pas la recherche globale et s'arrête dès qu'il a trouvé une première correspondance.

Deux solutions :

Soit on connaît le nombre de sous-chaînes "espace(s)", quel que soit le nombre d'espaces dans ces sous-chaînes, càd qu'il y a une règle au départ et qu'il y a juste une incohérence ou un manque de contrôle sur le nombre d'espaces qui sont insérés. On peut générer une expression régulière avec répétition d'un motif pour matcher le tout.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
tabExtrait est un tableau de 0 chaînes 
sRésultat est une chaîne 
sExposé est une chaîne = " 123aaa 456bbb    789ccc   111ddd 000"
nSpace est un entier = 4 //nombre de sous-chaînes "espace" à l'exclusion du début et de la fin, soit 4 pour sExposé
sRegMask est une chaîne 
 
sRegMask = "[ ]*" + Répète("([0-9a-zA-Z]+)[ ]*", nSpace + 1) + "[ ]*" 
SI VérifieExpressionRégulière(sExposé, sRegMask, tabExtrait) ALORS 
	sRésultat = TableauVersChaîne(tabExtrait, " ") 
	Trace("/" + sRésultat +"/") 
FIN

Soit on ne connaît pas le nombre de ces sous-chaînes ou on préfère rester plus générique et il faut gérer une boucle dans la quelle on extrait progressivement toutes les sous-chaînes encadrées par des espaces, étant entendu que la première peut ne pas être précédée par un espace et la dernière peut ne pas en être suivie (càd avec ou sans espace initial et terminal)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
tabExtrait est un tableau de 0 chaînes 
sRésultat est une chaîne 
sExposé est une chaîne = " 123aaa 456bbb    789ccc   111ddd 000"
sRegMask est une chaîne 
sRes1 est une chaîne
 
TANTQUE VérifieExpressionRégulière(sExposé,"[ ]*([0-9a-zA-Z]+)(.*)", sRes1,sExposé) 
	TableauAjoute(tabExtrait, sRes1) 
FIN
sRésultat = TableauVersChaîne(tabExtrait, " ") 
Trace("/" + sRésultat +"/")

Quant à l'élégance, ... que signifie-t-elle pour l'un ou pour l'autre ?
S'il s'agit de compacité ou de 'génie', il faut aussi s'assurer qu'on pourra se relire dans 5 ans et qu'un collègue pourra comprendre ce code assez rapidement.
Personnellement, dans cette perspective, j'ai tendance à renoncer aux codes trop ramassés et très cryptiques (même si structurés), pour des codes plus aérés et avec une structure plus lisible.

L'utilisateur n'a pas accès à notre code et se préoccupera surtout de sa compacité, de sa rapidité, de sa maintenabilité et de sa vitesse d'exécution. (on ne parle pas de l'IHM ici)
Donc, je ferais tourner les 3 solutions proposées jusqu'à présent en comparant les temps d'exécution.
Je serais curieux de comparer une quatrième solution plus "classique", car je ne parierais pas nécessairement sur la vélocité des moteurs d'analyse d'expressions régulières.

Bonne journée

Hemgé

[droliprane]

Bonjour hemgé,

désolé de ne pas avoir fait de retour sur vos propositions, on m'a sollicité sur un autre projet, alors ce sujet était un peu en standby !

Je suis dans la seconde situation, les espaces ne sont pas prévisibles, ni en nombre, ni en position.

J'ai testé votre code, ça fonctionne parfaitement, mais c'est vrai qu'on est quand même obligé de faire un tantque puisque VérifieExpressionRégulière s'arrête à la première correspondance.

J'avais vu un Java une instruction qui faisait du remplacement global dans une chaine, visiblement on n'a pas ça en WinDev, ou alors il faut se coder sa propre fonction (c'est peut-être ce qui a été fait en java)

Quant à l'élégance, c'est vrai que le client final s'en tamponne pas mal du moment que ça fonctionne, mais quand même j'aime bien optimiser quand c'est possible


Merci à vous

[tatayo]

Bonjour,
On peut faire plus simple (et peut-être plus rapide, à tester):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
sOrigine est une chaîne = " 123aaa 456bbb    789ccc   111                                                 ddd 000"
sResultat est une chaîne
sMot est une chaîne
 
POUR TOUTE CHAÎNE sMot DE sOrigine SEPAREE PAR " "
	sResultat += [" "] + sMot
FIN
Trace(sResultat)

[Hemgé]

Bonjour,

A tatayo

Si vous reprenez le fil de la discussion, bvadam souhaitait une solution plus 'quelque chose', de là la discussion sur l'élégance.
Il avait évoqué les expressions régulières et il lui avait été rétorqué que Windev classique, malgré tout ...

En fin de compte, il dispose de quatre propositions outre celle qu'il pourrait développer : 1 Regex via VBscript, 2 Regex via VérifieExpressionRégulière et 1 WL 'simple'.
Il ne lui reste plus qu'à les intégrer dans un SELON et à tester les performances comparées.

Outre Régex/pas Régex, il y a deux approches possibles du problème :
- on repère les espaces et on les gère, ce que font votre solution et celle de jurassic pork
- on extrait ce qui n'est pas un espace et on reconstruit une chaîne propre, ce que j'ai entrepris.
Cette dernière approche serait peut-être plus souple si on voulait effectuer une recherche plus générique et paramétrée, mais je n'ai aucun doute quant à la possibilité d'y arriver avec WL.

A bvadam

Pas de problème, j'ai effectivement lu que vous vous preniez langue avec Modbus.

La recherche globale s'obtient en général en terminant avec une lettre 'g' minuscule (pour global), mais apparemment non implémentée sous WL.

Maintenant, de nouveau, optimiser quoi : l'efficacité du code ou la simplicité de sa lecture ?
L'efficacité du code est à tester. Si vous vous y attelez, ce serait assurément intéressant.
L'efficacité en lecture m'apparaît meilleure ou plus générale avec la solution WL 'simple' de Tatayo, puis avec mes deux propositions, la solution VBscript n'étant ps accessible à quiconque ne connaît pas ce langage.

De toute façon, toutes les solutions proposées finissent par faire du balayage de la chaîne, le tout est de savoir comment et si c'est massif ou incrémental.

Dans le même état d'esprit, je réfléchirais deux fois à incorporer une solution faisant appel aux expressions régulières pour quiconque n'y a jamais touché et se sent incapable de les corriger/adapter si un problème survenait ou une modification s'imposait.
A ce niveau du code, il me semble en effet qu'il ne faut implémenter que du code que l'on peut faire évoluer.

Bon travail

Hemgé