Twitter iPhone pliant OnePlus 11 PS5 Disney+ Orange Livebox Windows 11

Optimisation de mon code SVP ?

15 réponses
Avatar
Pascal
Bien le bonjour,
je cherche à optimiser cette partie de mon code
sachant que LstMotAnalyser est variable 18.000 pour un mot de 8 lettres et
plus au dessus
et que le champ à vérifier de la base Access en contient 18.059(pour un mot
de 8 lettres) et 20.000 pour un mot de 10 lettres
cela ne pose pas trop de problème tant que longueurMot = 6, a 8 cela traine
et pour un mot de 10, je peux partir faire mes courses!
j'avais penser à une requête ACCESS, mais ne connait pas suffisament que
pour mettre en place!
si KKun a une idée, voir une très bonne!, serai sympa de m'éclairer
bien à tous
Pascal


'-------------------------------------------------------------------------------------------
'défini le dico à ouvrir
Dim longueurMot As Byte
'prend la longueur du mot
longueurMot = Len(LstMotAnalyser.List(0))
'ouvre la base Access et la table coorespondante
Set db = DAO.Workspaces(0).OpenDatabase(MA_BASE_ACCESS, False,
False)

'compare les mots avec le Dico
' ouverture d 'une requête sur la table
Set rs = db.OpenRecordset("select*from[" & longueurMot & "];", ,
dbForwardOnly)

For f = 0 To Me.LstMotAnalyser.ListCount - 1
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value,
UCase(LstMotAnalyser.List(f))) > 0 Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If
'passe au suivant
rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
'repositionne l'index sur le premier
rs.MoveFirst
Next f
'referme la requete proprement
rs.Close
End Sub
'-------------------------------------------------------------------------------------------

10 réponses

1 2
Avatar
Christian Hugoud
Hi,

D'abord : Dim longueurMot As Byte devient Dim longueurMot As Long

Dim MotAnalyser as string

Ensuite :


For f = 0 To Me.LstMotAnalyser.ListCount - 1
MotAnalyser = UCase(LstMotAnalyser.List(f)) 'tu ne scrutes
plus la liste à chaque boucle
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value, MotAnalyser ) > 0 Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If

rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
rs.MoveFirst
Next f

Essaies déjà cela...

Christian

"Pascal" a écrit dans le message de news:

Bien le bonjour,
je cherche à optimiser cette partie de mon code
sachant que LstMotAnalyser est variable 18.000 pour un mot de 8 lettres et
plus au dessus
et que le champ à vérifier de la base Access en contient 18.059(pour un
mot de 8 lettres) et 20.000 pour un mot de 10 lettres
cela ne pose pas trop de problème tant que longueurMot = 6, a 8 cela
traine et pour un mot de 10, je peux partir faire mes courses!
j'avais penser à une requête ACCESS, mais ne connait pas suffisament que
pour mettre en place!
si KKun a une idée, voir une très bonne!, serai sympa de m'éclairer
bien à tous
Pascal


'-------------------------------------------------------------------------------------------
'défini le dico à ouvrir
Dim longueurMot As Byte
'prend la longueur du mot
longueurMot = Len(LstMotAnalyser.List(0))
'ouvre la base Access et la table coorespondante
Set db = DAO.Workspaces(0).OpenDatabase(MA_BASE_ACCESS, False,
False)

'compare les mots avec le Dico
' ouverture d 'une requête sur la table
Set rs = db.OpenRecordset("select*from[" & longueurMot & "];",
, dbForwardOnly)

For f = 0 To Me.LstMotAnalyser.ListCount - 1
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value,
UCase(LstMotAnalyser.List(f))) > 0 Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If
'passe au suivant
rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
'repositionne l'index sur le premier
rs.MoveFirst
Next f
'referme la requete proprement
rs.Close
End Sub
'-------------------------------------------------------------------------------------------



Avatar
Pascal
Hello Christian
merci pour ta réponse
mais Dim LongueurMOt ne dépasse JAMAIS 15 donc byte est bien approprié!
pour MotAnalyser j'aurai pu y penser, bien vu
merci à toi
Pascal

"Christian Hugoud" a écrit dans le message de news:

Hi,

D'abord : Dim longueurMot As Byte devient Dim longueurMot As Long

Dim MotAnalyser as string

Ensuite :


For f = 0 To Me.LstMotAnalyser.ListCount - 1
MotAnalyser = UCase(LstMotAnalyser.List(f)) 'tu ne scrutes
plus la liste à chaque boucle
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value, MotAnalyser ) > 0 Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If

rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
rs.MoveFirst
Next f

Essaies déjà cela...

Christian

"Pascal" a écrit dans le message de news:

Bien le bonjour,
je cherche à optimiser cette partie de mon code
sachant que LstMotAnalyser est variable 18.000 pour un mot de 8 lettres
et plus au dessus
et que le champ à vérifier de la base Access en contient 18.059(pour un
mot de 8 lettres) et 20.000 pour un mot de 10 lettres
cela ne pose pas trop de problème tant que longueurMot = 6, a 8 cela
traine et pour un mot de 10, je peux partir faire mes courses!
j'avais penser à une requête ACCESS, mais ne connait pas suffisament que
pour mettre en place!
si KKun a une idée, voir une très bonne!, serai sympa de m'éclairer
bien à tous
Pascal


'-------------------------------------------------------------------------------------------
'défini le dico à ouvrir
Dim longueurMot As Byte
'prend la longueur du mot
longueurMot = Len(LstMotAnalyser.List(0))
'ouvre la base Access et la table coorespondante
Set db = DAO.Workspaces(0).OpenDatabase(MA_BASE_ACCESS, False,
False)

'compare les mots avec le Dico
' ouverture d 'une requête sur la table
Set rs = db.OpenRecordset("select*from[" & longueurMot & "];",
, dbForwardOnly)

For f = 0 To Me.LstMotAnalyser.ListCount - 1
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value,
UCase(LstMotAnalyser.List(f))) > 0 Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If
'passe au suivant
rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
'repositionne l'index sur le premier
rs.MoveFirst
Next f
'referme la requete proprement
rs.Close
End Sub
'-------------------------------------------------------------------------------------------







Avatar
Christian Hugoud
Oui, mais il faut que microprocesseur convertisse ton byte en long, dans
tous les cas. Il semblerait que ce soit plus rapide de travailler avec des
long, toujours.

"Pascal" a écrit dans le message de news:

Hello Christian
merci pour ta réponse
mais Dim LongueurMOt ne dépasse JAMAIS 15 donc byte est bien approprié!
pour MotAnalyser j'aurai pu y penser, bien vu
merci à toi
Pascal

"Christian Hugoud" a écrit dans le message de
news:
Hi,

D'abord : Dim longueurMot As Byte devient Dim longueurMot As Long

Dim MotAnalyser as string

Ensuite :


For f = 0 To Me.LstMotAnalyser.ListCount - 1
MotAnalyser = UCase(LstMotAnalyser.List(f)) 'tu ne scrutes
plus la liste à chaque boucle
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value, MotAnalyser ) > 0 Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If

rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
rs.MoveFirst
Next f

Essaies déjà cela...

Christian

"Pascal" a écrit dans le message de news:

Bien le bonjour,
je cherche à optimiser cette partie de mon code
sachant que LstMotAnalyser est variable 18.000 pour un mot de 8 lettres
et plus au dessus
et que le champ à vérifier de la base Access en contient 18.059(pour un
mot de 8 lettres) et 20.000 pour un mot de 10 lettres
cela ne pose pas trop de problème tant que longueurMot = 6, a 8 cela
traine et pour un mot de 10, je peux partir faire mes courses!
j'avais penser à une requête ACCESS, mais ne connait pas suffisament que
pour mettre en place!
si KKun a une idée, voir une très bonne!, serai sympa de m'éclairer
bien à tous
Pascal


'-------------------------------------------------------------------------------------------
'défini le dico à ouvrir
Dim longueurMot As Byte
'prend la longueur du mot
longueurMot = Len(LstMotAnalyser.List(0))
'ouvre la base Access et la table coorespondante
Set db = DAO.Workspaces(0).OpenDatabase(MA_BASE_ACCESS, False,
False)

'compare les mots avec le Dico
' ouverture d 'une requête sur la table
Set rs = db.OpenRecordset("select*from[" & longueurMot &
"];", , dbForwardOnly)

For f = 0 To Me.LstMotAnalyser.ListCount - 1
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value,
UCase(LstMotAnalyser.List(f))) > 0 Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If
'passe au suivant
rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
'repositionne l'index sur le premier
rs.MoveFirst
Next f
'referme la requete proprement
rs.Close
End Sub
'-------------------------------------------------------------------------------------------










