Discussion :

[pijaku]

Bonjour,

Je fais des petits tests pour vider une collection.
Avec For/Next ET Step -1 aucun souci :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
Dim i&, T#, C As Collection, N&
    N = 10000
    Set C = New Collection
    For i = 1 To N
        C.Add i, CStr(i)
    Next i
    T = Timer
    For i = N To 1 Step -1
        C.Remove i
    Next i
    Debug.Print "Vidé avec For - Next " & Timer - T

Pas de souci, si ce n'est la lenteur induite.
Autre solution qui ne pose pas de souci : Nothing :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
Dim i&, T#, C As Collection, elem, N&
    N = 10000
    Set C = New Collection
    T = Timer
    For i = 1 To N
        C.Add i, CStr(i)
    Next i
    Debug.Print "Remplit en : " & Timer - T:
    T = Timer
    Set C = Nothing
    Debug.Print "Vidé avec Nothing " & Timer - T

Là ou je ne comprend pas, c'est la logique de la boucle For Each...

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Dim i&, T#, C As Collection, elem, N&, Tb()
    N = 100
    Set C = New Collection
    For i = 1 To N
        C.Add i, CStr(i)
    Next i
    i = 0
    On Error GoTo Suite
    T = Timer
    For Each elem In C
        i = i + 1
        ReDim Preserve Tb(1 To i)
        Tb(i) = elem
        C.Remove elem
    Next
    Debug.Print "Vidé avec For Each " & Timer - T
Suite:
    Debug.Print "Planté à l'indice : " & i & " -- Nb d'éléments restants : " & C.Count
    Debug.Print Join(Tb, " - ")

Le résultat, dans la fenêtre d'exécution est :

Planté à l'indice : 40 -- Nb d'éléments restants : 61
1 - 2 - 4 - 5 - 7 - 9 - 10 - 12 - 13 - 15 - 17 - 18 - 20 - 22 - 23 - 25 - 26 - 28 - 30 - 31 - 33 - 34 - 36 - 38 - 39 - 41 - 43 - 44 - 46 - 47 - 49 - 51 - 52 - 54 - 56 - 57 - 59 - 60 - 62 - 64

Je crois comprendre cette ligne : Planté à l'indice : 40 -- Nb d'éléments restants : 61 si le nombre d'éléments est 100, il y a une cohérence.
Mais par contre :

Je prends 1 --> je le supprime ==>> il passe à 2 ok, normal
Je prends 2 --> je le supprime ==>> il passe à 4 ????
Je prends 4 --> je le supprime ==>> il passe à 5 ok, normal
Je prends 5 --> je le supprime ==>> il passe à 7 ????
Je prends 7 --> je le supprime ==>> il passe à 9 ????
Je prends 9 --> je le supprime ==>> il passe à 10 ok, normal
etc...

Voici donc mes deux questions :

1. Qu'elle logique suit donc cette boucle For Each?
2. La collection est-elle bien vidée avec Nothing (ne reste t'il vraiment rien en mémoire) ? [Parce que le temps d'exécution entre la boucle et Nothing est juste hallucinant!]

[joe.levrai]

Bonjour,

il me semble qu'un For Each avec une suppression va réagir comme de vouloir supprimer des lignes en bouclant du début au lieu de la fin ?

essaye de suivre le contenu de ta collection en pas à pas à chaque passage du Remove, tu risques d'y voir des "sauts d'indices" qui n'en sont pas réellement, et un plantage survenant au moment où tu interrogeras un Elem dépassant la limite de ta collection.

Appliquer Nothing à un objet, c'est effectivement le vider totalement de la mémoire, un petit visu des variables locales sur la ligne où tu Nothing la collection te le montrera quand tu exécuteras la ligne en question

[pijaku]

Bonjour Joe,

Merci de ta réponse.
Suivre en pas à pas, c'est ce que j'ai fait.
J'ai en effet observé des "sauts d'indice".
Effectivement, le Remove plante quand l'indice à supprimer n'existe plus.
Tout cela, je l'avais bien compris.

Ce que je ne comprends pas c'est la logique de ces "sauts d'indice".

1 - 2 - 4 - 5 - 7 - 9 - 10 - 12 - 13 - 15 - 17 - 18 - 20 - 22 - 23 - 25 - 26 - 28 - 30 - 31 - 33 - 34 - 36 - 38 - 39 - 41 - 43 - 44 - 46 - 47 - 49 - 51 - 52 - 54 - 56 - 57 - 59 - 60 - 62 - 64

La logique de suppression qui saute une ligne sur deux, je comprends (boucler de la fin au début pour éviter cela), mais dans la boucle For Each, je ne comprends pas la logique...

1 - 2 [saut] 4 - 5 [saut] 7 [saut] 9 - 10 [saut] 12 - 13 [saut] 15 [saut] 17 - 18 [saut] 20 [saut] 22 - 23 [saut] 25 - 26 [saut] 28 [saut] 30 - 31 [saut] 33 - 34 [saut] 36 [saut]
38 - 39 [saut] 41 [saut] 43 - 44 [saut] 46 - 47 [saut] 49 [saut] 51 - 52 [saut] 54 [saut] 56 - 57 [saut] 59 - 60 [saut] 62 [saut] 64

