EL offre la possibilité d'écrire des expressions qui vont être évaluées dynamiquement à l'exécution de la page.
Une expression peut être un accès à une variable, une opération sur des variables, ou une invocation de méthode.
Voici un exemple d'utilisation d'une expression EL :

<%
request.setAttribute("x", 5);
request.setAttribute("y", 10);
%>

${x*y} 

Voici le code Java généré par le container de servlets :

public void _jspService(
        final javax.servlet.http.HttpServletRequest request,
        final javax.servlet.http.HttpServletResponse response)
        throws java.io.IOException, javax.servlet.ServletException {

    // ...

    request.setAttribute("x", 5);
    request.setAttribute("y", 10);

    out.write((java.lang.String) org.apache.jasper.runtime.PageContextImpl.proprietaryEvaluate("${x*y}", java.lang.String.class, (javax.servlet.jsp.PageContext)_jspx_page_context, null, false));

    // ...
}

La valeur de l'expression ${x*y} est passée en paramètre à la méthode proprietaryEvaluate.
À l'exécution de la page JSP l'expression va être évaluée et la valeur résultante de l'exécution de cette expression va être écris dans la sortie.

Une expression EL est placée entre deux accolades "{" et "}" avec le caractère "$" placé avant la première accolade ouvrante : ${EL_Expression}
À noter que les expressions EL ne permettent pas d'écrire des instructions de flux de commande (conditions, boucles).

Le typage n'est pas explicite avec EL, il est inféré par le compilateur dépendamment de la valeur de l'expression.
Il y a cependant cinq catégories de littéraux qui sont mappés avec cinq types correspondants du langage Java.

+-----------------------+---------------------------+-------------------------------------------------------------------------------+
| littéral              | Exemple                   | Commentaire                                                                   |
+-----------------------+---------------------------+-------------------------------------------------------------------------------+
| true|false            | ${true == (4 == 4)}       | Équivalents aux littéraux Java "true" et "false".                             |
|                       |                           | Comme pour Java, il faut respecter la casse.                                  |
+-----------------------+---------------------------+-------------------------------------------------------------------------------+
| Nombres               | ${10000 + 25.87}          | Nombres entiers et réels.                                                     |
+-----------------------+---------------------------+-------------------------------------------------------------------------------+
| Chaînes de caractères | ${"chaîne de caractères"} | Les caractères sont placés entre deux guillemets (") ou deux apostrophes ('). |
+-----------------------+---------------------------+-------------------------------------------------------------------------------+
| null                  | ${null}                   | Équivalent au littéral Java "null".                                           |
|                       |                           | Comme pour Java, il faut respecter la casse.                                  |
|                       |                           | Génère une chaine vide sur la sortie.                                         |
+-----------------------+---------------------------+-------------------------------------------------------------------------------+

Notes :
- Pour les littéraux "true", "false", et "null", il faut respecter la casse sinon l'évaluateur des expressions EL va considérer qu'il s'agit d'un nom de variable.
- Pour les chaines de caractères, il est possible d'utiliser le caractère d'échappement "\" pour échapper les caractères ("), ('), et (\) : (\"), (\'), (\\).

1. Les opérateurs arithmétiques
   EL offre les opérateurs d'addition (+), soustraction (-), division (/ ou div), modulo (% ou mod), changement de signe (-).
   Ces opérateurs ont le même comportement que ceux du langage Java, à l'exception des cas suivants :
   

   • L'opérateur d'addition (+) s'applique uniquement aux nombres, et il n'est pas possible de l'utiliser avec des chaînes de caractères pour faire la concaténation, comme c'est le cas en Java.
     Ainsi l'opération ${"abc" + "12"} génère une exception java.lang.NumberFormatException : java.lang.NumberFormatException: For input string: "abc".
     
     
   • Les opérandes de ces opérateurs peuvent être des littéraux ou des variables et leurs valeurs peuvent être des nombres mais aussi des chaînes de caractères à condition que la chaîne de caractères soit convertible en une valeur numérique, par exemple l'opération ${"5" - "4"} donne le résultat "1".
     Vous obtiendrez l'exception vu ci-dessus si la conversion de un des opérandes de ces opérateurs échoue.
     
     
   • Si la variable est inexistante ou que sa valeur est nulle, alors par défaut l'évaluateur des expressions EL la traite comme si sa valeur est "0".
     Cela s'applique aussi au littéral null qui est considéré comme "0" lorsqu'il est utilisé comme opérande de ces opérateurs.
     Ainsi l'opération ${null + "4"} donne le résultat "4".
     
     
   • La division sur la valeur "0" ne génère pas une exception puisqu'elle est considérée une division réelle.
     Et donc le résultat de l'opération ${"5" / "0"} est la valeur "Infinity" (comme c'est le cas pour Java lorsque la division est réelle).
     
     
   • L'opérateur modulo performe une opération entière si les deux opérandes sont des valeurs entière, sinon, si un des opérandes et réel alors l'opérateur modulo performe une opération réelle.
     Ainsi l'opération ${"5" % 2} donne le résultat "1".
     Et l'opération ${"5" % "2.0"} donne le résultat "1.0".
     
     
   • L'opérateur unaire "-" permet de changer le signe d'un opérande (nombre) à la négative ou positive selon le signe du nombre.
     Ainsi l'opération ${- (4)} donne le résultat "-4".
     Et l'opération ${- (-5)} donne le résultat "5".
     
     
