Les boucles en JSP

Les boucles en JSP

  1. Objectifs

    • Connaitre les structures conditionnelles en Java
  2. Présentation

    • Une boucle permet d’exécuter une instruction plusieurs fois.
    • Les instructions de boucle (aussi appelé instructions répétitives) en langage JSP (Java Server Pages) sont au nombres de trois à savoir:
      • while
      • do … while
      • for



  3. Boucle For

    1. Présentation
      • La boucle permet de répéter un certain nombre de fois un ensemble d’instructions.
      • La boucle est introduite par le mot-clé for.
    2. Syntaxe
      • 
        for ([initialisation;][condition;][incrementation])
        {
            instructions
        }
        
      • La condition qui suit FOR est composée de 3 éléments :
        • 1. Une valeur ou expression initiale portant sur une variable entière appelée compteur.
          2. Une condition : tant qu’elle est vraie, la répétition est poursuivie.
          3. Une expression de poursuite qui consiste en la mise à jour du compteur.

        Ce sont bien des points-virgules (;)qui se trouvent entre les parenthèses après le for.
        Attention à ne pas les confondre avec des virgules, qui sont utilisées pour séparer les arguments des fonctions.

    3. Exemple :
      • <!DOCTYPE html >
        <html lang="fr">
        <head>
        <title>JavaScript</title>
        <meta ="UTF-8">
        </head>
        <body>
        <% for (int j=1; j<=50; j++){ %>
            <%= j %> </br>
         <% } %>
        </body>
        </html> 
        • Pour afficher nos cinquante premiers entiers, nous pouvons écrire une boucle qui nous permet de réduire le texte de programme à trois lignes (au lieu de cent).
        • Cette boucle utilise la variable i qui vaut 1 initialement. Ensuite le corps de la boucle, c’est-à-dire les instructions à l’intérieur des crochets ({ et }) est exécuté
        • tant que la condition i<=50 est vraie. A chaque tour de boucle, on incrémente la variable i.
    4. Applications
      1. A1
        • Créez un fichier jsp nommé boucleForApp1.jsp, comportant un script permettant d’afficher tous les diviseurs des nombres compris entre 2 et 100 ;
        • Mettre le nombre en gras
        • les nombres premiers seront colorés en rouge
        • Le résultat du script doit ressemble au schéma suivant
        • <!DOCTYPE html >
          <html lang="fr">
          <head>
          <title>JavaScript</title>
          <meta ="UTF-8">
          </head>
          <body>
           <% int n=0; 
          for(n=2; n<=20; n++)
          { 
              int t=1;int i;String m="1"; 
              for(i=2 ;i<=n; i++)
               {
                  if(n%i==0)
                  {           
                      m+= ','+(new Integer(i).toString());
                      t++;
                  }
               }
               if(t==2)
               {
                   %>
                  <span style='color:red'> Les diviseurs de <b><%= n%> </b> sont: <%= m%><br></span>
                  <%
              }
              else
              {
                  %>
                  Les diviseurs de <b><%= n%> </b> sont: <%= m%><br>
                  <%
              }       	
          }
          %>
          
          
          </body>
          </html> 
      2. A2
        • Créez un fichier jsp nommé boucleForApp2.jsp, comportant un script permettant d’afficher tous les nombres parfaits compris entre 2 et 1000 ; sachant qu’un nombre N est dit parfait s’il est égal à la somme de ses diviseurs sauf lui-même.
          Exemple : Pour N=6 La somme des diviseurs de 6 (sauf 6) est 1+2+3= 6, donc 6 est un nombre parfait.
        • <!DOCTYPE html >
          <html lang="fr">
          <head>
          <title>JavaScript</title>
          <meta ="UTF-8">
          </head>
          <body>
           <%
           for(int n=2; n<=1000; n++)
           {
             int s=1;
              for(int i=2 ;i<=n/2; i++)
              if(n%i==0) s+=i;
              if (s==n){%>
                  <%= n%><br>
           <%}}
          %>
          
          
          </body>
          </html> 

    Bibliographie

    • https://www.editions-eni.fr/open/mediabook.aspx?idR=d61db330adee76e87b74dc180f67552d
  4. Boucle While

    1. Présentation
      • L’instruction "while" permet la comparaison au début de la boucle, avant même que la suite d’instruction inclus dans la boucle ne soit lancé! On peut voir cette instruction à la manière d’un "if" se répétant tant et aussi longtemps que la condition est vrai.
    2. Syntaxe
      • while(expression_vrai) instruction_exécuté_si_vrai;
  5. Boucle DO…While

    1. Présentation
      • L’instruction "Do…while" est identique à si méprendre avec l’instruction «while» à la différence que la condition est effectué à la fin des instructions plutôt qu’au début. L’avantage, on est certain que les instructions seront exécutés au moins une fois! Ainsi le principe de fonctionnement est simple, on exécute les instructions, on effectue un teste pour vérifier si la condition est vrai, on revient au début et on recommence sinon on poursuit à l’instruction suivante.
      • La structure do permet d’exécuter une instruction ou un bloc d’instructions et de répéter cette action tant qu’une expression logique controlée par while est vraie.
      • La commande do… while est une commande JavaScript de boucle similaire à la commande while.
      • Elle exécute une instruction ou une série d’instructions une fois puis en répète l’exécution tant qu’une expression conditionnelle est évaluée à true.
    2. Syntaxe
      • 
        do
        {
        instructions
        } while (condition(s))
        

        Paramètres

        • instruction
        • Une instruction exécutée au moins une fois et ré-exécutée chaque fois que la condition de test est évaluée à true. On peut exécuter plusieurs instructions au sein d’une boucle grâce à l’instruction block ({ … }) qui permet de grouper différentes instructions en une seule.
        • condition
        • Une expression évaluée après chaque passage dans la boucle.
    3. Exemple :
      • <!DOCTYPE html >
        <html lang="fr">
        <head>
        <title>JavaScript</title>
        <meta ="UTF-8">
        </head>
        <body>
        <%
         int i = 0;
         do {%>
            <%=i %><br>
            <% i++;
            } while (i < 10);
        %>
        
        
        </body>
        </html> 
        • Dans l’exemple suivant, les instructions de la boucle do…while continuent à s’exécuter tant que la variable i est inférieure à 10.



Abonnez vous à notre chaîne YouTube gratuitement