EL Operators & Type Coercion

The examples need data in scope and nothing else, so a ServletContextListener puts a handful of values into application scope when the web application starts. The Book record is the one used in the rest of the section. Records are read as beans by the EL since version 6.0, so ${dune.title} works without getters.

Source: Jakarta Servlet 6.1 — 4.5 Context Attributes

Every page of the examples starts with the same directive, which is left out of the listings: <%@ page contentType="text/plain;charset=UTF-8" trimDirectiveWhitespaces="true" %>. It makes the response plain text so that the output below is exactly what curl printed, and it removes the blank lines left by directives. The name nothing that appears in many examples is deliberately not defined anywhere: an unknown identifier evaluates to null (the errorOnELNotFound switch that makes it an error is described on the configuration page). A value is called null in the rest of the page whenever it is null, whether through an unknown name, a missing map key or a property that returns null.

EL has five groups of operators and two structural ones. The word forms exist for two reasons: they avoid the entity references that <, > and & need in XML syntax (see Operators in XML Syntax), and they are the spelling XPath and ECMAScript users know. A symbol and its word form behave identically.

Source: Jakarta Expression Language 6.0 — 1.16 Operator Precedence

Three words from this table, empty, div and mod, cannot be used as identifiers; the full list is in Reserved Words and Identifiers. The operators +=, =, ; and -> were added in EL 3.0 (Java EE 7, 2013). A page written for JSP 2.0 to 2.2 knows only the arithmetic, relational, logical, empty and conditional operators, which is all that the books in the bibliography describe.

The operators are +, -, *, / (or div), % (or mod) and the unary minus. They work on integers (BigInteger and Long) and on floating-point numbers (BigDecimal and Double); every other numeric type, and a String, is converted first. The specification picks the working type for +, - and * from the operands:

Source: Jakarta Expression Language 6.0 — 1.7.1 Binary operators for addition, subtraction and multiplication

The other three operators have their own rules.

When both operands are null the result is the Long 0, and a single null operand counts as 0 (the coercion of null to a number is 0, see Type Coercion). An operation that throws, such as a Long remainder by zero, becomes an error.

The response (verified on Tomcat 11.0.26):

Source: Jakarta Expression Language 6.0 — 1.7 Arithmetic Operators

Reading the output against the rules:

The four pages each end with HTTP 500. The root causes of the exception report (Tomcat prints the page line and the cause of the failure) are:

Source: Jakarta Expression Language 6.0 — 1.7.3 Binary operator for remainder

Two lessons are in this output. First, the third line is the commonest mistake of everybody who comes from Java or JavaScript: + never concatenates. The operands of 'Dune' + ' (1965)' are parsed as numbers, and the parse fails. The concatenation operator is += (next section). Second, a number-conversion failure surfaces as a raw NumberFormatException from Long.valueOf and not as an ELException, while a Boolean operand is rejected with an ELException; handlers that map exceptions to pages must be ready for both. Whatever the type, the page never renders partially in this case: the container answers 500 (or the configured error page, see the error handling page).

${A += B} converts both operands to String and returns the concatenation. It exists because + is arithmetic only. A null operand becomes the empty String and an enum becomes its name(), so there is no NullPointerException and no "null" text, as there would be in Java.

Source: Jakarta Expression Language 6.0 — 1.8 String Concatenation Operator

The last line shows the precedence: += binds more loosely than binary +, so both additions run first (3 and 7) and the two numbers are then joined as "37". For readable pages keep the operands short and prefer c:out and fmt tags for anything that is displayed; += is best for building an attribute value such as a CSS class or a URL fragment.

The ordering operators <, >, <=, >= (lt, gt, le, ge) and the equality operators ==, != (eq, ne) return a Boolean. Their rules are tried top to bottom, and the first that matches decides the type of the comparison. The rule list is the key to the surprises, so it is reproduced as a table.

Source: Jakarta Expression Language 6.0 — 1.9.1 Ordering operators and 1.9.2 Equality operators