2. Les opérateurs relationnels

   Nom de l'opérateur	EL	EL (syntaxe java)
   égale à	eq (exemple : ${5 eq 2})	== (exemple : ${5 == 2})
   différent de	ne (exemple : ${5 ne 2})	!= (exemple : ${5 != 2})
   plus grand que	gt (exemple : ${5 gt 2})	> (exemple : ${5 > 2})
   plus grand ou égale à	ge (exemple : ${5 ge 2})	>= (exemple : ${5 >= 2})
   plus petit que	lt (exemple : ${5 lt 2})	< (exemple : ${5 < 2})
   plus petit ou égale à	le (exemple : ${5 le 2})	<= (exemple : ${5 <= 2})

   
   Ces opérateurs s'appliquent autant sur des nombres que des chaînes de caractères.
   Le type de l'opération de comparaison dépend du type des opérandes :
   

   • Si les deux opérandes sont des nombres alors la comparaison est numérique.
     Exemple : ${5 le 22}.
     Résultat : "true".
     
     
   • Si un des opérandes est un nombre et la valeur du deuxième opérande est convertible en valeur numérique alors la comparaison est numérique.
     Exemple : ${5 le "22"}.
     Résultat : "true".
     
     
   • Si les deux opérandes sont des chaînes de caractères alors la comparaison est faite sur des chaînes de caractères.
     Exemple (1) : ${"5" le "22"}.
     Résultat : "false".
     Exemple (2) : ${"abc" le "xyz"}.
     Résultat : "true".
     
     
   • Sinon, si un des opérandes est un nombre et la valeur du deuxième opérande n'est pas convertible en valeur numérique alors l'évaluateur des expressions EL génère une exception javax.el.ELException.
     Exemple : ${5 le "abc"}.
     Résultat : javax.el.ELException: Cannot convert abc of type class java.lang.String to class java.lang.Long.
     
     
3. Les opérateurs logiques

   Nom de l'opérateur	EL	Évaluation de la condition
   négation NOT	not	Exemple (1) : ${not x} Exemple (2) : ${! x} la condition est vraie si x est false la condition est fausse si x est true
   	!
   opérateur AND	and	Exemple (1) : ${x and y} Exemple (2) : ${x && y} la condition est vraie si x et y sont true la condition est fausse si x ou/et y sont false
   	&&
   opérateur OR	or	Exemple (1) : ${x or y} Exemple (2) : ${x || y} la condition est vraie si x ou/et y sont true la condition est fausse si x et y sont false
   	||

   
   Notes :
   L'évaluation d'une valeur qui n'est pas « true » est toujours fausse.
   Cela s'applique autant pour des chaînes de caractères (à l'exception de la chaîne de caractères "true"), des valeurs numériques, des variables non définies, et le littéral null.
   
   Exemples :
   

   <%
   request.setAttribute("x1", "true");
   request.setAttribute("x2", "aaa");
   request.setAttribute("x3", "1");
   request.setAttribute("x4", "0");
   %>
   
   ${not x1} 
   
   ${not x2} 
   ${not x3} 
   ${not x4} 
   
   ${not x5} 
   
   ${not null} 

