Différences et comparaison des performances entre les boucles foreach et while

foreach et while sont tous deux des boucles en php, alors quelle est la différence entre foreach et while loop ? Laissez-moi vous présenter la différence entre les boucles foreach et while

 ? .

Dans une boucle while, Perl lit une ligne d'entrée, la stocke dans une variable et exécute le corps de la boucle. Ensuite, il revient pour trouver d'autres lignes d'entrée.

Dans la boucle foreach, toute la ligne de l'opérateur input

sera exécutée dans le contexte de la liste (car le foreach doit traiter le contenu de la liste ligne par ligne). Avant que la boucle puisse commencer à s'exécuter, elle doit lire toutes les entrées.

Lors de la saisie de fichiers de grande capacité, l'utilisation de foreach occupera beaucoup de mémoire. La différence entre les deux sera très évidente. Par conséquent, la meilleure approche consiste généralement à utiliser le raccourci pendant une boucle while et à le laisser traiter une ligne à la fois.

Lorsque vous souhaitez exécuter de manière répétée certaines instructions ou certains paragraphes, C# propose 4 options d'instructions de boucle différentes que vous pouvez utiliser en fonction des différentes tâches en cours :
. pour la déclaration
. déclaration foreach
. while déclaration

. do instruction

1. for

L'instruction for est particulièrement utile lorsque vous savez à l'avance combien de fois une instruction contenue doit être exécutée. La syntaxe régulière permet aux instructions internes (et aux expressions de boucle

) d'être exécutées à plusieurs reprises lorsque la condition est vraie :

for (initialisation; condition; boucle) instruction interne

Notez que l'initialisation, les conditions et les boucles sont toutes facultatives. Si vous omettez la condition, vous pouvez créer une boucle infinie qui nécessite une instruction jump (break ou goto) pour sortir.

for (;;)
{
   break; // 由于某些原因
}

Un autre point important est que vous pouvez ajouter plusieurs instructions séparées par des virgules aux trois paramètres de la boucle for

en même temps. Par exemple, vous pouvez initialiser deux variables, avoir trois conditions et répéter 4 variables.

2.foreach

Une fonctionnalité qui existe depuis longtemps dans le langage Visual Basic est la collection d'énumérations à l'aide de l'instruction For Each. C# dispose également d'une commande pour collecter des énumérations via l'instruction foreach :

foreach (identifiant de type dans l'expression) L'instruction incluse

les variables de boucle sont déclarées par type et identifiant, et les expressions correspondent aux collections. La variable de boucle représente l'élément de collection pour lequel la boucle est en cours d'exécution.

3.while

Lorsque vous souhaitez exécuter une instruction incluse 0 fois ou plus, l'instruction while est exactement ce que vous voulez :

while (condition) Inline Statement

L'instruction conditionnelle - qui est également une expression booléenne - contrôle le nombre de fois que l'instruction incluse est exécutée. Vous pouvez utiliser les instructions break et continue pour contrôler l'exécution des instructions dans une instruction while, qui fonctionne exactement de la même manière que dans une instruction for.

4,do

La dernière instruction de boucle disponible en C# est l'instruction do. Elle est très similaire à une instruction while dans la mesure où la condition n'est vérifiée qu'après la boucle initiale.

do
{
内含语句
}
while (条件);

L'instruction do garantit que les instructions contenues ont été exécutées au moins une fois et qu'elles continuent d'être exécutées tant que la condition est évaluée comme vraie. En utilisant l'instruction break, vous pouvez forcer l'exécution à quitter le bloc do. Si vous souhaitez ignorer cette boucle, utilisez l'instruction continue.

Comparaison des performances

Foreach opère sur une copie du tableau (en copiant le tableau), tandis que while fonctionne en déplaçant l'index interne du tableau. De manière générale, on pense que while devrait. être plus rapide que foreach (car foreach copie d'abord le tableau lorsqu'il commence à s'exécuter, tandis que while déplace directement le pointeur interne), mais le résultat est tout le contraire.

Ce qui est fait dans la boucle est une opération de "lecture" de tableau, donc foreach est plus rapide que while :

foreach ($array as $value) { 
echo $value; 
} 
while (list($key) = each($array)) { 
echo $array[$key]; 
}

Ce qui est fait dans la boucle est une opération "d'écriture" de tableau, puis while est plus rapide que foreach :

foreach ($array as $key => $value) { 
echo $array[$key] = $value . '...'; 
} 
while (list($key) = each($array)) { 
$array[$key] = $array[$key] . '...'; 
}

Testons d'abord le temps nécessaire pour parcourir un tableau unidimensionnel

avec 50 000 indices :

<?php
/*
  * @ Author: Lilov
  * @ Homepage: www.111cn.net
  * @ E-mail: zhongjiechao@gmail.com
  *
  */
$arr = array();
for($i = 0; $i < 50000; $i++){
$arr[] = $i*rand(1000,9999);
}
function GetRunTime()
{
list($usec,$sec)=exp lode(" ",microtime());
return ((float)$usec+(float)$sec);
}
######################################
$time_start = GetRunTime();
for($i = 0; $i < count($arr); $i++){
$str .= $arr[$i];
}
$time_end = GetRunTime();
$time_used = $time_end - $time_start;
echo &#39;Used time of for:&#39;.round($time_used, 7).&#39;(s)<br><br>&#39;;
unset($str, $time_start, $time_end, $time_used);
######################################
$time_start = GetRunTime();
while(list($key, $val) = each($arr)){
$str .= $val;
}
$time_end = GetRunTime();
$time_used = $time_end - $time_start;
echo &#39;Used time of while:&#39;.round($time_used, 7).&#39;(s)<br><br>&#39;;
unset($str, $key, $val, $time_start, $time_end, $time_used);
######################################
$time_start = GetRunTime();
foreach($arr as $key => $val){
$str .= $val;
}
$time_end = GetRunTime();
$time_used = $time_end - $time_start;
echo &#39;Used time of foreach:&#39;.round($time_used, 7).&#39;(s)<br><br>&#39;;
######################################
?>

Résultats des tests :

Moyenne des trois résultats de tests :
correspond respectivement à for, while et foreach
0,1311650
0,1666853

0,1237440

Après des tests répétés, les résultats montrent que for Lors du parcours du même tableau, foreach est le plus rapide et while est le plus lent. foreach est environ 20 à 30 % plus rapide que while. Ajoutez ensuite l'indice du tableau à 500 000 et 5 000 000 et le résultat du test est le même. Mais d'un point de vue principe, foreach opère sur une copie du tableau (en copiant le tableau), tandis que while opère en déplaçant l'index interne du tableau. De manière générale, on pense que while devrait être plus rapide que foreach (car). foreach exécute d'abord le tableau (le tableau est copié, tandis que while déplace directement le pointeur interne), mais le résultat est tout le contraire. La raison devrait être que foreach est une implémentation interne de PHP, tandis que while est une structure de boucle générale.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!