EDITH : pour :

petit visu des variables locales sur la ligne où tu Nothing la collection

[patricktoulon]

re
@franck

d'apres toi que fait tu dans ta ligne
c.remove elem dans une boucle for each?????

pour t'en rendre compte il te suffit de faire un debug.print i & "--" & elem dans ta boucle

c'est exactement pareil qu'avec un dico

c.remove index pas sa valeur hors elem est sa valeur et donc ton goto suite fait sauter ton debug et passe a la suivante

n'oublie pas aussi que l'index du premier est zer0

for each elem ---->>>>elem donne la valeur

[Invité]

Bonjour,
dans ton exemple tu ajoute n ligne à ta collection si c'est l'équivalent du Clear que tu veux !voila!

Code Clear :

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

1
2
3
4
5
6
7
 N = 10000
Set C = New Collection
    For i = 1 To N
        C.Add i, CStr(i)
    Next i
    T = Timer
Set C = New Collection

[patricktoulon]

regarde ce que donne le debug a chaque tour valide
ton code tel qu'el avec un debug

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
Sub test3()
Dim i&, T#, C As Collection, elem, N&, Tb()
    N = 100
    Set C = New Collection
    For i = 1 To N
        C.Add i, CStr(i)
    Next i
    i = 0
    On Error GoTo Suite
    T = Timer
    For Each elem In C
        i = i + 1
        Debug.Print i & "---" & elem
        ReDim Preserve Tb(1 To i)
        Tb(i) = elem
        C.Remove elem
    Next
    Debug.Print "Vidé avec For Each " & Timer - T
Suite:
    Debug.Print "Planté à l'indice : " & i & " -- Nb d'éléments restants : " & C.Count
    Debug.Print Join(Tb, " - ")
End Sub

c'est pas plus compliqué que cela

[pijaku]

Mea Culpa, je me suis mal fait comprendre.

Bonjour à tous,

Merci de m'avoir retrouvé ici...

Je sais "delete" une collection :

Code :

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

1
2
3
Private Sub CollDelete(C As Collection)
    Set C = Nothing
End Sub

Je sais également "clear" une collection :

Code :

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

1
2
3
Private Sub CollDelete(C As Collection)
    Set C = New Collection
End Sub

Je sais supprimer un à un le contenu d'une collection :

Code :

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

1
2
3
4
5
6
Private Sub VideColl(C As Collection)
Dim i&
    For i = C.Count To 1 Step -1
        C.Remove i
    Next i
End Sub