Avatar
Pascal
Ah bon! je ne savais pas cela
merci pour l'info!
pour motanalyser, je gagne un petit peu en vitesse même en ajoutant:
If InStr(1, rs.Fields(1).Value, MotAnalyser ) > 0 Then
LstMotCompatible.AddItem MotAnalyser <--------
mais pas suffisament pour un mot de 10 ou 15 lettres.
j'avais penser, (dis-moi si c'est une erreur)
plustôt que d'ouvrir chaque fois la table appropriée, n'en faire qu'une
seule avec l'inconvenient qu'elle sera plus importante à parcourir. Des fois
que l'on gagnerai en vitesse ouverture/fermeture table?

Bien à toi
Pascal



"Christian Hugoud" a écrit dans le message de news:

Oui, mais il faut que microprocesseur convertisse ton byte en long, dans
tous les cas. Il semblerait que ce soit plus rapide de travailler avec des
long, toujours.

"Pascal" a écrit dans le message de news:

Hello Christian
merci pour ta réponse
mais Dim LongueurMOt ne dépasse JAMAIS 15 donc byte est bien approprié!
pour MotAnalyser j'aurai pu y penser, bien vu
merci à toi
Pascal

"Christian Hugoud" a écrit dans le message de
news:
Hi,

D'abord : Dim longueurMot As Byte devient Dim longueurMot As Long

Dim MotAnalyser as string

Ensuite :


For f = 0 To Me.LstMotAnalyser.ListCount - 1
MotAnalyser = UCase(LstMotAnalyser.List(f)) 'tu ne scrutes
plus la liste à chaque boucle
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value, MotAnalyser ) > 0
Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If

rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
rs.MoveFirst
Next f

Essaies déjà cela...

Christian

"Pascal" a écrit dans le message de news:

Bien le bonjour,
je cherche à optimiser cette partie de mon code
sachant que LstMotAnalyser est variable 18.000 pour un mot de 8 lettres
et plus au dessus
et que le champ à vérifier de la base Access en contient 18.059(pour un
mot de 8 lettres) et 20.000 pour un mot de 10 lettres
cela ne pose pas trop de problème tant que longueurMot = 6, a 8 cela
traine et pour un mot de 10, je peux partir faire mes courses!
j'avais penser à une requête ACCESS, mais ne connait pas suffisament
que pour mettre en place!
si KKun a une idée, voir une très bonne!, serai sympa de m'éclairer
bien à tous
Pascal


'-------------------------------------------------------------------------------------------
'défini le dico à ouvrir
Dim longueurMot As Byte
'prend la longueur du mot
longueurMot = Len(LstMotAnalyser.List(0))
'ouvre la base Access et la table coorespondante
Set db = DAO.Workspaces(0).OpenDatabase(MA_BASE_ACCESS, False,
False)

'compare les mots avec le Dico
' ouverture d 'une requête sur la table
Set rs = db.OpenRecordset("select*from[" & longueurMot &
"];", , dbForwardOnly)

For f = 0 To Me.LstMotAnalyser.ListCount - 1
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value,
UCase(LstMotAnalyser.List(f))) > 0 Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If
'passe au suivant
rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
'repositionne l'index sur le premier
rs.MoveFirst
Next f
'referme la requete proprement
rs.Close
End Sub
'-------------------------------------------------------------------------------------------














Avatar
Christian Hugoud
Je ne pense pas car en fait, tu vas juste récupérer l'accès au pointeur.
Faut essayer...

Peut être le InsStr est long ?

"Pascal" a écrit dans le message de news:

Ah bon! je ne savais pas cela
merci pour l'info!
pour motanalyser, je gagne un petit peu en vitesse même en ajoutant:
If InStr(1, rs.Fields(1).Value, MotAnalyser ) > 0 Then
LstMotCompatible.AddItem MotAnalyser <--------
mais pas suffisament pour un mot de 10 ou 15 lettres.
j'avais penser, (dis-moi si c'est une erreur)
plustôt que d'ouvrir chaque fois la table appropriée, n'en faire qu'une
seule avec l'inconvenient qu'elle sera plus importante à parcourir. Des
fois que l'on gagnerai en vitesse ouverture/fermeture table?

Bien à toi
Pascal



"Christian Hugoud" a écrit dans le message de
news:
Oui, mais il faut que microprocesseur convertisse ton byte en long, dans
tous les cas. Il semblerait que ce soit plus rapide de travailler avec
des long, toujours.

"Pascal" a écrit dans le message de news:

Hello Christian
merci pour ta réponse
mais Dim LongueurMOt ne dépasse JAMAIS 15 donc byte est bien approprié!
pour MotAnalyser j'aurai pu y penser, bien vu
merci à toi
Pascal

"Christian Hugoud" a écrit dans le message de
news:
Hi,

D'abord : Dim longueurMot As Byte devient Dim longueurMot As Long

Dim MotAnalyser as string

Ensuite :


For f = 0 To Me.LstMotAnalyser.ListCount - 1
MotAnalyser = UCase(LstMotAnalyser.List(f)) 'tu ne
scrutes plus la liste à chaque boucle
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value, MotAnalyser ) > 0
Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If

rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
rs.MoveFirst
Next f

Essaies déjà cela...

Christian

"Pascal" a écrit dans le message de news:

Bien le bonjour,
je cherche à optimiser cette partie de mon code
sachant que LstMotAnalyser est variable 18.000 pour un mot de 8
lettres et plus au dessus
et que le champ à vérifier de la base Access en contient 18.059(pour
un mot de 8 lettres) et 20.000 pour un mot de 10 lettres
cela ne pose pas trop de problème tant que longueurMot = 6, a 8 cela
traine et pour un mot de 10, je peux partir faire mes courses!
j'avais penser à une requête ACCESS, mais ne connait pas suffisament
que pour mettre en place!
si KKun a une idée, voir une très bonne!, serai sympa de m'éclairer
bien à tous
Pascal


'-------------------------------------------------------------------------------------------
'défini le dico à ouvrir
Dim longueurMot As Byte
'prend la longueur du mot
longueurMot = Len(LstMotAnalyser.List(0))
'ouvre la base Access et la table coorespondante
Set db = DAO.Workspaces(0).OpenDatabase(MA_BASE_ACCESS, False,
False)

'compare les mots avec le Dico
' ouverture d 'une requête sur la table
Set rs = db.OpenRecordset("select*from[" & longueurMot &
"];", , dbForwardOnly)

For f = 0 To Me.LstMotAnalyser.ListCount - 1
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value,
UCase(LstMotAnalyser.List(f))) > 0 Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If
'passe au suivant
rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
'repositionne l'index sur le premier
rs.MoveFirst
Next f
'referme la requete proprement
rs.Close
End Sub
'-------------------------------------------------------------------------------------------

















Avatar
Pascal
hello,
oui, InsStr est de type Variant (long)
le fait de passer de byte à Long, je gagne effectivement 4/10 secondes sur
l'ensemble(test fait sur mot de 8 lettres)
Autre idée: du fait d'une base ACCESS, je pourrai créer une requête dans la
base et faire appel à celle-ci à partir de VB6! mais comment ajouter le
résultat de ma requête dans un ListView?

Après, je n'ennuie plus personne avec cela!

Bien à toi
Pascal


"Christian Hugoud" a écrit dans le message de news:
%
Je ne pense pas car en fait, tu vas juste récupérer l'accès au pointeur.
Faut essayer...

Peut être le InsStr est long ?

"Pascal" a écrit dans le message de news:

Ah bon! je ne savais pas cela
merci pour l'info!
pour motanalyser, je gagne un petit peu en vitesse même en ajoutant:
If InStr(1, rs.Fields(1).Value, MotAnalyser ) > 0 Then
LstMotCompatible.AddItem MotAnalyser <--------
mais pas suffisament pour un mot de 10 ou 15 lettres.
j'avais penser, (dis-moi si c'est une erreur)
plustôt que d'ouvrir chaque fois la table appropriée, n'en faire qu'une
seule avec l'inconvenient qu'elle sera plus importante à parcourir. Des
fois que l'on gagnerai en vitesse ouverture/fermeture table?

Bien à toi
Pascal




Avatar
Pascal
Re, Re, Re
ai pu encore gagner environ 6,2 secondes en déplacant
LstMotAnalyser.ListIndex = f qui était mal placé
je l'ai mis après le loop.....
mais toujours pas suffisant pour des mots supérieur à 7 lettres, GRRRRRRRR

Bat
Pascal

"Pascal" a écrit dans le message de news:

hello,
oui, InsStr est de type Variant (long)
le fait de passer de byte à Long, je gagne effectivement 4/10 secondes
sur l'ensemble(test fait sur mot de 8 lettres)
Autre idée: du fait d'une base ACCESS, je pourrai créer une requête dans
la base et faire appel à celle-ci à partir de VB6! mais comment ajouter le
résultat de ma requête dans un ListView?

