J'avais lu quelques part que l'utilisation du "do" était plus efficace en
temps machine que du "for each", est-ce vrai?? J'ai testé ceux-ci et pour
l'instant, je n'y vois aucune différence, le temps écoulé pour le traitement
est le meme.
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Zazar
Bonjour,
J'avais lu quelques part que l'utilisation du "do" était plus efficace en temps machine que du "for each", est-ce vrai?? J'ai testé ceux-ci et pour l'instant, je n'y vois aucune différence, le temps écoulé pour le
traitement
est le meme.
Dans le cas d'un parcours d'un ArrayList (par exemple) avec une boucle for ou une boucle Do : Le temps d'initialisation est quasiment nul : (initilialisation d'une variable à 0). Le temps d'accés à un élément est minimal (on ne peut pas faire mieux) Le temps de passage à l'élement suivant est égal au temps d'effectuer un test puis une incrémentation
Dans le cas d'une boucle foreach : Lors de l'initialisation, il faut appeler une méthode qui crée un nouvel objet (ça prend un peu de temps et ça consomme un peu de mémoire). Pour accéder à un élément, on appelle une méthode qui va : tester si l'objet courant existe ou non : 1 appel de méthode et 1 comparaison puis fournir l'objet courant (mis en cache lors d'un appel à MoveNext()) Pour passer à l'élément suivant, on appelle une méthode qui teste si la collection a été modifiée, puis qui teste si on est à la fin de la collection, et qui met en cache le nouvel objet courant (temps d'accés minimal égal à celui de l'étape 2 d'une boucle for).
Conclusion : dans une utilisation standard, une boucle for effectue moins d'opération qu'une boucle foreach, mais à part la création de l'objet lors de l'initialisation (qui n'a donc lieu qu'une seule fois) les opérations supplémentaires sont donc assez rapides. Donc, oui une boucle do loop est plus rapide qu'une boucle foreach, et selon la méthode de test, la différence peut ne pas apparaître.
-- Zazar
Bonjour,
J'avais lu quelques part que l'utilisation du "do" était plus efficace en
temps machine que du "for each", est-ce vrai?? J'ai testé ceux-ci et pour
l'instant, je n'y vois aucune différence, le temps écoulé pour le
traitement
est le meme.
Dans le cas d'un parcours d'un ArrayList (par exemple) avec une boucle for
ou une boucle Do :
Le temps d'initialisation est quasiment nul : (initilialisation d'une
variable à 0).
Le temps d'accés à un élément est minimal (on ne peut pas faire mieux)
Le temps de passage à l'élement suivant est égal au temps d'effectuer un
test puis une incrémentation
Dans le cas d'une boucle foreach :
Lors de l'initialisation, il faut appeler une méthode qui crée un nouvel
objet (ça prend un peu de temps et ça consomme un peu de mémoire).
Pour accéder à un élément, on appelle une méthode qui va : tester si l'objet
courant existe ou non : 1 appel de méthode et 1 comparaison puis fournir
l'objet courant (mis en cache lors d'un appel à MoveNext())
Pour passer à l'élément suivant, on appelle une méthode qui teste si la
collection a été modifiée, puis qui teste si on est à la fin de la
collection, et qui met en cache le nouvel objet courant (temps d'accés
minimal égal à celui de l'étape 2 d'une boucle for).
Conclusion : dans une utilisation standard, une boucle for effectue moins
d'opération qu'une boucle foreach, mais à part la création de l'objet lors
de l'initialisation (qui n'a donc lieu qu'une seule fois) les opérations
supplémentaires sont donc assez rapides. Donc, oui une boucle do loop est
plus rapide qu'une boucle foreach, et selon la méthode de test, la
différence peut ne pas apparaître.
J'avais lu quelques part que l'utilisation du "do" était plus efficace en temps machine que du "for each", est-ce vrai?? J'ai testé ceux-ci et pour l'instant, je n'y vois aucune différence, le temps écoulé pour le
traitement
est le meme.
Dans le cas d'un parcours d'un ArrayList (par exemple) avec une boucle for ou une boucle Do : Le temps d'initialisation est quasiment nul : (initilialisation d'une variable à 0). Le temps d'accés à un élément est minimal (on ne peut pas faire mieux) Le temps de passage à l'élement suivant est égal au temps d'effectuer un test puis une incrémentation
Dans le cas d'une boucle foreach : Lors de l'initialisation, il faut appeler une méthode qui crée un nouvel objet (ça prend un peu de temps et ça consomme un peu de mémoire). Pour accéder à un élément, on appelle une méthode qui va : tester si l'objet courant existe ou non : 1 appel de méthode et 1 comparaison puis fournir l'objet courant (mis en cache lors d'un appel à MoveNext()) Pour passer à l'élément suivant, on appelle une méthode qui teste si la collection a été modifiée, puis qui teste si on est à la fin de la collection, et qui met en cache le nouvel objet courant (temps d'accés minimal égal à celui de l'étape 2 d'une boucle for).
Conclusion : dans une utilisation standard, une boucle for effectue moins d'opération qu'une boucle foreach, mais à part la création de l'objet lors de l'initialisation (qui n'a donc lieu qu'une seule fois) les opérations supplémentaires sont donc assez rapides. Donc, oui une boucle do loop est plus rapide qu'une boucle foreach, et selon la méthode de test, la différence peut ne pas apparaître.
-- Zazar
David Bouchard
Merci de ta réponse
"Zazar" a écrit dans le message de news:
Bonjour,
> J'avais lu quelques part que l'utilisation du "do" était plus efficace
en
> temps machine que du "for each", est-ce vrai?? J'ai testé ceux-ci et
pour
> l'instant, je n'y vois aucune différence, le temps écoulé pour le traitement > est le meme.
Dans le cas d'un parcours d'un ArrayList (par exemple) avec une boucle for ou une boucle Do : Le temps d'initialisation est quasiment nul : (initilialisation d'une variable à 0). Le temps d'accés à un élément est minimal (on ne peut pas faire mieux) Le temps de passage à l'élement suivant est égal au temps d'effectuer un test puis une incrémentation
Dans le cas d'une boucle foreach : Lors de l'initialisation, il faut appeler une méthode qui crée un nouvel objet (ça prend un peu de temps et ça consomme un peu de mémoire). Pour accéder à un élément, on appelle une méthode qui va : tester si
l'objet
courant existe ou non : 1 appel de méthode et 1 comparaison puis fournir l'objet courant (mis en cache lors d'un appel à MoveNext()) Pour passer à l'élément suivant, on appelle une méthode qui teste si la collection a été modifiée, puis qui teste si on est à la fin de la collection, et qui met en cache le nouvel objet courant (temps d'accés minimal égal à celui de l'étape 2 d'une boucle for).
Conclusion : dans une utilisation standard, une boucle for effectue moins d'opération qu'une boucle foreach, mais à part la création de l'objet lors de l'initialisation (qui n'a donc lieu qu'une seule fois) les opérations supplémentaires sont donc assez rapides. Donc, oui une boucle do loop est plus rapide qu'une boucle foreach, et selon la méthode de test, la différence peut ne pas apparaître.
-- Zazar
Merci de ta réponse
"Zazar" <DILAVNI.nicolas.prats@iie.cnam.fr.INVALID> a écrit dans le message
de news:eEWUMCriEHA.344@TK2MSFTNGP10.phx.gbl...
Bonjour,
> J'avais lu quelques part que l'utilisation du "do" était plus efficace
en
> temps machine que du "for each", est-ce vrai?? J'ai testé ceux-ci et
pour
> l'instant, je n'y vois aucune différence, le temps écoulé pour le
traitement
> est le meme.
Dans le cas d'un parcours d'un ArrayList (par exemple) avec une boucle for
ou une boucle Do :
Le temps d'initialisation est quasiment nul : (initilialisation d'une
variable à 0).
Le temps d'accés à un élément est minimal (on ne peut pas faire mieux)
Le temps de passage à l'élement suivant est égal au temps d'effectuer un
test puis une incrémentation
Dans le cas d'une boucle foreach :
Lors de l'initialisation, il faut appeler une méthode qui crée un nouvel
objet (ça prend un peu de temps et ça consomme un peu de mémoire).
Pour accéder à un élément, on appelle une méthode qui va : tester si
l'objet
courant existe ou non : 1 appel de méthode et 1 comparaison puis fournir
l'objet courant (mis en cache lors d'un appel à MoveNext())
Pour passer à l'élément suivant, on appelle une méthode qui teste si la
collection a été modifiée, puis qui teste si on est à la fin de la
collection, et qui met en cache le nouvel objet courant (temps d'accés
minimal égal à celui de l'étape 2 d'une boucle for).
Conclusion : dans une utilisation standard, une boucle for effectue moins
d'opération qu'une boucle foreach, mais à part la création de l'objet lors
de l'initialisation (qui n'a donc lieu qu'une seule fois) les opérations
supplémentaires sont donc assez rapides. Donc, oui une boucle do loop est
plus rapide qu'une boucle foreach, et selon la méthode de test, la
différence peut ne pas apparaître.
> J'avais lu quelques part que l'utilisation du "do" était plus efficace
en
> temps machine que du "for each", est-ce vrai?? J'ai testé ceux-ci et
pour
> l'instant, je n'y vois aucune différence, le temps écoulé pour le traitement > est le meme.
Dans le cas d'un parcours d'un ArrayList (par exemple) avec une boucle for ou une boucle Do : Le temps d'initialisation est quasiment nul : (initilialisation d'une variable à 0). Le temps d'accés à un élément est minimal (on ne peut pas faire mieux) Le temps de passage à l'élement suivant est égal au temps d'effectuer un test puis une incrémentation
Dans le cas d'une boucle foreach : Lors de l'initialisation, il faut appeler une méthode qui crée un nouvel objet (ça prend un peu de temps et ça consomme un peu de mémoire). Pour accéder à un élément, on appelle une méthode qui va : tester si
l'objet
courant existe ou non : 1 appel de méthode et 1 comparaison puis fournir l'objet courant (mis en cache lors d'un appel à MoveNext()) Pour passer à l'élément suivant, on appelle une méthode qui teste si la collection a été modifiée, puis qui teste si on est à la fin de la collection, et qui met en cache le nouvel objet courant (temps d'accés minimal égal à celui de l'étape 2 d'une boucle for).
Conclusion : dans une utilisation standard, une boucle for effectue moins d'opération qu'une boucle foreach, mais à part la création de l'objet lors de l'initialisation (qui n'a donc lieu qu'une seule fois) les opérations supplémentaires sont donc assez rapides. Donc, oui une boucle do loop est plus rapide qu'une boucle foreach, et selon la méthode de test, la différence peut ne pas apparaître.