Source: Jakarta Expression Language 6.0 — 1.9 Relational Operators

Points the output makes concrete:

The cases where the rules produce an error rather than a false are worth seeing once.

Source: Jakarta Expression Language 6.0 — 1.9.2 Equality operators

Each failure follows from the rules. '1.0' eq 1 meets an integer (step 6), so both become Long, and "1.0" is not a Long. A Book record is not Comparable (step 8 finds neither side comparable), so lt between two books is an error; compare books[0].year lt books[1].year instead. A Character is an integer for step 6, which turns the String 'a' into a Long and fails, even though comparing a Character with a one-letter text is what the author meant; compare letter eq 97, or convert the text in Java. A String that does not name an enum constant fails (an empty String does not: ${status == ''} and ${status == nothing} print false and false). The last line shows that chained comparisons do not exist: 1 lt 2 lt 3 is (1 lt 2) lt 3, which compares a Boolean with 3. Write 1 lt 2 and 2 lt 3.

The BigDecimal rule deserves its own example because money values are the commonest BigDecimal in a page.

Source: Jakarta Expression Language 6.0 — 1.9.2 Equality operators

price is 12.50 (scale 2). == calls BigDecimal.equals, which is false for 12.50 and 12.5, so ${price == 12.50} is false too: the literal 12.50 is a Double that is converted to BigDecimal as 12.5. The ordering operators use compareTo, so le and ge both say "equal". To test a BigDecimal for equality in a page, use price le x and price ge x, or a Double-free string (price eq '12.50' has the same scale), or do the comparison in Java. The last two lines show the same trap in arithmetic: a numeric literal such as 0.1 is a Double, and converting it to a BigDecimal exposes the binary expansion of 0.1; the quoted '0.1' is converted to a BigDecimal from its text and stays exact.

&& (and), || (or) and ! (not) coerce their operands to Boolean. The binary operators stop as soon as the result is known: in A and B and C, if B is false then C is never evaluated. The unary ! applies to the operand that follows.

Source: Jakarta Expression Language 6.0 — 1.10 Logical Operators

The coercion to Boolean (section 1.25.5) is lenient for Strings and strict for numbers. A null or empty String is false; the text "true", in any letter case, is true; any other text is false and not an error ('yes' and true is false), because Boolean.valueOf never throws. A number is an error, as the following two pages show.

Source: Jakarta Expression Language 6.0 — 1.25.5 Coerce A to Boolean or boolean

Short-circuit evaluation is a safety feature as much as an optimisation. ${not empty param.q and fn:length(param.q) gt 3} never evaluates the call when the parameter is absent, and ${false and (1/0 lt 1)} never reaches the division. The guard has to be on the left of the operator.

${empty A} is true when A is null, an empty String, an empty array, an empty Map or an empty Collection; otherwise it is false. It is a prefix operator, so it can be combined with not or ! to ask the opposite question.

Source: Jakarta Expression Language 6.0 — 1.11 Empty Operator

The details that matter in practice: a string of spaces is not empty, 0 and false are not empty, and empty books[5] is true because a list index outside the list is null in EL (not an error). The operator returns true for a request parameter that is absent and also for one that is present but blank in the query string (?q=), so a search page cannot tell "no filter" from "empty filter" with it. empty gives the standard guard for a missing value: ${empty param.q ? 'all books' : param.q}; remember to wrap anything printed from a parameter in c:out (the next sections and the pitfalls explain why). Its precedence is the same as unary minus and not, so ${not empty param.q and copies gt 0} means (not (empty param.q)) and (copies gt 0).

${A ? B : C} coerces A to Boolean and evaluates and returns B when it is true and C when it is false; the branch that is not selected is never evaluated. It is right associative, so a chain of tests needs no parentheses.

Source: Jakarta Expression Language 6.0 — 1.12 Conditional Operator

