Deux types de boucles peuvent être utilisés en PHP : for et while
Boucle for
for ($i = 1; $i<10; $i++) {
echo $i "vaut ".$i."<br>";
}
Boucle while
$i=0;
while ($i<10) {
$i++;
echo $i "vaut ".$i."<br>";
}
Deux types de boucles peuvent être utilisés en PHP : for et while
for ($i = 1; $i<10; $i++) {
echo $i "vaut ".$i."<br>";
}
$i=0;
while ($i<10) {
$i++;
echo $i "vaut ".$i."<br>";
}
Dans un programme, il est souvent nécessaire de faire exécuter plusieurs fois un même bloc d’instructions. Plutôt que de répéter plusieurs fois ce bloc, il est plus judicieux d’utiliser une instruction de répétition. Java dispose de trois instructions de ce type : for, do while et while. Nous allons examiner leur fonctionnement dans les pages suivantes.
L’instruction for exécute de façon répétitive un bloc d’instructions tant qu’une condition est vérifiée. Cette condition est basée sur la valeur d’une variable incrémentée par l’instruction.
Voici la syntaxe de l’instruction for :
for (expression 1; expression 2; expression 3){
instruction 1;
...
instruction N;
}
L’instruction while exécute de façon répétitive un bloc d’instructions tant qu’une condition est vérifiée. Le test de la condition est fait avant l’exécution de la boucle.
Voici la syntaxe de l’instruction while :
while (expression) {
instruction 1;
...
instruction N;
}
où expression est une condition qui doit être vérifiée pour que les instructions de la boucle s’exécutent, et instruction 1 à instruction N sont les instructions ou appels de procédures/fonctions exécutés tant que l’expression est vérifiée.
L’instruction do while se comporte comme l’instruction while, mais le test de la condition de bouclage est réalisé après avoir exécuté le bloc d’instructions. Il en découle que le bloc d’instructions est au moins exécuté une fois dans une boucle do while, alors qu’il peut ne pas l’être dans la même boucle while.
Voici la syntaxe de l’instruction do while :
do {
instruction 1;
...
instruction N;
}
while (expression);
où expression est une condition logique qui fixe la ré exécution ou l’arrêt du bloc d’instructions, et instruction 1 à instruction N sont les instructions ou appels de procédures/fonctions exécutés jusqu’à ce que l’expression ne soit plus vérifiée.
Pour définir une boucle infinie (c’est-à-dire pour exécuter indéfiniment un bloc d’instructions), vous utiliserez l’une des trois instructions suivantes.
Première possibilité :
for ( ; ; ){
instructions;
}
Deuxième possibilité :
while (1){
instructions;
}
Troisième possibilité :
do{
instructions;
}
while (1);
Il est parfois nécessaire d’interdire l’exécution d’une boucle lorsqu’une condition logique est satisfaite. Pour ce faire, vous utiliserez l’instruction continue, en tête du bloc :
Dans une instruction for :
for (expression 1; expression 2; expression 3){
if (condition)
continue;
instruction 1;
...
instruction N;
}
Dans une instruction while :
while (expression){
if (condition)
continue;
instruction 1;
...
instruction N;
}
Dans une instruction do while :
do{
if (condition)
continue;
instruction 1;
...
instruction N;
}
while (expression);
Exemple :
Ce petit programme calcule les valeurs de la fonction y = 1/(x – 3) pour les valeurs comprises entre 2 et 4, par pas de 0.1. Il est nécessaire d’exclure la valeur 3 du calcul. Une instruction continue s’en charge.
public class Fonction {
public static void main (String args[]) {
double x;
for (x=2; x<=4; x+=.1){
if (((x-3)<0.01) && ((x-3)>-0.01))
continue; // Interdit l'exécution de la boucle pour x=3
System.out.println("x= " + x + " y= " + 1/(x-3));
}
}
}
Remarque
Pour tester si x vaut 3, on ne peut pas utiliser l’instruction suivante :
if (x == 3)
Car x est une variable de type double. Par sa nature, elle ne sera jamais égale exactement à 3, mais plutôt à quelque chose comme 3,0000000001.
Il est parfois utile d’arrêter l’exécution d’une boucle lorsqu’une condition logique est satisfaite. Pour cela, utilisez l’instruction break, en tête du bloc :
Dans une instruction for :
for (expression 1; expression 2; expression 3){
if (condition)
break;
instruction 1;
...
instruction N;
}
Dans une instruction while :
while (expression){
if (condition)
break;
instruction 1;
...
instruction N;
}
Dans une instruction do while :
do{
if (condition)
break;
instruction 1;
...
instruction N;
}
while (expression);
Le langage Java possède une boucle semblable à l’instruction foreach rencontrée dans de nombreux autres langages. Vous utiliserez cette instruction pour parcourir simplement les éléments d’une structure quelconque (un tableau ou une collection quelconque).
Voici la syntaxe de cette instruction :
for (type variable : structure {
// Une ou plusieurs instructions
}
Voici un exemple d’utilisation :
public static void main(String[] args) {
int[] Tableau = {1, 2, 3, 4, 5, 6};
for (int t:Tableau){
System.out.println(t);
}
}
Et voici le résultat, exécuté dans NetBeans :
<center><img src=”https://www.mediaforma.com/uneminuteparjour/java/images/java-instructions-repetitives.jpg”></center>
Comme tous les langages, Java est composé d’un certain nombre de mots-clés. Nous allons les passer en revue dans cette section.
Pour faciliter la compréhension et la maintenance du code, il est souvent utile d’ajouter des commentaires dans le source d’une application ou d’une applet.
Le langage Java supporte trois types de commentaires :
Les caractères “//” définissent un commentaire sur une (et une seule) ligne qui s’étend jusqu’au retour chariot de fin de ligne.
Les deux exemples ci-après sont corrects :
// Ce commentaire occupe une ligne
for (i=1; i<10; i++) // Le traitement est répété 10 fois
Par contre, l’exemple ci-après est incorrect. Les caractères “//” ne peuvent pas être placés à l’intérieur d’une instruction :
for (i=1; // Le traitement est répété 10 fois i<10; i++)
Les signes “/*” et “*/” peuvent être utilisés pour placer des commentaires sur plusieurs lignes ; par exemple :
/* Ceci est un commentaire
qui occupe deux lignes */
Contrairement au premier type de commentaire (//), il est ici possible de placer un commentaire à l’intérieur d’une instruction :
for (i=1; /* Le traitement est répété 10 fois */ i<10; i++)
Ce type de commentaire est destiné au programme javadoc.exe, livré avec le SDK. Il permet de documenter automatiquement une application.
Sans entrer dans les détails, sachez que les lignes de code qui commencent par les caractères “/**” contiennent des commentaires qui seront automatiquement insérés dans un document HTML lors de l’exécution du programme Javadoc.
Exemple :
/** Ces commentaires
sont destinés au
système JAVADOC
qui génère de la documentation
API à partir du code */
Le terme “identificateurs” désigne les constantes, les variables et les objets utilisés dans le langage. Ces derniers commencent obligatoirement par une lettre (A à Z, a à z, ou une autre lettre appartenant au jeu de caractères Unicode dont la valeur hexadécimale est supérieure à H00C0), un caractère de soulignement (_) ou un dollar ($). Les caractères suivants peuvent être des lettres, des caractères de soulignement, des dollars ou des chiffres.
Par exemple, les noms suivants peuvent être utilisés pour référencer un identificateur :
Var12_5
Bien_que_très_long_ce_nom_est_acceptable
$Celui-ci_aussi
Par contre, ces deux identifiants ne sont pas autorisés :
Nombre d'itérations
4Var
Le premier, parce qu’il contient un espace. Le second, parce qu’il commence par un chiffre.
Remarque Unicode est un standard qui permet des échanges de texte dans différentes langues.Le tableau ci-après liste les mots clés du langage. Ces derniers ne peuvent pas être utilisés comme noms de variable, d’objet, de classe, etc. Leur utilisation sera décrite dans la suite de l’ouvrage.
Mot clé | Signification |
abstract | Définit une classe ou une fonction qui n’a pas été totalement implémentée. |
boolean | Déclaration d’une variable booléenne. |
break | Fin prématurée d’une boucle. |
byte | Déclaration d’une variable byte. |
case | Teste si une variable a une valeur particulière dans un bloc switch. |
catch | Traitement suite à une exception. |
char | Déclaration d’une variable char. |
class | Déclaration d’une classe. |
const | Ce mot est réservé mais pas utilisé dans le langage. |
continue | Interdit l’exécution d’une boucle lorsqu’une condition logique est satisfaite. |
default | Permet d’exécuter un bloc d’instructions lorsque aucune des constantes case ne concorde avec l’expression placée après le mot switch. |
do | Boucle do while. |
double | Déclaration d’une variable double. |
else | Dans une instruction if else, permet d’exécuter un bloc d’instructions si la condition if n’est pas satisfaite. |
extends | Permet de sous-classer une classe parent. |
false | Valeur booléenne false. |
final | Indique à Java que la classe courante ne peut être sous-classée. |
finally | Permet d’exécuter systématiquement une portion de code à chaque occurrence d’une exception. |
float | Déclaration d’une variable float. |
for | Exécute répétitivement un bloc d’instructions. |
goto | Ce mot est réservé mais pas utilisé dans le langage. |
if | Teste une condition logique. |
implements | Détermine l’interface à utiliser. |
import | Fait référence à un package Java externe. |
instanceof | Détermine le type d’un objet. |
int | Déclaration d’une variable int. |
interface | Indique à Java que le code qui suit doit être utilisé pour définir une nouvelle interface. |
long | Déclaration d’une variable long. |
native | Permet d’appeler un programme externe. |
new | Permet de définir une nouvelle instance de classe. |
null | Correspond à une valeur non existante. |
package | Indique à Java le nom du package auquel se réfère le code qui suit. |
private | Définit une classe, une méthode ou une variable private. |
protected | Définit une classe, une méthode ou une variable protected. |
public | Définit une classe, une méthode ou une variable public. |
return | Définit la valeur retournée par une classe ou une méthode. |
short | Déclaration d’une variable short. |
static | Définit une classe, une méthode ou une variable static. |
super | Fait référence à la classe parent de la classe courante. |
switch | Permet d’effectuer un test multiple sur une variable. |
synchronized | Indique à Java qu’une seule instance de cette méthode peut être exécutée à la fois. |
this | Fait référence à l’objet courant. |
throw | Indique à Java qu’une exception particulière (autre que Errors et Runtime) doit être traitée dans le prochain bloc catch. |
throws | Détermine les exceptions gérées par le programmeur dans une déclaration de méthode. |
true | Valeur booléenne true. |
try | Définit un bloc de code dans lequel une ou plusieurs exceptions peuvent se produire. Un bloc try doit être suivi d’un bloc catch qui traite les exceptions correspondantes. |
void | Déclare une procédure Java qui ne renvoie aucune valeur. |
volatile | Les variables de type volatile peuvent changer de valeur indépendamment du programme Java (date et heure système par exemple) |
while | Exécute répétitivement un bloc d’instructions. |
Recevez gratuitement ce mini-dossier au format PDF dans votre boîte mail.