Il ya 10 ans
Juste une note sur l'utilisation de l'instruction continue pour renoncer au reste d'une boucle - assurez-vous que vous "n'émettez pas l'instruction continue à partir d'un cas SWITCH - cela ne continuera pas la boucle while, mais plutôt l'instruction switch elle-même.
Bien que cela puisse sembler évident pour certains, cela m'a pris un peu de test, alors j'espère que cela aidera quelqu'un d'autre.
il y a 5 ans
C'est étrange que le manuel précise...
"Parfois, si l'expression while est évaluée à FALSE dès le début, la ou les instructions imbriquées ne seront même pas exécutées une seule fois. "
Parce que ça ne peut pas être PARFOIS
S'il se comporte de cette façon, alors c'est un bogue, car il ne doit TOUJOURS pas exécuter la ou les instructions imbriquées même une fois si l'expression WHILE est évaluée à FALSE dès le début.
Une autre façon de quitter la boucle while est d'utiliser l'instruction BREAK .. voir dans le manuel.
Et si l'expression vaut NULL est la même que FALSE
while (expression vaut NULL) ()
il y a 14 ans
Juste une note pour stuart - la raison de ce comportement est que l'utilisation de la construction while (valeur = chaque (tableau)) incrémente le compteur interne du tableau au fur et à mesure qu'il est parcouru. Par conséquent, si vous avez l'intention de répéter la boucle, vous devez réinitialiser le compteur. par exemple:
$ un = tableau ("10", "20", "30", "40");
$ deux = tableau ("a", "b", "c", "d");
$ i = 0 ;
tandis que ($ je< count($one)) {
réinitialiser (2 $);
tandis que ($ a = chacun ($ deux)) (
echo $ a. "-". $ un [$ i]. ",";
}
$ je ++;
a - 10, b - 10, c - 10, d - 10, a - 20, b - 20, c - 20, d - 20, a - 30, b - 30, c - 30, d - 30, a - 40, b - 40, c - 40, d - 40,
il y a 15 ans
Alors que peut faire des merveilles si vous avez besoin de quelque chose pour mettre en file d'attente l'écriture dans un fichier alors que quelque chose d'autre y a accès.
Voici mon exemple simple :
Fonction write ($ data, $ file, $ write_mode = "w") (
$ verrou = $ fichier. ".fermer à clé";
// exécute le correctif d'écriture, pour arrêter les conflits qui peuvent se produire
write_fix ($ verrou);
// crée un nouveau fichier de verrouillage après write_fix () pour cette session d'écriture
toucher ($ verrouiller);
// écris dans ton fichier
$ open = fopen ($ file, $ write_mode);
fwrite ($ ouvert, $ données);
fclose ($ ouvert) ;
// tue votre verrou actuel
dissocier ($ verrouiller) ;
}
Fonction write_fix ($ lock_file) (
while (file_exists ($ lock_file) (
// faire quelque chose ici ?
// peut-être dormir quelques microsecondes
// pour maintenir la stabilité, si cela doit
// prendre un certain temps ??
}
}
?>
Cette méthode n'est pas recommandée pour une utilisation avec des programmes qui auront besoin de quelques bonnes secondes pour écrire dans un fichier, car la fonction while consommera beaucoup de cycles de processus. Cependant, cette méthode fonctionne et est facile à mettre en œuvre. Il regroupe également les fonctions d'écriture en une seule fonction facile à utiliser, ce qui facilite la vie. :-)
il y a 17 ans
À la fin de la boucle while (list / each) le pointeur de tableau sera à la fin.
Cela signifie que la deuxième boucle while de ce tableau sera ignorée !
Vous pouvez remettre le pointeur de tableau avec la fonction reset ($ myArray).
$ monTableau = tableau ("aa", "bb", "cc", "dd");
réinitialiser ($ myArray);
while (list ($ key, $ val) = each ($ myArray)) echo $ val;
?>
Il y a 7 ans
Au lieu de cet usage ;
$ arr = array ("orange", "banane", "pomme", "framboise");
$ i = 0 ;
tandis que ($ je<
count
($arr
)) {
$ a = $ arr [$ i] ;
echo $ a. "\n" ;
$ je ++;
}
// ou
$ i = 0 ;
$ c = compte ($ arr);
tandis que ($ je<
$c
) {
$ a = $ arr [$ i] ;
echo $ a. "\n" ;
$ je ++;
}
?>
Cela pourrait être plus efficace;
while ($ a = $ arr [1 * $ i ++]) echo $ a. "\n" ;
?>
il y a 16 ans
J'ai fait un test en traversant un tableau (tableau numérique simple mais long avec des touches numériques). Mon test comportait un cycle par méthode et multipliait chaque élément du tableau par 100. Voici mes résultats :
******************************************************
30870 Parcours de matrice d'éléments
0.2373 seg plus tard -> while (list ($ key, $ val) = each ($ array)) FIN
0,1916 segment plus tard -> while (list ($ key,) = each ($ array)) FIN
0.1714 seg plus tard -> foreach ($ array AS $ key => $ value) FIN
0,0255 seg plus tard -> while ($ next = next ($ array)) FIN
0,1735 seg plus tard -> foreach (tableau $ AS valeur $) FIN
**************************************************************
foreach est plus gros qu'un certain temps (liste - chacun), vrai.
Cependant, un moment (suivant) était plus rapide que foreach.
Voici les codes gagnants :
$ array = $ save;
heure_test ("", 1);
foreach ($ array AS $ key => $ value)
test_time ("foreach (\ $ array AS \ $ key => \ $ value)");
$ array = $ save;
heure_test ("", 1);
réinitialiser (tableau $);
while ($ suivant = suivant ($ tableau))
($ clé = clé ($ tableau);
$ array [$ key] = $ array [$ key] * 100;
}
test_time ("while (\ $ next = next (\ $ array))");
*********************************************************
L'amélioration semble énorme, mais ce n'est pas si dramatique dans la pratique réelle. Les résultats ont varié... J'ai un très long tableau bidimensionnel et je n'ai pas vu plus de 2 secondes de différence, mais sur des scripts de plus de 140 secondes. Notez cependant que vous perdez le contrôle de la valeur de la clé $ (à moins que vous n'ayez des touches numériques, ce que j'ai tendance à éviter), mais ce n'est pas toujours nécessaire.
Je m'en tiens généralement à foreach. Cependant, cette fois, j'obtenais des erreurs de taille de mémoire autorisée dépassée avec Apache. N'oubliez pas que foreach copie le tableau d'origine, ce qui fait maintenant deux énormes tableaux 2D en mémoire et beaucoup de travail pour Apache. Si vous obtenez cette erreur, vérifiez vos boucles. N'utilisez pas l'ensemble du tableau sur un foreach. Au lieu de cela, obtenez les clés et accédez directement aux cellules. Essayez également d'utiliser unset et le référencement sur les énormes tableaux.
Travailler sur votre tableau et vos boucles est une bien meilleure solution de contournement que d'enregistrer dans des tables temporaires et de supprimer (beaucoup plus lent).
il y a 14 ans
Le speedtest est intéressant. Mais le moyen apparemment le plus rapide contient un écueil pour les débutants qui l'utilisent simplement car c'est rapide et rapide c'est cool ;)
Parcourir un tableau avec next() coupera la première entrée, car c'est ainsi que next() fonctionne ;)
Si vous devez vraiment procéder de cette façon, assurez-vous que votre tableau contient une entrée vide au début. Une autre façon serait d'utiliser
while ($ this = courant ($ tableau)) (
do_something ($ this);
suivant ($ tableau) ;
}
?>
Il y a un impact sur la vitesse c'est sûr mais je ne l'ai pas testé. Je conseillerais de m'en tenir aux méthodes conventionnelles car les boucles current (), next () dans while sont trop sujettes aux erreurs pour moi.
il y a 4 ans
Une façon sympa de continuer à évaluer quelque chose jusqu'à ce qu'il échoue à un test.
tandis que (vrai) (
si ("test") ( // la condition initiale est vraie
// faire quelque chose qui change aussi la condition initiale
) else (// la condition a échoué
Pause; // quitte la boucle
}
}
?>
il y a 4 ans
Programme de modèle pyramidal simple utilisant la boucle while
$ i = 1 ;
tandis que ($ je<=
5
)
{
$j = 1 ;
tandis que ($ j<=
$i
)
{
echo "* & nbsp & nbsp" ;
$j++;
}
écho "
"
;
$ je ++;
}
?>
// ou bien vous pouvez utiliser :
$ i = 1 ;
tandis que ($ je<=
5
):
$j = 1 ;
tandis que ($ j<=
$i
):
echo "* & nbsp & nbsp" ;
$j++;
à la fin ;
Écho "
"
;
$ je ++;
à la fin ;
?>
il y a 11 ans
En raison du fait que php n'interprète que les éléments nécessaires pour obtenir un résultat, j'ai trouvé pratique de concaténer différentes requêtes SQL en une seule instruction :
$ q1 = "une requête sur un ensemble de tables";
$ q2 = "requête similaire sur un autre ensemble de tables";
if (($ r1 = mysql_query ($ q1)) && ($ r2 = mysql_query ($ q2))) (
Tandis que (($ row = mysql_fetch_assoc ($ r1)) || ($ row = mysql_fetch_assoc ($ r2))) (
/ * faire quelque chose avec $ row provenant de $ r1 et $ r2 * /
}
}
?>
il y a 3 ans
// test While Vs For php 5.6.17
$ t1 = microtemps (vrai);
$a = 0 ;
tandis que ($ a ++<=
1000000000
);
$ t2 = microtemps (vrai);
$ x1 = $ t2 - $ t1 ;
echo PHP_EOL, "> tandis que ($ a ++<= 100000000); : "
, $ x1, "s", PHP_EOL;
$ t3 = microtime (vrai);
pour ($ a = 0; $ a<=
1000000000
;
$a
++);
$ t4 = microtemps (vrai);
$ x2 = $ t4 - $ t3 ;
echo PHP_EOL, "> pour ($ a = 0; $ a<= 100000000;$a++); : "
, $ x2, "s", PHP_EOL;
$ t5 = microtemps (vrai);
$a = 0 ; pour (; $ a ++<=
1000000000
;);
$ t6 = microtemps (vrai);
$ x3 = $ t6 - $ t5 ;
echo PHP_EOL, "> $ a = 0; pour (; $ a ++<= 100000000;); : "
, $ x3, "s", PHP_EOL;
//> while ($ a ++<= 100000000); = 18.509671926498s
//> pour ($ a = 0; $ a<= 100000000;$a++); = 25.450572013855s
//> $a = 0; pour (; $ a ++<= 100000000;); = 22.614907979965s
// ===================
//> while ($ a ++! = 100000000); : 18.204656839371s
//> pour ($ a = 0; $ a! = 100000000; $ a ++); : 25.025605201721s
//> $a = 0; pour (; $ a ++! = 100000000;); : 22.340576887131s
// ===================
//> while ($ a ++< 100000000); : 18.383454084396s
//> pour ($ a = 0; $ a< 100000000;$a++); : 25.290743112564s
//> $a = 0; pour (; $ a ++< 100000000;); : 23.28609919548s
?>
il y a 16 ans
C'est un moyen facile pour tous les créateurs de calculatrices de faire des factorielles. Le code est celui-ci :
$ c = ($ a - 1);
$ d = $ a;
tandis que ($ c> = 1)
{
$ a = ($ a * $ c);
$ c - ;
}
print ("$ d! = $ a");
?>
$ a change, tout comme c, nous devons donc créer une nouvelle variable, $ d, pour l'instruction de fin.
La boucle PHP foreach peut être utilisée comme ceci :
foreach ($ array_name as $ value) (// code à exécuter)
foreach ($ array_name as $ key => $ value) (// // code à exécuter)
Exemple d'utilisation d'une boucle foreach avec un tableau numérique
Dans cet exemple, nous allons créer un tableau à cinq éléments avec des valeurs numériques. La boucle PHP foreach sera ensuite utilisée pour parcourir ce tableau. À l'intérieur de la boucle foreach, nous avons utilisé echo pour imprimer les valeurs du tableau :
Voir la démo et le code
Exemple avec des clés et des valeurs de tableau
Cet exemple décrit une autre façon d'utiliser la boucle PHP foreach. Pour cela, nous avons créé un tableau associatif de trois éléments. Il comprend les noms des employés ( comme clés) et le montant du salaire ( comme valeurs):
Voir la démo et le code
Un exemple de modification de la valeur d'un élément de tableau dans une boucle foreach
Vous pouvez également utiliser PHP array foreach pour modifier les valeurs des éléments du tableau. Pour ce faire, utilisez "&" avant "$" pour la valeur de la variable. Par exemple:
& $ value_of_element
La valeur sera modifiée. Pour que ce soit plus clair, considérons l'exemple suivant.
Dans cet exemple, nous avons créé un tableau numérique de cinq éléments. Après cela, nous avons utilisé une boucle foreach pour afficher les valeurs des éléments.
Ensuite, nous avons créé une autre boucle foreach où "&" est ajouté avant $ value_of_element. À l'intérieur des accolades, nous attribuons de nouvelles valeurs aux éléments du tableau.
Pour voir la différence avant et après l'attribution de nouvelles valeurs, le tableau est affiché à l'aide de la fonction print_r ().
Voir la démo et le code
A quoi sert la boucle PHP foreach ?
La boucle PHP foreach est utilisée pour travailler avec un tableau. Il itère sur chacun de ses éléments.
Vous pouvez également utiliser une boucle for pour travailler avec des tableaux. Par exemple, utiliser la propriété length pour obtenir la longueur d'un tableau, puis l'appliquer en tant qu'opérateur max. Mais foreach facilite les choses car il est conçu pour fonctionner avec des tableaux.
Si vous travaillez avec MySQL, ce cycle est encore plus approprié pour cela. Par exemple, vous pouvez sélectionner plusieurs lignes d'une table de base de données et les transmettre à un tableau. Après cela, à l'aide d'une boucle foreach, parcourez tous les éléments du tableau et effectuez une action.
Notez que vous pouvez utiliser une boucle foreach avec un tableau ou simplement un objet.
Utiliser une boucle foreach
Il existe deux façons d'utiliser la boucle PHP foreach en PHP. Les deux sont décrits ci-dessous.
- La syntaxe de la première méthode d'utilisation est :
foreach ($ array_name as $ value) (écho $ value)
Dans ce cas, vous devez spécifier le nom du tableau, puis la variable $ value.
Pour chaque itération, la valeur de l'élément courant est affectée à la variable valeur $. À la fin de l'itération, la variable reçoit la valeur de l'élément suivant. Et ainsi de suite jusqu'à ce que tous les éléments du tableau soient énumérés.
- La syntaxe de la deuxième méthode ( PHP foreach comme valeur clé):
Cela convient aux tableaux associatifs qui utilisent des paires clé/valeur.
Lors de chaque itération, la valeur de l'élément courant sera affectée à la variable $ value_of_element. De plus, la clé de l'élément est affectée à la variable $ key_of_element.
Si vous travaillez avec des tableaux numériques, vous pouvez utiliser la première méthode, qui ne nécessite pas de clés d'élément.
Cette publication est une traduction de l'article " PHP foreach boucle 2 façons de l'utiliser"Préparé par l'équipe sympathique du projet
La note: la version adaptative du site est activée, qui s'adapte automatiquement à la petite taille de votre navigateur et masque certains détails du site pour plus de lisibilité. Bon visionnage !
Bonjour chers lecteurs et abonnés réguliers ! Il est temps de continuer la série d'articles sur PHP et aujourd'hui, nous allons apprendre une chose aussi basique et en même temps très importante, comme les boucles. Quelle est la première chose que vous devez savoir sur les boucles ? Et le fait qu'ils soient utilisés partout et partout, et les templates Joomla, VirtueMart, Wordpress, OpenCart et tout autre CMS ne fait pas exception.
Qu'est-ce qu'un cycle ? Cycle Est une répétition multiple du même morceau de code. Le nombre de répétitions à faire dépend du compteur de cycles, que nous créons nous-mêmes et pouvons gérer. C'est très pratique, par exemple, lorsque l'on a besoin de dessiner des produits dans la catégorie d'une boutique en ligne, d'afficher des articles de blog, d'afficher des commentaires sur un article ou un produit, tous les menus des CMS (moteurs de site) sont également réalisés à l'aide de boucles. En général, les boucles sont utilisées très souvent.
Mais avant de passer aux boucles elles-mêmes, vous devez d'abord jouer avec des opérateurs incrément et décrémenter.
L'opérateur ++ (incrémenter) augmente la valeur d'une variable d'une unité, tandis que l'opérateur - (décrémenter) diminue la valeur d'une variable d'une unité. Ils sont très pratiques à utiliser en boucle comme compteur, et en programmation en général. Il existe également des incréments/décréments PRE et des incréments/décréments POST :
PRE incrément / décrément ++ $ a Incrémente $ a de un et renvoie la valeur de $ a. - $ a Diminue $ a de un et renvoie la valeur de $ a. POST incrémenter / décrémenter $ a ++ Renvoie la valeur de $ a puis incrémente $ a de un. $ a-- Renvoie la valeur de $ a, puis décrémente $ a de un.
Par exemple:
$a = 1 ; echo "Imprimer le numéro : ». $ un ++ ; // Imprimer le numéro : 1 echo "Imprimer le numéro :". $ un ; // Sortie d'un nombre : 2 echo " Sortie d'un nombre : $ a "; $ a + = 1 ; // comme sur la première ligne$a = 1 ; echo "Imprimer le numéro : ». ++ $ a; // Imprimer le numéro : 2 echo "Imprimer le numéro :". $ un ; // Affiche le nombre : 2 $ a + = 1; echo "Imprimer le numéro : $ a" ; // le même que dans la première ligne de ce bloc
Pour boucle
pour (partie A; partie B; partie C) (// N'importe quel code, autant de lignes que vous le souhaitez ;)La boucle for se compose de 3 parties et du corps lui-même. Partie A il fait simplement ce qu'il dit, en règle générale, dans 90% des cas, un compteur de boucle est créé là-bas. Partie B- ceci, grosso modo, nous est déjà familier si, c'est-à-dire vérifier vrai (vrai ?). Si la condition est vraie, c'est vrai, puis PHP entre dans la boucle et continue de l'exécuter. Partie C- la même chose que la partie A, en règle générale dans la partie C, nous effectuons une sorte de conversion avec un compteur. Par exemple:
";) echo" CHERCHEZ et avancez dans le code... ";?>
Maintenant à propos de l'algorithme de la boucle for. Tout d'abord, quand il voit pour, PHP entre dans la partie A et l'exécute une fois (voir l'image ci-dessous). PHP va alors à B et vérifie s'il y a vrai ou faux. Si vrai, alors il exécute le corps de la boucle et ensuite seulement va à la partie C. Après cela, PHP va à nouveau à la partie B et vérifie si c'est toujours vrai là-bas ou non. Sinon, la boucle se termine, si oui, continue jusqu'à ce que la partie B soit fausse.
Le résultat de l'exemple précédent :
Pendant que la boucle
while (partie B) (// N'importe quel code, autant de lignes que vous le souhaitez ;)Comme vous pouvez le voir, il n'y a pas de partie A et de partie C, il ne reste que la condition de la boucle for, c'est-à-dire la partie B. Si nous devons utiliser un compteur, nous devons le mettre à l'intérieur de la boucle while, parmi le reste du code, ce sera la partie C. le compteur est nécessaire avant le début de la construction while :
Partie A ; while (partie B) (// N'importe quel code, autant de lignes que vous le souhaitez ; Partie C ;)
Transformons la boucle for précédente en boucle while :
"; $ i ++;) echo" CHERCHEZ et passez à travers le code ... ";?>
Le résultat sera exactement le même. Quoi utiliser : une boucle for ou une boucle while est une question de goût, voyez comme c'est plus pratique et logique pour vous, il n'y a pas de différence.
Faire ... en boucle
Moins commun de tous les types de cycles. Il s'agit essentiellement d'un tout inversé. Son astuce est que PHP au moins une fois (la première), mais ira certainement dans le corps de la boucle do... while, car dans cette boucle la condition à la fin :
Partie A ; do (// N'importe quel code, autant de lignes que vous le souhaitez; Partie C;) while (Partie B);
"; $ i ++;) tandis que ($ i< 8); echo "ВЫШЛИ ИЗ ЦИКЛА и пошли дальше по коду..."; ?>
Il est important de comprendre qu'il n'y a pas de parties obligatoires dans les trois types de cycles.
Un exemple de boucle for sans partie A et partie C :
Pour (; $ i> 8;) (// votre code)
Un exemple de boucle for sans les trois parties :
Pour (;;) (// boucle infinie classique)
C'est-à-dire que tous les points-virgules restent dans la boucle for, c'est la syntaxe !
Des boucles sans fin
Une boucle infinie est une erreur de développeur dans laquelle la page ne pourra jamais se charger jusqu'à la fin, puisque la condition de boucle (partie B) sera toujours vraie. Par exemple:
"; $ i ++;) while ($ i! = 0); echo" QUITTER LE CYCLE et continuer dans le code ... ";?>
Résultat:
Je n'en ai montré qu'une partie, car tout ne tient pas sur l'écran. C'est ainsi que votre navigateur et le serveur de votre site tourmenteront sans cesse jusqu'à ce que le navigateur plante au bout de 30 secondes.C'est parce que dans l'exemple ci-dessus, la variable $ i ne sera jamais égale à zéro, elle est initialement égale à 1 et est en constante augmentation.
C'est-à-dire que le développeur était inattentif lorsqu'il a proposé une telle condition.
Contrôle de cycle
La déclaration de rupture. Il y a des situations où nous n'avons pas besoin de la boucle pour jouer toutes les itérations (répétitions). Par exemple, à un certain moment, nous voulons l'interrompre et continuer l'exécution ci-dessous dans le code :
"; if ($ i === 5) break; // quitte la boucle si $ i vaut 5 $ i ++;) echo" Je ne peux compter que jusqu'à 5 :( ";?>
Résultat:
Dans l'exemple ci-dessus, dès que nous sommes arrivés à cinq, PHP a quitté la boucle, sinon il compterait jusqu'à 7.
La déclaration continue interrompt également l'exécution de la boucle, mais contrairement à break, continue ne quitte pas la boucle, mais renvoie l'interpréteur PHP à la condition (à la partie B). Exemple:
";) echo" Vous avez raté quelque chose ? ";?>
Résultat:
Nous avons juste sauté le 5 parce que PHP n'a pas eu d'écho.
Une boucle peut être imbriquée dans une boucle. Dans ce cas, les instructions continue et break ne couvrent qu'un seul cycle, celui dans lequel elles se trouvent. C'est-à-dire qu'en d'autres termes, ils sont projetés à un niveau, et non à travers tous. Exemple:
Mais nous pouvons nous-mêmes choisir le nombre de niveaux à franchir :
"; $ i ++; $ i = 1; $ k = 1; tandis que ($ k< 8) {
echo "Итерация $k номер ". $k . "
"; if ($ k === 5) break 2; $ k ++;))?>
Résultat:
Naturellement, dans ce cas, nous ne pouvons pas mettre un nombre supérieur à nos boucles imbriquées.
Boucle Foreach
La boucle foreach est la plus récente, mais la plus importante. Utilisé par seul itérer sur et des objets (il est trop tôt pour les apprendre). Exemple de syntaxe :
"; } ?>
Résultat:
Il s'agissait d'une construction foreach courte, mais il existe également une version étendue qui, en plus des valeurs des cellules du tableau, affiche également les noms des cellules (clés):
valeur $) (écho "Dans la section ". Touche $." il y a un article qui s'appelle : ". $ valeur."
";
}
?>
Résultat:
J'attire votre attention sur le fait qu'on peut appeler des variables comme on veut, même $ key et $ value, voire $ xxx et $ yyy.
S'il s'agit d'un tableau, nous n'utilisons que la boucle foreach et aucune autre. Ce cycle est utilisé dans VirtueMart, et même partout.
Il est souvent pratique de pouvoir terminer le cycle plus tôt que prévu lorsque certaines conditions se présentent. Cette opportunité est fournie par l'instruction break. Il fonctionne avec des constructions telles que while, do while, for, foreach ou switch.
L'instruction break peut prendre un argument numérique facultatif qui lui indique le nombre de structures imbriquées à terminer. La valeur par défaut d'un argument numérique est 1, ce qui termine l'exécution de la boucle en cours. Si une instruction switch est utilisée dans une boucle, break / break 1 ne fait que quitter l'instruction switch.
\ n "; break 1; / * Sortie uniquement de l'instruction switch. * / case 10: echo" Itération 10; en quittant
\ n "; break 2; / * Sortie de la construction switch et de la boucle while. * /)) // autre exemple pour ($ bar1 = -4; $ bar1< 7; $bar1++) {
// проверка деления на ноль
if ($bar1 == 0) {
echo "Выполнение остановлено: деление на ноль невозможно.";
break;
}
echo "50/$bar1 = ",50/$bar1,"
";
}
?>
Bien sûr, vous préféreriez parfois sauter une des itérations de la boucle plutôt que de terminer la boucle complètement, auquel cas cela se fait à l'aide de l'instruction continue.
Continuez
Pour arrêter le traitement du bloc de code actuel dans le corps de la boucle et passer à l'itération suivante, vous pouvez utiliser l'instruction continue. Elle diffère de l'instruction break en ce qu'elle ne termine pas la boucle, mais passe simplement à l'itération suivante.
L'instruction continue, comme break, peut prendre un argument numérique facultatif, qui indique combien de niveaux de boucles imbriquées le reste de l'itération sera ignoré. La valeur par défaut d'un argument numérique est 1, ce qui ignore uniquement le reste de la boucle actuelle.
"; continue;) echo" 50 / $ bar1 = ", 50 / $ bar1"
";
}
?>
Remarque : pendant la boucle, la valeur zéro de la variable de compteur $ a été ignorée, mais la boucle a continué à partir de la valeur suivante.
aller à
goto est un opérateur de saut inconditionnel. Il est utilisé pour passer à une autre section du code du programme. L'endroit où vous devez vous rendre dans le programme est indiqué par un libellé (simple identifiant) suivi de deux points. Pour un saut, l'étiquette souhaitée est placée après l'instruction goto.
Un exemple simple d'utilisation de l'instruction goto :
L'instruction goto a quelques limitations sur son utilisation. L'étiquette cible doit être dans le même fichier et dans le même contexte, ce qui signifie que vous ne pouvez pas sortir des limites d'une fonction ou d'une méthode, ni entrer dans l'une d'entre elles. De plus, vous ne pouvez pas entrer dans une boucle ou une instruction switch. Mais il peut être utilisé pour quitter ces constructions (à partir de boucles et d'instructions switch). Habituellement, une instruction goto est utilisée à la place des pauses à plusieurs niveaux.
";) echo" après la boucle - jusqu'à la marque "; // l'instruction ne sera pas exécutée end: echo" Après la marque ";?>