Two details. The result type is the type of the branch that ran: ${true ? 1 : 2.5} is the integer 1, not 1.0 as in Java, because EL does no numeric promotion between the branches. And the test is a Boolean coercion, so the String "true" is true and the empty String and null are false. The Elvis operator ?: that many languages have (a default for a null or empty value) does not exist in EL 6.0; the specification project lists it for EL 6.1 (see What Changed Recently). Until then use ${empty x ? 'default' : x}.

The conditional has one parsing trap, which the specification describes in section 1.16: a namespace prefix makes a colon part of a qualified function name, and qualified functions bind tighter than any operator.

The page is not translated; the first request fails with:

Source: Jakarta Expression Language 6.0 — 1.16 Operator Precedence

copies:count() is read as the function count in the namespace copies. Put spaces around the colon, or parentheses around the call (${c ? b : (f())}). Without a call following the colon there is no problem, and the page ops/cond2.jsp printed 3 for ${yes ? copies:count} and for ${yes ? copies : count}.

EL 3.0 added two operators that change state, both designed for the stand-alone ELProcessor and for lambdas, and both available in a page.

What a bare name means to = is decided by the resolvers. In a page, the Pages ScopedAttributeELResolver sets the attribute in whichever scope already holds that name, searching page, request, session and application (the scopes page has the details), and creates a page-scope attribute only if no scope has the name.

Source: Jakarta Expression Language 6.0 — 1.13 Assignment Operator and 1.14 Semicolon Operator

An assignment prints its value, which is why ${x = 5} shows up in the page; ${z = 1; ''} is the idiom for "assign and print nothing". The nastiest consequence is the existing-name rule, which is not what a reader of the specification text alone would expect:

Source: Jakarta Pages 4.0 API — ScopedAttributeELResolver.setValue

A single = typed where == was meant overwrites the shared application attribute for every user until the web application restarts, and the second request proves it: the "stock" value is now 99 for everyone. pageScope.copies stays empty because the write went to the scope that held the name. Treat a page that contains a bare = as code that changes the model, review it as such, and never build an expression with = from request data (see Security Notes). Targets that are not writable fail instead:

Source: Jakarta Expression Language 6.0 — 1.13 Assignment Operator

The precedence table in The Operators at a Glance is the specification’s, highest first; operators on one row have equal precedence. All binary operators are left associative except ? :, = and ->, which are right associative. When the order is not obvious, add parentheses: (...) is free and never changes the type of the result.

Source: Jakarta Expression Language 6.0 — 1.15 Parentheses and 1.16 Operator Precedence

Reading the table against the output: && binds tighter than || (true || false && false is true || (false && false)), which is why a third operand needs parentheses to be read correctly; not binds tighter than ||, so not true || true is (not true) || true; relational operators bind tighter than equality (1 < 2 == true is (1 < 2) == true); and empty is a prefix operator with the same rank as not, so empty noBooks == true tests the emptiness and then compares the answer. Subtraction and division associate left (10 - 2 - 3 is 5, 100 / 10 / 5 is 2.0). The two += lines show that concatenation comes after addition.

Sixteen words are reserved by section 1.17 and cannot be used as identifiers: and, or, not, eq, ne, lt, gt, le, ge, div, mod, empty, true, false, null and instanceof. Some of them are operators today; others, instanceof, are held back for future use and are already off limits. A name that collides cannot be read with the dot syntax, but the bracket syntax with a String does work:

The first two lines print ten and both. Each of the last three fails when the page is translated, before any output is produced, with HTTP 500 and:

Source: Jakarta Expression Language 6.0 — 1.17 Reserved Words

The same failure happens for any syntactically invalid expression: section 2.8 of the Pages specification requires a translation error for an invalid EL expression in an attribute value or in template text, and ${1 + } fails with the same Failed to parse the expression message. The practical rules are to avoid the sixteen words as names of attributes, map keys and bean properties (a property called empty or div is reachable only through the bracket form), and never to name a scoped variable empty, not or and.