Ce que je ne comprends pas (et je sais que c'est totalement farfelu ET inutile), c'est la logique des "sauts" dans le For Each avec Remove...

[patricktoulon]

c'est logique
le remove est en fin condition donc a chaque retour de goto un sur deux est pris sauf que comme je te l'ai montré avec le debug l'index "I" ne correspond pas a la valeur de elem et donc c(i) ne correspond pas a elem
voila tout

en gros tu ne peux pas faire c.remove elem comme un dico car tu incrémente ton " I" avec une condition donc des que c'est décalé(a partir du 2)

tu passe par goto suite forcement tout le temps

[patricktoulon]

re

Code :

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

1
2
3
4
5
6
7
8
x=round(rnd*100)
For Each elem In C
        i = i + 1
        Debug.Print i & "---" & elem
        ReDim Preserve Tb(1 To i)
        Tb(i) = elem
       if i=x then  C.Remove elem
    Next

essaie cela dans ton code et regarde a partir de ou ca saute maintenant

[pijaku]

Bon...
Pour Remove dans un For Each, ce n'est pas compliqué, il suffit de Remove le 1er indice.

Code :

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

1
2
3
4
5
6
7
8
9
10
    Set C = New Collection
    For i = 1 To N
        C.Add "Liste " & i, "Liste " & i
    Next i
    i = 0
    t = Timer
    For Each elem In C
       C.Remove 1
    Next
    Debug.Print "Vidé avec For Each " & Timer - t & " -- " & C.Count

Mais bon, ça n'est pas cela ma question.
Je sais qu'elle n'a aucun sens, mais je voulais trouver une logique à la suite :

1 - 2 - 4 - 5 - 7 - 9 - 10 - 12 - 13 - 15 - 17 - 18 - 20 - 22 - 23 - 25 - 26 - 28 - 30 - 31 - 33 - 34 - 36 - 38 - 39 - 41 - 43 - 44 - 46 - 47 - 49 - 51 - 52 - 54 - 56 - 57 - 59 - 60 - 62 - 64

[Invité]

tu peux identifier un collection par sa position ordinal comme une cellule excel cells(1,1) ou par son nom range("A1")

si tu supprime par la position ordinale l’item 2 devient le 1!

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Private Sub test()Set C = New Collection
    For i = 1 To 10
        C.Add "Liste " & i, "Liste " & i
    Next i
    i = 0
    t = Timer
    i = 1
    For Each elem In C
       C.Remove "Liste " & i
       i = i + 1
    Next
    Debug.Print "Vidé avec For Each " & Timer - t & " -- " & C.Count
 
 
End Sub

[pijaku]

si tu supprime par la position ordinale l’item 2 devient le 1!

Ok.
Cela explique pourquoi l'on passe de 1 à 2 puis de 2 à 4.
Mais cela n'explique toujours pas le passage de 13 à 15, de 15 à 17 et de 17 à 18...
C'est cette "irrégularité régulière" que je trouve particulière.

[Invité]

il faut faire le rapprochement avec excel le ForEach fait une incrémentation ordinale donc tu saute des items! for i =count to 1 step -1!

ce qui explique ton besoin du On Error.

regard avec un dictionaire (Set MonDico = CreateObject("Scripting.Dictionary"))

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
Sub test()
Dim i&, T#, C As Collection, elem, N&, Tb()
Dim MonDico As Object
Set MonDico = CreateObject("Scripting.Dictionary")
    N = 100
    Set C = New Collection
    For i = 1 To N
        C.Add i, CStr(i)
        MonDico(i) = i
    Next i
    i = 0
   ' On Error GoTo Suite
    T = Timer
    tb2 = MonDico.items
    Set MonDico = Nothing
    For Each elem In C
        i = i + 1
        ReDim Preserve Tb(1 To i)
        Tb(i) = elem
        C.Remove elem
    Next
    Debug.Print "Vidé avec For Each " & Timer - T
Suite:
    Debug.Print "Planté à l'indice : " & i & " -- Nb d'éléments restants : " & C.Count
    Debug.Print Join(Tb, " - ")
End Sub

[joe.levrai]

Moi aussi ça me turlupine ce saut irrégulier "régulier" comme tu l'appelles

Le Step répond à un pattern en trois temps comme tu l'as bien montré, il n'est pas uniforme, on ne va pas de deux en deux à chaque tour de boucle

Mais je n'ai aucune idée de la raison

[Invité]

en fait c'est logique le ForEach avance inexorablement donc tu atein la fin de la collection avant le ForEach !

[joe.levrai]

Je ne remet pas en cause cet effet parfaitement logique, que j'avais aussi souligné à ma première intervention

Le fait est que ça avance, certes, inexorablement ... mais l'avancement n'est pas régulier
Un tour au "saute" un élement, le tour d'après on en saute pas etc...

Pourquoi donc la régularité est relative (plusieurs pattern) et pas absolue (saut identique à chaque tour)

[pijaku]

en fait c'est logique le ForEach avance inexorablement donc tu atein la fin de la collection avant le ForEach !

Mais ça on est tous d'accord.
Joe m'a, je crois, compris.
Regarde le résultat de :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Sub test()
Dim i&, C As Collection, elem, N&, Tb()
    N = 30
    Set C = New Collection
    For i = 1 To N
        C.Add i, CStr(i)
    Next i
    i = 0
   On Error GoTo Suite
    For Each elem In C
        i = i + 1
        ReDim Preserve Tb(1 To i)
        Tb(i) = elem
        C.Remove elem
    Next
Suite:
    Debug.Print Join(Tb, " - ")
End Sub

Ca nous donne :

1 - 2 - 4 - 5 - 7 - 9 - 10 - 12 - 13 - 15 - 17 - 18 - 20

Si lorsque deux nombres se suivent on inscrit un oui, s'ils ne se suivent pas on inscrit non, je ne comprends pas pourquoi on obtient 1 oui, 1 non, 1 oui, 2 non en boucle :

1-2 oui
2-4 non
4-5 oui
5-7 non
7-9 non
9-10 oui
10-12 non
12-13 oui
13-15 non
15-17 non
17-18 oui
18-20 non

[Invité]

Code :

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

1
2
 C.Remove elem
 Debug.Print "Item" & i, "Valeur" & elem, "C.Remove:= " & C(elem)

[joe.levrai]

C'est comme si un tour de boucle ne "push" pas les indices de la collection, et le suivant fait le job

on saute
on saute pas
on saute
on saute pas


un peu tiré par les cheveux, mais c'est la seule explication que je trouve

[Invité]

non on ne saute pas on remonte les valeurs d'une ligne et comme on passe a la suivante...

elem garde une copie de la ligne supprimée!
c(1)=1;c(2)=2
c.remove elem
elem=1; c(elem)=2 (Position ordinale!)

prends un dictionnaire qui ne gère pas la position ordinale!

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
Sub test()Dim i&, T#, C As Collection, elem, N&, Tb()
Dim MonDico As Object
Set MonDico = CreateObject("Scripting.Dictionary")
    N = 100
    Set C = New Collection
    For i = 1 To N
 
        MonDico(i) = i
    Next i
    i = 0
'    On Error GoTo Suite
    T = Timer
    tb2 = MonDico.items
    'Set MonDico = Nothing
    For Each elem In MonDico
        i = i + 1
        ReDim Preserve Tb(1 To i)
        Tb(i) = elem
        MonDico.Remove elem
    Next
    Debug.Print "Vidé avec For Each " & Timer - T
Suite:
 
    Debug.Print Join(Tb, " - ")
End Sub