4. L'opérateur ternaire "? :" (COND ? STMT1 : STMT2)
   L'opérateur ternaire utilise une expression conditionnelle, qui retourne true ou false, pour déterminer l'expression à exécuter.
   L'opérateur est équivalemment à une instruction if...else : if(COND) STMT1; else STMT2;

   <%
   request.setAttribute("attr0", 4);
   %>
   
   ${( attr0 mod 2 eq 0) ? "EVEN NUMBER" : "ODD NUMBER"}

5. L'opérateur empty
   L'application de l'opérateur empty est évaluée à vraie si l'opérande est null, l'opérande est une chaîne de caractères vide, l'opérande est une variable non définie, ou l'opérande est une variable dont la valeur est null.
   L'évaluation est aussi vraie si l'opérande est un tableau vide ou une collection vide.
   Autrement l'évaluation est fausse.
   
   Exemples :
   

   <%
   request.setAttribute("y1", "");
   request.setAttribute("y2", null);
   request.setAttribute("y3", new int[0]);
   request.setAttribute("y4", new Integer[0]);
   request.setAttribute("y5", new ArrayList());
   %>
   
   ${empty y1} 
   ${empty y2} 
   
   ${empty y3} 
   
   ${empty y4} 
   ${empty y5} 
   
   ${empty y6} 
   
   ${empty null} 

