Item | Description |
---|---|
Comments | Specified using ## or // and extend to the end of line, e.g.
## This is a comment // , e.g.
// This is a comment /*...*/ , e.g.
/* This is a multi-line comment */ |
Identifiers / variables | Must start with a-z , A-Z , _ or $ . Can then be followed by 0-9 , a-z , A-Z , _ or $ . e.g.
Variable names are case-sensitive, e.g. NOTE: JEXL does not support variables with hyphens in them, e.g. commons-logging // invalid variable name (hyphenated) logging from the variable commons
JEXL also supports my.dotted.var
N.B. the following keywords are reserved, and cannot be used as a variable name or property when using the dot operator: my.new.dotted.var // invalid ('new' is keyword) my['new'].dotted.var
|
Scripts | A script in Jexl is made up of zero or more statements. Scripts can be read from a String, File or URL. |
Statements | A statement can be the empty statement, the semicolon (; ) , block, assignment or an expression. Statements are optionally terminated with a semicolon. |
Block | A block is simply multiple statements inside curly braces ({, } ). |
Assignment | Assigns the value of a variable (my.var = 'a value' ) using a JexlContext as initial resolver. Both beans and ant-ish variables assignment are supported. |
Method calls | Calls a method of an object, e.g.
"hello world".hashCode() hashCode method of the "hello world" String. In case of multiple arguments and overloading, Jexl will make the best effort to find the most appropriate non ambiguous method to call. |
Literals
Item | Description |
---|---|
Integer Literals | 1 or more digits from 0 to 9 |
Floating point Literals | 1 or more digits from 0 to 9 , followed by a decimal point and then one or more digits from 0 to 9 . |
String literals | Can start and end with either ' or " delimiters, e.g.
"Hello world" 'Hello world' The escape character is |
Boolean literals | The literals true and false can be used, e.g.
val1 == true |
Null literal | The null value is represented as in java using the literal null , e.g.
val1 == null |
Array literal | A [ followed by one or more expressions separated by , and ending with ] , e.g.
[ 1, 2, "three" ] This syntax creates an JEXL will attempt to strongly type the array; if all entries are of the same class or if all entries are Number instance, the array literal will be an Furthermore, if all entries in the array literal are of the same class and that class has an equivalent primitive type, the array returned will be a primitive array. e.g. |
Map literal | A { followed by one or more sets of key : value pairs separated by , and ending with } , e.g.
{ "one" : 1, "two" : 2, "three" : 3, "more": "many more" } This syntax creates a |
Functions
Function | Description |
---|---|
empty | Returns true if the expression following is either:
empty(var1) |
size | Returns the information about the expression:
size("Hello") |
new | Creates a new instance using a fully-qualified class name or Class:
new("java.lang.Double", 10) Note that the first argument of In case of multiple constructors, Jexl will make the best effort to find the most appropriate non ambiguous constructor to call. |
ns:function | A JexlEngine can register objects or classes used as function namespaces. This can allow expressions like:
math:cosinus(23.0) |
Operators
Operator | Description |
---|---|
Boolean and | The usual && operator can be used as well as the word and , e.g.
cond1 and cond2 cond1 && cond2 |
Boolean or | The usual || operator can be used as well as the word or , e.g.
cond1 or cond2 cond1 || cond2 |
Boolean not | The usual ! operator can be used as well as the word not , e.g.
!cond1 not cond1 |
Bitwise and | The usual & operator is used, e.g.
33 & 4 |
Bitwise or | The usual | operator is used, e.g.
33 | 4 |
Bitwise xor | The usual ^ operator is used, e.g.
33 ^ 4 |
Bitwise complement | The usual ~ operator is used, e.g.
~33 |
Ternary conditional ?: | The usual ternary conditional operator condition ? if_true : if_false operator can be used as well as the abbreviation value ?: if_false which returns the value if its evaluation is defined, non-null and non-false, e.g.
val1 ? val1 : val2 val1 ?: val2 NOTE: The condition will evaluate to |
Equality | The usual == operator can be used as well as the abbreviation eq . For example
val1 == val2 val1 eq val2
|
Inequality | The usual != operator can be used as well as the abbreviation ne . For example
val1 != val2 val1 ne val2 |
Less Than | The usual < operator can be used as well as the abbreviation lt . For example
val1 < val2 val1 lt val2 |
Less Than Or Equal To | The usual <= operator can be used as well as the abbreviation le . For example
val1 <= val2 val1 le val2 |
Greater Than | The usual > operator can be used as well as the abbreviation gt . For example
val1 > val2 val1 gt val2 |
Greater Than Or Equal To | The usual >= operator can be used as well as the abbreviation ge . For example
val1 >= val2 val1 ge val2 |
Regex match =~ | The Perl inspired =~ operator can be used to check that a string matches a regular expression (expressed either a Java String or a java.util.regex.Pattern). For example "abcdef" =~ "abc.* returns true . |
Regex no-match !~ | The Perl inspired !~ operator can be used to check that a string does not match a regular expression (expressed either a Java String or a java.util.regex.Pattern). For example "abcdef" !~ "abc.* returns false . |
Addition | The usual + operator is used. For example
val1 + val2 |
Subtraction | The usual - operator is used. For example
val1 - val2 |
Multiplication | The usual * operator is used. For example
val1 * val2 |
Division | The usual / operator is used, or one can use the div operator. For example
val1 / val2 val1 div val2 |
Modulus (or remainder) | The % operator is used. An alternative is the mod operator. For example
5 mod 2 5 % 2 |
Negation | The unary - operator is used. For example
-12 |
Array access | Array elements may be accessed using either square brackets or a dotted numeral, e.g.
arr1[0] arr1.0 |
HashMap access | Map elements are accessed using square brackets, e.g.
map[0]; map['name']; map[var]; map['7'] map[7] map[0] map.0 |
Conditional
Operator | Description |
---|---|
if | Classic, if/else statement, e.g.
if ((x * 2) == 5) { y = 1; } else { y = 2; } |
for | Loop through items of an Array, Collection, Map, Iterator or Enumeration, e.g.
for(item : list) { x = x + item; } item and list are variables. The JEXL 1.1 syntax using foreach(item in list) is now deprecated. |
while | Loop until a condition is satisfied, e.g.
while (x lt 10) { x = x + 2; } |