Source: Jakarta Pages 4.0 — 2.8 Invalid EL Expressions

JSP documents (.jspx, covered on the JSP documents page) are XML, so < and & in an expression must be written as < and &; in an attribute value a bare < is not allowed at all. The word forms exist to avoid that.

Source: Jakarta Expression Language 6.0 — 1.9 Relational Operators (the word forms)

The XML parser decodes the entities before EL sees the text, so the expression is evaluated as copies < 5. Writing lt, gt, le, ge, and and or in JSP documents, tag files in XML syntax and Facelets-style XML pages avoids the escaping altogether, and is a good habit even in plain .jsp pages when the expression sits in an attribute.

Every expression is evaluated in the context of an expected type: an operator expects numbers, a Boolean or a String; a tag attribute expects the type in its TLD; a method call expects the parameter type. The result of the sub-expression rarely matches, so section 1.25 defines how a value X becomes a type Y. The first step is to find a custom converter: an ELResolver can implement convertToType, and the resolvers in the chain are asked in order. Only when no resolver converts does the default conversion run.

Source: Jakarta Expression Language 6.0 — 1.25 Type Conversion

A primitive target is coerced as its box type and then unboxed; if the box is null, the conversion is an error. In practice null becomes 0 and "" becomes 0 or false for primitive targets, which section 1.25.1 spells out.

The following page uses most operators for something a catalogue page does: it reads a page number, computes the slice of books to show, labels each row and offers previous and next links. It uses empty and the conditional operator for the default, arithmetic and lt for the slice, mod for the row style, a nested conditional for the label, and +/- in the link targets.

curl for /g4elops/shelf.jsp, /g4elops/shelf.jsp?page=2 and /g4elops/shelf.jsp?page=3:

Source: Jakarta Tags 3.0 — c:forEach and c:set

Notes on the page. param.page + 0 is the idiom for "this parameter, as a number": it turns the text "2" into the Long 2 so that page - 1 and page + 1 do arithmetic and the links print the numbers 1 and 3. An absent or empty parameter is covered by empty param.page, but a parameter that is not a number (?page=abc) still ends in NumberFormatException: For input string: "abc" and an HTTP 500: validate numeric input in a servlet or filter, or in a tag that catches the error (c:catch), before the page reads it. The third response is the other trap: ?page=3 is a valid number past the end of the data, and the page announces "Showing 5 to 3 of 3" with an empty list. The operators cannot clamp the value without a Math.min, so compute the page range in the controller and hand the view the numbers. The titles are printed through c:out; the ${book.year} in text is a number and needs no escaping, which is not true of ${param.q} or of any text typed by a user.

Source: Jakarta Pages 4.0 — 2.9 Errors, Warnings, Default Values

Source: OWASP — Cross Site Scripting Prevention Cheat Sheet

Source: Jakarta Expression Language 6.0 — A.1 Changes between 6.0 and 5.0

Source: Jakarta Expression Language 6.0 — A.2 Changes between 5.0 and 4.0

Source: Jakarta Expression Language 6.0 — A.3 Changes between 4.0 and JSR 341

Source: Jakarta Expression Language 6.1 (under development)

The specification text still carries small leftovers of older Java versions: section 1.7.2 refers to the constant BigDecimal.ROUND_HALF_UP (deprecated since Java 9; the 3.13 seen above is the half-up result), and section 1.25.3 describes conversions with the deprecated new Short(...) style constructors. The behaviour is what matters and it is as described.

The section bibliography lists JSTL in Action (Manning, 2002), which teaches the expression language of JSTL 1.0 on JSP 1.2, and Web Development with JavaServer Pages (Manning, 2001), which predates the EL. The operator concepts the first one teaches (the arithmetic, comparison and logical operators with their word forms, empty and null) are still exactly right; what has moved is where the EL may be used, the number of operators, and the platform.

Source: Manning — JSTL in Action

Source: Manning — Web Development with JavaServer Pages, Second Edition