6. Les opérateurs d'accès "." et "[]"
   les opérateurs "." et "[]" permettent d'accéder aux propriétés d'un objet bean et aux éléments d'un tableau ou d'une collection de type List ou Map.
   

   • Accéder aux propriétés d'un objet bean :
     Les propriétés correspondent aux méthodes "getter" qui respectent la spécification de nommage des propriétés JavaBeans (les méthodes retournent une valeur et n'ont pas de paramètres).
     Pour accéder aux propriétés on spécifié le nom de la méthode sans le préfixe "get".
     
     L'opérateur "." peut être utilisé pour accéder aux propriétés du bean ${REFERENCE_NAME.PROPERTY_NAME}.
     
     De même l'opérateur "[]" peut être utilisé pour accéder aux propriétés du bean : le nom de la propriété est spécifié entre deux crochets.
     Le nom de la propriété peut être mis soit entre deux quottes doubles ${REFERENCE_NAME["PROPERTY_NAME"]} ou deux quottes simples ${REFERENCE_NAME["PROPERTY_NAME"]}.
     

     <%!
     public class MyClass {
         public Integer getProp1() {
             return 50;
         }
     
         public MyClass getInstance() {
             return new MyClass();
         }
     }
     %>
     
     <%
     MyClass myClass = new MyClass();
     request.setAttribute("attr0", myClass);
     %>
     
     ${attr0.prop1} 
     ${attr0["prop1"]} 

     Si la valeur d'une propriété est un objet bean, alors il est possible d'utiliser ces opérateurs pour accéder aux propriétés du bean référencé :
     - ${REFERENCE_NAME.PROPERTY_NAME1.PROPERTY_NAME2}
     - ${REFERENCE_NAME["PROPERTY_NAME1"]["PROPERTY_NAME2"]}.
     

     ${attr0.instance.prop1} 
     ${attr0["instance"]["prop1"]} 

     Dans certains cas le nom de la propriété peut provenir d'une variable ; par exemple le nom d'un paramètre ou attribut du scope REQUEST. Dans ce cas il est possible d'utiliser l'opérateur "[]" pour accéder à la propriété :
     

     <%
     request.setAttribute("v0", "prop1");
     %>
     
     ${attr0[v0]} 

     
     
   • Accéder aux éléments d'un tableau :
     Déclarer un tableau :
     

     <%
     String[] strArray = {"ABC", "DEF", "GHI"};
     %>

     Accéder aux éléments du tableau :
     

     <%
     request.setAttribute("attr1", strArray);
     %>
     
     ${attr1[0]} 
     ${attr1["1"]} 

     Accéder aux éléments du tableau en utilisant un indice variable :
     

     <%
     request.setAttribute("v1", 2);
     %>
     
     ${attr1[v1]} 

     
     
   • Accéder aux éléments d'une List :
     Déclarer une liste :
     

     <%
     List strLIst = new ArrayList(3);
     
     strLIst.add("ABC");
     strLIst.add("DEF");
     strLIst.add("GHI");
     %>

     Accéder aux éléments de la liste :
     

     <%
     request.setAttribute("attr2", strLIst);
     %>
     
     ${attr2[0]} 
     ${attr2["1"]} 

     Accéder aux éléments de la liste en utilisant un indice variable :
     

     <%
     request.setAttribute("v2", 2);
     %>
     
     ${attr2[v2]} 

     
     
   • Accéder aux éléments d'une Map :
     Déclarer une Map :
     

     <%
     Map strMap = new HashMap();
     
     strMap.put("A", "ABC");
     strMap.put("D", "DEF");
     strMap.put("G", "GHI");
     %>

     Accéder aux éléments de la Map :
     

     <%
     request.setAttribute("attr3", strMap);
     %>
     
     ${attr3["A"]} 
     ${attr3.D} 

     Accéder aux éléments de la Map en utilisant un indice variable :
     

     <%
     request.setAttribute("v3", "G");
     %>
     
     ${attr3[v3]} 

     
     
7. Précédence des opérateurs
   Si plusieurs opérateurs sont utilisés sans les parenthèses alors la priorité des opérateurs est résolue selon l'ordre présenté ici-bas.
   Si des opérateurs sont situés au même niveau alors la priorité s'applique de droite à gauche.
   

   1. [] .
      
   2. ()
      
   3. - (opérateur unaire : changement de signe) not ! empty
      
   4. * / div % mod
      
   5. + - (opérateur binaire : soustraction)
      
   6. < > <= >= lt gt le ge
      
   7. == != eq ne
      
   8. && and
      
   9. || or
      
   10. ? :
       

EL offre des variables qui référencent des objets implicites.

+------------------+--------------------------------------------------------------------------------------+---------------------------------------------------------+
| Objet            | Description                                                                          | Équivalent en JSP                                       |
+------------------+--------------------------------------------------------------------------------------+---------------------------------------------------------+
| pageContext      | Instance de PageContext de la page JSP                                               | objet implicite pageContext                             |
+------------------+--------------------------------------------------------------------------------------+---------------------------------------------------------+
| pageScope        | Un objet Map des attributs du scope PAGE                                             | pageContext.getAttribute(PAGE_SCOPE)                    |
+------------------+--------------------------------------------------------------------------------------+---------------------------------------------------------+
| requestScope     | Un objet Map des attributs du scope REQUEST                                          | request.getAttribute()                                  |
+------------------+--------------------------------------------------------------------------------------+---------------------------------------------------------+
| sessionScope     | Un objet Map des attributs du scope SESSION                                          | session.getAttribute()                                  |
+------------------+--------------------------------------------------------------------------------------+---------------------------------------------------------+
| applicationScope | Un objet Map des attributs du scope APPLICATION                                      | application.getAttribute()                              |
+------------------+--------------------------------------------------------------------------------------+---------------------------------------------------------+
| param            | Un objet Map des paramètres de la requête http (première valeur de chaque paramètre) | request.getParameter()                                  |
+------------------+--------------------------------------------------------------------------------------+---------------------------------------------------------+
| paramValues      | Un objet Map des paramètres de la requête http (toutes les valeurs des paramètres)   | request.getParameterValues()                            |
+------------------+--------------------------------------------------------------------------------------+---------------------------------------------------------+
| initParam        | Un objet Map des paramètresd'initialisation de l'application (ServletContext)        | config.getServletContext().getInitParameter()           |
+------------------+--------------------------------------------------------------------------------------+---------------------------------------------------------+
| header           | Un objet Map des paramètres de la requête http (première valeur de chaque entête)    | request.getHeader()                                     |
+------------------+--------------------------------------------------------------------------------------+---------------------------------------------------------+
| headerValues     | Un objet Map des paramètres de la requête http (toutes les valeurs des entêtes)      | request.getHeaders()                                    |
+------------------+--------------------------------------------------------------------------------------+---------------------------------------------------------+
| cookie           | Un objet Map des cookies de la requête http                                          | request.getCookies()                                    |
+------------------+--------------------------------------------------------------------------------------+---------------------------------------------------------+

1. L'objet "pageContext"
   La variable "pageContext" peut être utilisée pour accéder aux propriétés de l'instance PageContext de la page JSP.
   Les règles pour accéder aux propriétés de l'objet sont celles vues avec les operateurs "." et "[]" pour accéder aux propriétés d'un objet bean s'appliquent aussi pour cette variables.
   Donc toutes les méthodes de la classe PageContext qui respectent la nomenclature JavaBeans sont accessibles.
   Par exemple, la classe PageContext déclare la méthode getRequest() qui retourne un objet de type ServletRequest qui lui-même déclare la méthode getServerName().
   Cette méthode est accessible comme suit :
   

   pageContext.getRequest().getServerName(): ${pageContext.request.serverName}

2. Les objets "pageScope", "requestScope", "sessionScope", "applicationScope"
   Ces variables référencent des objets, de type Map, qui donnent accès aux attributs des scopes "PAGE", "REQUEST", "SESSION", et "APPLICATION".
   

   ${requestScope.attr0}

   Notes : Comme ces objets sont de type Map, donc les même règles, vues pour les operateurs "." et "[]" pour accéder aux éléments d'une Map, s'appliquent aussi pour ces variables.
   

   ${sessionScope["attr0"]["attr1"]}

   Notes : Il est possible d'accéder aux attributs de ces 4 scopes sans expliciter le scope, par exemple ${attr0}, dans ce cas la recherche est faite en utilisant la fonction "findAttribute" de la classe "PageContext" ${PageContext.findAttribute("attr0") qui va chercher l'attribut dans ces 4 scopes.
3. Les objets "param", "paramValues"
   Ces variables référencent des objets, de type Map, qui donnent accès aux paramètres de la requête http.
   La variable "param" peut être utilisée pour lire la valeur d'un paramètre.
   La variable "paramValues" représente chaque paramètre par un tableau qui contient toutes les valeurs du paramètre, cela est utile pour lire les valeurs d'un paramètre qui a plusieurs valeurs.
   Si la variable "param" est utilisée avec un paramètre à plusieurs valeur, alors la valeur lue est celle du premier élément du tableau du paramètre référencé par la variable "paramValues".
   

   ${param.myparam1}
   
   ${paramValues.myparam2[1]}
   ${paramValues.myparam2[2]}

   Notes : Comme ces objets sont de type Map, donc les même règles, vues pour les operateurs "." et "[]" pour accéder aux éléments d'une Map, s'appliquent aussi pour ces variables.
   
4. L'objet "initParam"
   Cette variable donne accès aux paramètres d'initialisation de l'application (ServletContext).

   ${initParam.myinitparam1}

   Notes : Comme cet objet est de type Map, donc les même règles, vues pour les operateurs "." et "[]" pour accéder aux éléments d'une Map, s'appliquent aussi pour cette variable.
   
5. Les objets "header", "headerValues"
   Ces variables référencent des objets, de type Map, qui donnent accès aux entêtes de la requête http.
   La variable "header" peut être utilisée pour lire la valeur d'un entête.
   La variable "headerValues" représente chaque entête par un tableau qui contient toutes les valeurs de l'entête, cela est utile pour lire les valeurs d'un entête qui a plusieurs valeurs.
   Si la variable "header" est utilisée avec un entête à plusieurs valeur, alors la valeur lue est celle du premier élément du tableau de l'entête référencé par la variable "headerValues".
   

   ${header.myheader1}
   
   ${headerValues.myheader2[1]}

   Notes : Comme ces objets sont de type Map, donc les même règles, vues pour les operateurs "." et "[]" pour accéder aux éléments d'une Map, s'appliquent aussi pour ces variables.
   
6. L'objet "cookie"
   Cette variable donne accès aux paramètres des cookies de la requête http.
   

   ${cookie.mycookieparam1}

   Notes : Comme cet objet est de type Map, donc les même règles, vues pour les operateurs "." et "[]" pour accéder aux éléments d'une Map, s'appliquent aussi pour cette variable.