Langage d'expression dans JSP

⚡ Résumé intelligent

Le langage d'expression dans JSP simplifie l'accès aux données stockées dans JavaLes beans et les objets implicites tels que les requêtes, les sessions et les applications. Introduits dans JSP 2.0, ils prennent en charge les opérateurs arithmétiques, logiques et relationnels, ainsi que les instructions de décision et de boucle écrites dans des balises EL.

🧮 Définition d'EL : Simplifie l'accès à JavaBeans et objets implicites ; ajoutés dans JSP 2.0.
🔣 syntaxe: Écrivez les expressions entre ${ } pour qu'elles soient évaluées lors de l'exécution et que le résultat soit affiché.
🔀 La prise de décision: Les instructions if-else et switch contrôlent le flux de la page.
(I.e. Boucles: Les instructions for et while permettent d'itérer sur des conditions.
➕ Operateurs : Opérateurs arithmétiques, relationnels et logiques (eq, lt, and, or, vide).

Qu’est-ce que le langage d’expression (EL) ?

Le langage d'expression (EL) est un mécanisme qui simplifie l'accessibilité des données stockées dans Java composant bean et autre objet comme requête, session et application, etc.

Il existe de nombreux opérateurs dans JSP qui sont utilisés dans EL comme les opérateurs arithmétiques et logiques pour exécuter une expression. Il a été introduit dans JSP 2.0

Syntaxe JSP du langage d'expression (EL)

Syntaxe de EL : ${expression}

Dans JSP, tout ce qui est présent entre les accolades est évalué au moment de l'exécution et envoyé au flux de sortie.
L'expression est une expression EL valide et elle peut être mélangée avec un texte statique et combinée avec une autre expression pour former une expression plus grande.

Pour avoir une meilleure idée du fonctionnement des expressions dans JSP, nous allons voir l'exemple ci-dessous. Dans cet exemple, nous verrons comment EL est utilisé comme opérateur pour additionner deux nombres (1+2) et obtenir le résultat correspondant.

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
	pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Guru JSP1</title>
</head>
<body>
<a>Expression is:</a>
${1+2};
</body>
</html>

Explication de Code:

Code Ligne 11: Le langage d'expression (EL) est défini là où nous ajoutons deux nombres 1+2, il donnera donc un résultat de 3.

Lorsque vous exécutez le code ci-dessus, vous obtiendrez la sortie suivante.

Sortie:

L'expression est : 3 (Comme les nombres 1+2 seront ajoutés et serviront de sortie)

Déclarations de contrôle de flux :

JSP offre la puissance de Java à intégrer dans l'application. Nous pouvons utiliser toutes les API et éléments de base de Java in Programmation JSP y compris les instructions de flux de contrôle qui incluent la prise de décision et les instructions de boucle.

Il existe deux types d'instructions de contrôle de flux décrites ci-dessous :

Déclarations décisionnelles
Déclarations de boucle

Déclarations décisionnelles :

La déclaration de prise de décision dans JSP est basée sur le fait que l'ensemble de conditions soit vrai ou faux. La déclaration se comportera en conséquence.

Il existe deux types de déclarations décisionnelles décrites ci-dessous :

Sinon
interrupteur

JSP Si-sinon

L'instruction « If else » est la base de toutes les instructions de flux de contrôle et elle indique au programme d'exécuter une certaine section de code uniquement si le test particulier est évalué comme vrai.

Cette condition est utilisée pour tester plusieurs conditions si elles sont vraies ou fausses.

Si la première condition est vraie alors « if block » est exécuté et
si c'est faux alors "else block" est exécuté

Syntaxe de l'instruction if – else:

If(test condition)
{
	 //Block of statements
}
else
{
    //Block of statements
}

Dans cet exemple, nous allons tester la condition « si sinon » en prenant une variable et en vérifiant la valeur si la variable correspond à ce à quoi elle est initialisée :

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Guru JSP2</title>
</head>
<body>
<%! int month=5; %>
<% if(month==2){ %>
<a>Its February</a>
<% }else{ %>
<a>Any month other than February</a>
<%} %>
</body>
</html>

Explication du code :

Code Ligne 10: La variable nommée mois est initialisée à 5 dans les balises d'expression
Code Ligne 11: Dans les balises EL il y a « if condition » indiquant que si le mois est égal à 2 (la condition est testée ici comme vraie ou fausse)
Code Ligne 12: Si la condition est vraie et que la variable mois est 2, elle sera imprimée dans le flux de sortie.
Code Ligne 13-15: Si la condition if ci-dessus échoue, elle sera déplacée vers la partie else pour tous les autres cas où l'instruction sera imprimée sur le flux de sortie et la condition est fermée.

Lorsque vous exécutez le code ci-dessus, vous obtiendrez la sortie suivante.

Sortie :

Étant donné que le mois que nous avons est 5, ce qui n'est pas égal à #2 (février). Par conséquent, nous avons la sortie « Tout mois autre que février » (le mois est mentionné comme 5, donc les autres sont exécutés)

Commutateur JSP

Le corps de l’instruction switch est appelé « bloc switch ».

Le cas de commutation est utilisé pour vérifier le nombre de chemins d'exécution possibles.
Un commutateur peut être utilisé avec tous les types de données
Les instructions switch contiennent plusieurs cas et un cas par défaut
Il évalue l'expression puis exécute toutes les instructions suivant le cas correspondant

Syntaxe de l'instruction switch:

switch (operator)
{
   Case 1:
       Block of statements
break;
   Case 2:
      Block of statements
break;


case n:
    Block of statements
break;
default:
  Block of statements
break;
}

Le bloc de commutation commence par un paramètre, qui est l'opérateur qui doit être transmis et
Ensuite, il existe différents cas qui fournissent une condition et celui qui correspond à l'opérateur, ce cas est exécuté.

Dans l'exemple ci-dessous, nous avons défini une variable « semaine », qui est comparée à la condition vraie. Ici, la semaine est 2, donc la réponse est 2.^nd le cas correspond et la sortie est mardi :

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Guru JSP3</title>
</head>
<body>
<%! int week=2; %>
<% switch(week){
case 0:
    out.println("Sunday");
    break;
case 1:
    out.println("Monday");
    break;
case 2:
    out.println("Tuesday");
    break;
case 3:
    out.println("wednesday");
    break;
case 4:
    out.println("Thursday");
    break;
case 5:
    out.println("Friday");
    break;
    default:
        out.println("Saturday");
    }
%>
</body>
</html>

Explication de Code:

Code Ligne 10: La variable nommée week est initialisée à 2 dans les balises d'expression
Code Ligne 11: Dans les balises EL, le cas de commutation est démarré où la semaine est passée en paramètre
Code Lignes 12 et 29 : Tous les cas ont été mentionnés, du cas 0 au cas 5, où la valeur du paramètre week correspond aux cas et, par conséquent, la sortie est imprimée. Dans ce cas, la valeur est 2 donc le cas 2 sera exécuté dans ce cas. Ici, « out » est la classe de JSP qui écrit le flux de sortie pour la réponse générée et « println » est une méthode de cette classe.
Code Ligne 30-32: Si tous les cas ci-dessus échouent, il sera déplacé vers la partie par défaut et sera exécuté, où l'instruction sera imprimée sur le flux de sortie et la condition sera fermée.

Lorsque vous exécutez le code ci-dessus, vous obtiendrez la sortie suivante.

Sortie :

La sortie dans ce cas est le mardi car le 2ème cas est appelé.

Instructions de boucle :

Boucle JSP For

Il est utilisé pour itérer les éléments pour une certaine condition et comporte trois paramètres.

Le compteur variable est initialisé
Condition jusqu'à ce que la boucle doive être exécutée
Le compteur doit être incrémenté

Syntaxe de la boucle For :

For(inti=0;i<n;i++)
{
           //block of statements
}

Dans cet exemple, nous avons une boucle for qui itère jusqu'à ce que le compteur soit inférieur au nombre donné :

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Guru JSP4</title>
</head>
<body>
<%! int num=5; %>
<% out.println("Numbers are:");
for(int i=0;i<num;i++){
    out.println(i);
}%>
</body>
</html>

Explication du code :

Code Ligne 10: La variable nommée « num » est initialisée à 5 dans les balises d'expression
Code Ligne 11-14: Dans les balises EL, « out » est la classe de JSP et « println » est la méthode out qui s'imprime dans le flux de sortie et la boucle for est lancée qui a trois paramètres :
- La variable i est initialisée à 0,
- La condition est donnée où i est inférieur à la variable locale num,
- Et i est incrémenté à chaque itération de la boucle temporelle.

Dans le corps de « forloop », il y a une classe de JSP qui s'imprime dans le flux de sortie en utilisant la méthode println où nous imprimons la variable i.

Lorsque vous exécutez le code ci-dessus, vous obtiendrez la sortie suivante.

Sortie :

Sortie Numbers sont 0 1 2 3 4. Dans cet exemple, nous donnons la condition selon laquelle jusqu'à ce que le compteur soit inférieur à une variable, la « boucle for » doit être exécutée. Le nombre est 5 donc la boucle commencera à partir de 0 et se déroulera jusqu'à 4 (5 fois). D'où la sortie.

Boucle JSP While

Il est utilisé pour itérer le éléments dans lequel il a un paramètre de la condition.

syntaxe:

While(i<n)
{
      //Block of statements
}

Dans cet exemple, nous avons une boucle while qui va itérer jusqu'à ce que le jour soit supérieur ou égal au compteur :

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Guru JSP5</title>
</head>
<body>
<%! int day=2; int i=1; %>
<% while(day>=i){
    if(day==i){
        out.println("Its Monday");
        break;}
    i++;}
%>

</body>
</html>

Explication du code :

Code Ligne 10: La variable nommée i est initialisée à 1 et le jour vaut 2 dans les balises d'expression
Code Ligne 11-17: Dans les balises EL, une boucle « while » s'exécute jusqu'à ce qu'une condition soit remplie : si la date est supérieure ou égale à i, la variable est vraie (jour >= i). À l'intérieur de cette boucle, une condition « if » vérifie si la date est égale à i. Si cette condition est vraie, le flux de sortie est affiché et la boucle « while » s'arrête ; sinon, la variable i est incrémentée et la boucle continue.

Lorsque nous exécutons le code, nous aurons le résultat suivant

La sortie est:

La sortie de ce code sera « son Monday ».

JSP Operajeudi

JSP Operators prend en charge la plupart de ses opérateurs arithmétiques et logiques qui sont pris en charge par Java dans les balises de langage d'expression (EL). Les opérateurs fréquemment utilisés sont mentionnés ci-dessous :

Voici les opérateurs :

.	Accéder à une propriété de bean ou à une entrée de carte
[]	Accéder à un élément de tableau ou de liste
()	Regrouper une sous-expression pour modifier l'ordre d'évaluation
+	Addition
-	Soltracémission ou négation d'une valeur
*	Multiplier
/ ou div	Division
% ou module	Modulo (reste)
== ou équation	Test d'égalité
!= ou ne	Test d'inégalité
< ou lt	Testez pour moins de
> ou GT	Test pour plus de
<= ou le	Test pour inférieur ou égal
>= ou ge	Test pour supérieur ou égal
&& ou et	Tester le ET logique
\|\| ou ou	Test du OU logique
! ou non	Complément booléen unaire
Vide	Tester les valeurs de variables vides

Dans cet exemple,

Nous déclarons deux variables num1 et num2, puis prenons une variable num3, où nous utilisons l'opérateur JSP + by pour ajouter num1 et num2 et obtenir num3.
Ensuite, nous vérifions si num3 est différent de 0 en utilisant les opérateurs JSP (!=, >) et
Prenez ensuite une autre variable num4 en multipliant deux num1 et num2 nous obtenons num4.

Tous ces nombres doivent être imprimés comme résultat :

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Guru JSP6</title>
</head>
<body>
<% int num1=10; int num2 = 50;
   int num3 = num1+num2;
   if(num3 != 0 || num3 > 0){
       int num4= num1*num2;
       out.println("Number 4 is " +num4);
       out.println("Number 3 is " +num3);
    }%>
</body>
</html>

Explication du code :

Code Ligne 10: La variable nommée num1 est initialisée à 10 et num2 à 50 dans les balises d'expression
Code Ligne 11: La variable num3 est la somme de num1 et num2 où nous utilisons l'opérateur d'addition
Code Ligne 12-16: Dans les balises EL, nous avons utilisé l'opérateur OU (ou un opérateur logique et arithmétique) pour vérifier si num3 est supérieur à 0 dans la condition « if ». L'opérateur OU est utilisé lorsqu'au moins une des conditions est vraie ; dans ce cas, le programme entre dans la partie « if » où nous multiplions les nombres « num1 » et « num2 » et stockons le résultat dans « num4 ». Le résultat est ensuite affiché.

Lorsque vous exécutez le code ci-dessus, vous obtiendrez la sortie suivante.

Sortie :

La première sortie est le numéro 4 est 500 (variable num4 qui est num1*num2)
La deuxième sortie est le numéro 3 est 60 (variable num3 dont num1+num2)

FAQ

Le langage d'expression (EL) simplifie l'accès aux données stockées dans JavaLes beans et les objets implicites tels que les requêtes, les sessions et les applications. Cela vous permet d'écrire des expressions et des opérateurs concis directement dans une page JSP au lieu de Java scriptlets.

EL utilise la syntaxe ${expression}. Le contenu entre accolades est évalué à l'exécution et envoyé au flux de sortie. Les expressions peuvent être combinées avec du texte statique et d'autres expressions.

Le langage d'expression a été introduit dans JSP 2.0. Il a été conçu pour réduire le besoin de Java Les scriptlets permettent d'accéder et d'afficher facilement les données de l'application.

L'IA peut convertir Java Transformer des scriptlets en expressions EL plus claires, suggérer l'opérateur approprié et générer des exemples de boucles et de conditions, etc.ping Les développeurs écrivent plus rapidement des pages JSP plus lisibles.

Oui. L'IA peut signaler les syntaxes EL invalides, les accolades mal appariées, les propriétés de bean manquantes et les problèmes de type, puis suggérer des corrections, réduisant ainsi les erreurs d'exécution dans les pages JSP.

Langage d'expression dans JSP

Qu’est-ce que le langage d’expression (EL) ?

Syntaxe JSP du langage d'expression (EL)

JSP Si-sinon

Commutateur JSP

Boucle JSP For

Boucle JSP While

JSP Operajeudi

FAQ

Résumez cet article avec :

Enregistrez-vous pour recevoir le bulletin d'informations

Qu’est-ce que le langage d’expression (EL) ?

Syntaxe JSP du langage d'expression (EL)

JSP Si-sinon

ARTICLES LIÉS

Commutateur JSP

Boucle JSP For

Boucle JSP While

JSP Operajeudi

FAQ

Résumez cet article avec :

Enregistrez-vous pour recevoir le bulletin d'informations