Après, je n'ennuie plus personne avec cela!

Bien à toi
Pascal


"Christian Hugoud" a écrit dans le message de
news: %
Je ne pense pas car en fait, tu vas juste récupérer l'accès au pointeur.
Faut essayer...

Peut être le InsStr est long ?

"Pascal" a écrit dans le message de news:

Ah bon! je ne savais pas cela
merci pour l'info!
pour motanalyser, je gagne un petit peu en vitesse même en ajoutant:
If InStr(1, rs.Fields(1).Value, MotAnalyser ) > 0 Then
LstMotCompatible.AddItem MotAnalyser <--------
mais pas suffisament pour un mot de 10 ou 15 lettres.
j'avais penser, (dis-moi si c'est une erreur)
plustôt que d'ouvrir chaque fois la table appropriée, n'en faire qu'une
seule avec l'inconvenient qu'elle sera plus importante à parcourir. Des
fois que l'on gagnerai en vitesse ouverture/fermeture table?

Bien à toi
Pascal







Avatar
François Picalausa
On Oct 9, 1:06 pm, "Pascal" wrote:
Bien le bonjour,
je cherche à optimiser cette partie de mon code


<snip>
If InStr(1, rs.Fields(1).Value,
UCase(LstMotAnalyser.List(f))) > 0 Then


<snip>


Hello,

Je n'ai pas suivi l'entièreté de la discussion, mais néanmoins, je
pense que l'article suivant de la faq pourait t'être utile:
http://faq.vb.free.fr/index.php?question7

François Picalausa
Avatar
Pascal
merci, je planche la dessus
B à Toi
Pascal

"François Picalausa" a écrit dans le message de news:

On Oct 9, 1:06 pm, "Pascal" wrote:
Bien le bonjour,
je cherche à optimiser cette partie de mon code


<snip>
If InStr(1, rs.Fields(1).Value,
UCase(LstMotAnalyser.List(f))) > 0 Then


<snip>


Hello,

Je n'ai pas suivi l'entièreté de la discussion, mais néanmoins, je
pense que l'article suivant de la faq pourait t'être utile:
http://faq.vb.free.fr/index.php?question7

François Picalausa
Avatar
Serial # 19781010
On Tue, 9 Oct 2007 20:22:29 +0200, "Pascal"
wrote:

hello,
oui, InsStr est de type Variant (long)
le fait de passer de byte à Long, je gagne effectivement 4/10 secondes sur
l'ensemble(test fait sur mot de 8 lettres)
Autre idée: du fait d'une base ACCESS, je pourrai créer une requête dans la
base et faire appel à celle-ci à partir de VB6! mais comment ajouter le
résultat de ma requête dans un ListView?



J'inclurais la sélection dans la requête (pas la peine de ramener
toute la table pour chaque mot cherché). Il faudrait aussi indexer le
champ recherché dans chaque table de la base Access. Quelque chose
comme ça en supposant que le champ sur lequel porte la recherche soit
nommé "mot" :


Sub Main()

Dim db As DataBase
Dim sMotFind As String
Dim f As Long
Dim sSql As String
Dim longueurMot As Long
Dim rs As RecordSet

longueurMot = Len(LstMotAnalyser.List(0))
Set db = DAO.Workspaces(0).OpenDatabase(MA_BASE_ACCESS, False,
False)

For f = 0 To LstMotAnalyser.ListCount - 1
sMotFind = LstMotAnalyser.List(f)
sMotFind = Replace(sMotFind, "'", "''")
sSql ="select mot from [" & longueurMot & "] where mot like '" &
sMotFind & "*';"
Set rs = db.OpenRecordset(sSql,dbForwardOnly)
RstToList rs, LstMotCompatible
Next f

rs.Close
Set rs = Nothing
db.Close
Set db = Nothing

End Sub

Private Function RstToList(rs As RecordSet, lst As ListBox)

Do While Not rs.EOF
lst.AddItem rs.Filed("mot")
rs.MoveNext
Loop

End Function


Ceci dit, j'ai l'impression que tu cherches un mot de n lettres dans
une table ne contenant que des mots de n lettres. Auquel cas la clause
where pourrait même se simplifier en "where mot ='" & sMotFind & "';"
(ce qui serait plus rapide et plus besoin de parcourir le recordset
dans ce cas : s'il est vide le mot n'existe pas, sinon il existe et on
l'ajoute à la liste). D'autre part, on pourrait aussi grouper
plusieurs critères dans chaque requête.
1 2