The catch tag is used to catch any java.lang.Throwable exception in the body of the tag. The syntax of the catch tag is as follows:

<c:catch [var="variable_name"]>
    JSP body content
</c:catch>

The catch tag has one attribute:

An example of the catch tag is listed here:

<c:catch var="exp">
  <c:import url="http://www.foobar.com/stuff.html"/>
</c:catch>
<c:if test="${not empty exp}">
  Sorry, unable to import from URL, got exception <c:out value="${exp}" />
</c:if>

The choose tag is used to provide conditional operation, and allows for choosing between mutually exclusive options. The actual selection is done using its subtags: when and otherwise. The syntax of the choose tag is shown here:

<c:choose>
  <c:when test="expression">
    JSP body content
  </c:when>
  ...
  <c:otherwise>
    JSP body content
  </c:otherwise>
</c:choose>

An example of the choose tag is as follows:

<c:choose>
  <c:when test="${userrole} == 'admin'}">
    Welcome admin. Proceed to your admin page <a href="/admin">here</a>
  </c:when>
  <c:when test="${userrole} == 'member'}">
    Welcome member. Proceed to your home page <a href="/memberhome">here</a>
  </c:when>
  <c:otherwise>
    Welcome guest. Log in <a href="/login">here</a>.
  </c:otherwise>
</c:choose>

The if tag evaluates a test condition. If it is true, it processes its body. If the test condition is false, the body is ignored. The syntax of the if tag is shown here:

<c:if test="test condition>
      [var="variable name"]
      [scope="page|request|session|application"]>
    JSP body content
</c:if>

The if tag has three attributes:

An example of the if tag is listed here:

<c:if test="${not empty exp}">
  Sorry, unable to import from URL, got exception <c:out value="${exp}" />
</c:if>

The import tag imports a resource specified by a URL and exposes it to the page, variable, or reader. It is similar to the <jsp:include> directive, but with more features. The body of the import tag can have param tags for adding parameters to the URL. The syntax for the tag is shown here:

<c:import url="resource URL"
          [var="variable name"]
          [scope="page|request|session|application"]
          [varReader="variable name"]
          [context="context name"]
          [charEncoding="character encoding"]>
     JSP body content
</c:import>

The import tag has six attributes:

An example of the import tag is listed here:

<c:import url="http://www.foobar.com/stuff.html"/>

The forEach tag is used for iteration over collections. The syntax of the forEach tag is shown here:

<c:forEach [items="collection of items"]
           [begin="begin index"]
           [end="end index"]
           [step="step size"]
           [var="variable name"]

[varStatus="status variable name"]>
     JSP body content
</c:forEach>

The forEach tag has six attributes:

An example of the forEach tag is listed here:

<ul>
      <c:forEach items="${list}" var="listItem" varStatus="status">
          <li><c:out value="${listItem}"/></li>
      </c:forEach>
  </ul>

The forTokens tag is used for iterating over tokens separated by a delimiter. The syntax of the forTokens tag is shown here:

<c:forTokens items="string of tokens"
             delims="delimiter characters"
            [begin="begin index"]
            [end="end index"]
            [step="step size"]
            [var="variable name"]
            [varStatus="status variable name"]>
     JSP body content
</c:forTokens>

The forTokens tag has seven attributes:

An example of the forTokens tag is listed here:

<ul>
      <c:forTokens items="${list}" delims =":" var="listItem" varStatus="status">
          <li><c:out value="${listItem}"/></li>
      </c:forTokens>
  </ul>

The out tag is used to output the result of an expression. It functions similarly to the <%= ... => JSP syntax. The syntax of the out tag is shown here:

<c:out value="expression"
       [default="default expression value"]
       [escapeXml="true|false"]>
   JSP body content
</c:out>

The out tag has three attributes:

An example of the out tag is listed here:

<ul>
      <c:forTokens items="${list}" delims =":" var="listItem" varStatus="status">
          <li><c:out value="${listItem}"/></li>
      </c:forTokens>
  </ul>

The otherwise tag is used for conditional evaluation of its body. It is a subtag of the choose tag and executes only if none of the when tags evaluate to true. The syntax of the otherwise tag is shown here:

<c:otherwise>
    JSP body content
</c:otherwise>

An example for the otherwise tag is listed here:

<c:choose>
  <c:when test="${userrole} == 'admin'}">
    Welcome admin. Proceed to your admin page <a href="/admin">here</a>
  </c:when>
  <c:when test="${userrole} == 'member'}">
    Welcome member. Proceed to your home page <a href="/memberhome">here</a>
  </c:when>
  <c:otherwise>
    Welcome guest. Log in <a href="/login">here</a>.
  </c:otherwise>
</c:choose>

The param tag is used along with the import, redirect, or url tags to add a parameter to a URL. The syntax of the param tag is shown here:

<c:param name="parameter name" [value="parameter value"]>
    JSP body content
</c:param>

The param tag has two attributes:

An example for the param tag is listed here. This generates a URL of the form http://www.google.com/search?q=<search term>.

<c:url value="http://www.google.com/search">
  <c:param name="q" value="${searchTerm}"/>
</c:url>

The redirect tag redirects the user to a new URL. The body of the redirect tag can have param tags for adding parameters to the URL. The syntax for the tag is shown here:

<c:redirect url="resource URL>
            [context="context name"]>
    JSP body content
</c:redirect>

The redirect tag has two attributes:

An example of the redirect tag is listed here:

<c:catch var="exp">
  <c:import url="http://www.foobar.com/stuff.html"/>
</c:catch>
<c:if test="${not empty exp}">
  <c:redirect url="/error.jsp"/>
</c:if>

The remove tag removes a variable from a scope. The syntax of the remove tag is shown here:

<c:remove var="variable name"
          [scope="page|request|session|application"] />

The remove tag has two attributes:

An example of the remove tag is listed here:

<c:remove var="foobar"/>

The set tag sets a variable or a property to the value of an expression. The syntax of the set tag is shown here:

<c:set   [var="variable name"]
         [value="expression"]
         [target="JavaBean or Map object name"]
         [property="target property name"]

[scope="page|request|session|application"] >
    JSP body content
</c:set>

The set tag has five attributes:

An example of the set tag is listed here:

<c:set var="index" value="1" scope="page" />

The url tag creates a URL. The body of the url tag can have param tags for adding parameters to the URL. The syntax for the tag is shown here:

<c:url   [var="variable name"]
         [scope="page|request|session|application"]
         [value="url"]
         [context="context name"]>
    JSP body content
</c:url>

The url tag has four attributes:

An example of the url tag is listed here:

<c:url value="http://www.google.com/search">
  <c:param name="q" value="${searchTerm}"/>
</c:url>

The when tag is used for conditional evaluation of its body. It is a subtag of the choose tag, and its body is included only if the test condition is true. The syntax of the otherwise tag is shown here:

<c:when test="test condition" >
    JSP body content
</c:when>

The when tag has one attribute:

An example of the when tag is listed here:

<c:choose>
  <c:when test="${userrole} == 'admin'}">
    Welcome admin. Proceed to your admin page <a href="/admin">here</a>
  </c:when>
  <c:when test="${userrole} == 'member'}">
    Welcome member. Proceed to your home page <a href="/memberhome">here</a>
  </c:when>
  <c:otherwise>
    Welcome guest. Log in <a href="/login">here</a>.
  </c:otherwise>
</c:choose>

The choose tag is used to provide conditional operation and allows for choosing between mutually exclusive options. The actual selection is made using its subtags: when and otherwise. The syntax of the choose tag is shown here:

<x:choose>
  <x:when test="XPath expression">
    JSP body content
  </x:when>
  ...
  <x:otherwise>
    JSP body content
  </x:otherwise>
</x:choose>

An example of the choose tag is listed here:

<x:choose>
  <x:when select="message[.= 'warning']">
    An error occurred.
  </x:when>
  <x:when select="message[.= 'fatal']">
    A fatal error occurred.
  </x:when>
  <x:otherwise>
    Welcome guest. Log in <a href="/login">here</a>.
  </x:otherwise>
</x:choose>

The forEach tag is used for iterating over collections. The syntax of the forEach tag is shown here:

<x:forEach select="XPath expression"
           [begin="begin index"]
           [end="end index"]
           [step="step size"]
           [var="variable name"]
           [varStatus="status variable name"]>
     JSP body content
</x:forEach>

The forEach tag has six attributes:

An example of the forEach tag is listed here:

<x:forEach select="$rssDocument//*[name()='item']">
  <li>
      <a href="<x:out select="./*[name()='link']"/>">
      <x:out select="./*[name()='title']" escapeXml="false"/>
      </a>
  </li>
</x:forEach>

The if tag evaluates a test XPath expression; if it is true, it processes its body. If the test condition is false, the body is ignored. The syntax of the if tag is shown here:

<x:if select="XPath expression"
      [var="variable name"]
      [scope="page|request|session|application"]>
    JSP body content
</x:if>

The if tag has three attributes:

An example of the if tag is listed here:

<x:if select="message[.= 'warning']">
    An error occurred.
</x:if>

The otherwise tag is used for conditional evaluation of its body. It is a subtag of the choose tag and executes only if none of the when tags evaluates to true. The syntax of the otherwise tag is as follows:

<x:otherwise>
    JSP body content
</x:otherwise>

An example of the otherwise tag is listed here:

<x:choose>
  <x:when select="message[.= 'warning']">
    An error occurred.
  </x:when>
  <x:when select="message[.= 'fatal']">
    An fatal error occurred.
  </x:when>
  <x:otherwise>
    Welcome guest. Log in <a href="/login">here</a>.
  </x:otherwise>
</x:choose>

The out tag is used to output the result of an XPath expression. It functions similarly to the <%= ... => JSP syntax. The syntax of the out tag is shown here:

<x:out select="XPath expression"
       [escapeXml="true|false"] />

The out tag has two attributes:

An example of the out tag is listed here:

<x:out select="./*[name()='title']" escapeXml="false"/>

The param tag is used along with the transform tag to add a parameter to the transformer. The syntax of the param tag is shown here:

<x:param name="parameter name" [value="parameter value"]>
   JSP body content
</x:param>

The param tag has two attributes:

An example of the param tag is listed here:

<x:transform xml="${xmlDoc}" xslt="${styleSheet}">
    <param name="id" value="${idvalue}" />
</x:transform>

The parse tag is used to parse XML data specified either via an attribute or in the tag body. The syntax of the parse tag is shown here:

<x:parse [var="variable name"]
         [varDom="variable name"]
         [scope="page|request|session|application"]
         [scopeDom="page|request|session|application"]
         [doc="XML document"]
         [systemId="system identifier URI"]
         [filter="filter"]>
   JSP body content
</x:parse>

The parse tag has seven attributes:

The parse tag also has an attribute called xml, which has been deprecated; the doc attribute should be used instead.

An example of the parse tag is listed here:

<c:import var="rssFeed" url=" "http://www.theserverside.com/rss/theserverside-servletsjsp-rss2.xml"/>
<x:parse var="rssDocument" xml="${rssFeed}"/>

The set tag sets a variable to the value of an XPath expression. The syntax of the set tag is shown here:

<x:set   var="variable name"
         [select="XPath expression"]
         [scope="page|request|session|application"]/>

The set tag has three attributes:

An example of the set tag is listed here:

<x:set var="firstTitle"
       select="$rssDocument//*[name()='channel']/*[name()='title'][1]}"/>

The transform tag applies an XSL transformation on a XML document. The syntax for the tag is shown here:

<x:set   [var="variable name"]
         [scope="page|request|session|application"]
         [result=""]
         [doc=""]
         [docSystemId=""]
         [xslt=""]
         [xsltSystemId=""]>
JSP body content
</x:set>

The transform tag has seven attributes:

The transform tag also has attributes called xml and xmlSystemId that have been deprecated; doc and docSystemId should be used instead.

An example of the transform tag is listed here:

<c:import var="rssFeed" url=" "http://www.theserverside.com/rss/theserverside-
servletsjsp-rss2.xml"/>
<c:import var="rssToHtml" url="/WEB-INF/xslt/rss2html.xsl"/>
<x:transform xml="${rssFeed}" xslt="${rssToHtml}"/>

The when tag is a subtag of choose, and it evaluates its body when the expression used in it is true. The syntax for the tag is shown here:

<x:when   select="XPath expression">
  JSP body content
</x:when>

The when tag has one attribute:

An example of the when tag is listed here:

<x:when select="message[.= 'warning']">
    An error occurred.
  </x:when>

The bundle tag loads a resource bundle for the body of the tag. The body usually contains a nested fmt:message tag to display a localized message. The syntax of the tag is shown here:

<fmt:bundle  basename="resource bundle basename"
             [prefix="message key prefix"]>
    JSP body content
</fmt:bundle>

The bundle tag has two attributes:

An example of the bundle tag is listed here:

<fmt:bundle basename="com.wrox.webapps.ErrorBundle">
    <fmt:message key="com.wrox.webapps.ErrorBundle.loginError"/>
</fmt:bundle>

The formatDate tag formats date and time data according to a specified style and pattern. The syntax of the tag is shown here:

<fmt:formatDate  value="string representation"
                 [type="date|time|both"]
                 [dateStyle="formatting style"]
                 [timeStyle="formatting style"]
                 [pattern="formatting pattern"]
                 [timeZone="timezone"]
                 [var="variable name"]
                 [scope="page|request|session|application"] />

The formatDate tag has eight attributes:

An example of the formatDate tag is listed here:

The job posting time is <fmt:formatDate value="${timeValue}" pattern="h:mm a zz"/>.

The formatNumber tag formats a numeric value as a number, currency, or a percentage in a locale-specific manner. The syntax of the tag is shown here:

<fmt:formatNumber   [value="numeric value"]
                    [type="number|currency|percentage"]
                    [pattern="pattern"]
                    [currencyCode="currency code"]
                    [currencySymbol="currency symbol"]
                    [groupingUsed="true|false"]
                    [maxIntegerDigits="max integer digits"]
                    [minIntegerDigits="min integer digits"]
                    [maxFranctionDigits="max fractional digits"]
                    [minFractionDigits="min fractional digits"]
                    [var="variable name"]
                    [scope="page|request|session|application"]>
    JSP body content
</fmt:formatNumber>

The formatNumber tag has 12 attributes:

An example of the formatNumber tag is listed here:

This item costs <fmt:formatNumber value="1000" type="currency"/>.

The message tag displays a localized message. The body can contain a nested fmt:param tag to pass parameterized values to the message. The syntax of the tag is shown here:

<fmt:message [key="message key"]
             [bundle="localization bundle where key is looked up"]
             [var="variable that stores localized message"]
             [scope="page|request|session|application"]>
    JSP body content
</fmt:message>

The message tag has four attributes:

An example of the message tag is listed here:

<fmt:bundle basename="com.wrox.webapps.ErrorBundle">
    <fmt:message key="com.wrox.webapps.ErrorBundle.loginError"/>
</fmt:bundle>

The param tag is nested within a fmt:message tag to pass parameterized values to the message. The syntax of the tag is shown here:

<fmt:param   [value="argument value"] >
    JSP body content
</fmt:param>

The param tag has one attribute:

An example of the param tag is listed here:

<fmt:message key="com.wrox.webapps.Messages.helloMessage">
    <fmt:param value="${user.Name}"/>
</fmt:message>

The parseDate tag parses string representations of date and time specified either via an attribute or in its body content. The syntax of the tag is shown here:

<fmt:parseDate   [value="string representation"]
                 [type="date|time|both"]
                 [dateStyle="formatting style"]
                 [timeStyle="formatting style"]
                 [pattern="formatting pattern"]
                 [timeZone="timezone"]
                 [parseLocale="locale"]
                 [var="variable name"]
                 [scope="page|request|session|application"]>
    JSP body content
</fmt:parseDate>

The parseDate tag has nine attributes:

An example of the parseDate tag is listed here:

<c:set var="dateString">1/1/05 12:00 PM</c:set>
<fmt:parseDate value="${dateString}" parseLocale="en_US" type="both"
               dateStyle="short" timeStyle="short" var="usDate"/>

The parseNumber tag parses a string representation of a number, currency, or a percentage specified either via an attribute or in its body content. The syntax of the tag is shown here:

<fmt:parseNumber   [value="string representation"]
                   [type="number|currency|percentage"]
                   [pattern="pattern"]
                   [parseLocale="locale"]
                   [integerOnly="true|false"]
                   [var="variable name"]
                   [scope="page|request|session|application"]>
    JSP body content
</fmt:parseNumber>

The parseNumber tag has seven attributes:

An example of the parseNumber tag is listed here:

<fmt:parseNumber value="${salePrice}" parseLocale="en_US" type="currency"/>

The requestEncoding tag sets the character encoding for the request. The syntax of the tag is shown here:

<fmt:requestEncoding  [value="character encoding name"] />

The requestEncoding tag has one attribute:

An example of the requestEncoding tag is listed here:

<fmt:requestEncoding value="UTF-8"/>

The setBundle tag loads a resource bundle for a specified scope (as compared to the bundle tag, which loads it only for its body). The syntax of the tag is shown here:

<fmt:setBundle  basename="resource bundle basename"
             [var="Localization context variable"]
             [scope="page|request|session|application"] />

The setBundle tag has three attributes:

An example of the setBundle tag is listed here:

<fmt:setBundle basename="com.wrox.webapps.ErrorBundle"/>

The setLocale tag sets the locale value in the locale configuration variable. The syntax of the tag is shown here:

<fmt:setLocale  value="Locale string"
                    [variant="Vendor or browser specific variant"]
                    [scope="page|request|session|application"]
                    />

The setLocale tag has three attributes:

An example of the setLocale tag is listed here:

<fmt:setLocale value="en"/>

The setTimeZone tag sets the time zone value in the time zone configuration variable for a specified scope (as compared to the timeZone tag, which sets it only for its body content). The syntax of the tag is shown here:

<fmt:setTimeZone  value="Time Zone string"
                      [var="time zone variable"]
                      [scope="page|request|session|application"]
                    />

The setTimeZone tag has three attributes:

An example of the setTimeZone tag is listed here:

<fmt:setTimeZone value="GMT-8"/>

The timeZone tag specifies the time zone for any time formatting in its body content. The syntax of the tag is shown here:

<fmt:timeZone  value="time zone">
         JSP body content
    </fmt:timeZone>

The timeZone tag has one attribute:

An example of the timeZone tag is listed here:

<fmt:timeZone value="GMT-8">
         ...
    </fmt:timeZone>

The dateParam tag is embedded in the body of a query or update tag. It is used to pass java.util.Date parameters to a SQL statement. The syntax of the tag is shown here:

<sql:dateParam  value="date parameter value"
                   [type="date|time|timestamp"] />

The dateparam tag has the following attributes:

An example of the dateParam tag is listed here:

<sql:query sql="select * from employee where join_date > ?">
    <sql:dateParam value="${cutoff_date}" type="date"/>
  </sql:query>

The param tag is embedded in the body of a query or update tag. It is used to pass parameters to a SQL statement. The syntax of the tag is shown here:

<sql:param [value="parameter value"]>
         JSP body content
    </sql:param>

The param tag has one attribute:

An example of the param tag is listed here:

<sql:query sql="select * from employee where salary > ?">
    <sql:param value="${min_salary}"/>
  </sql:query>

The query tag executes an SQL query statement specified either via an attribute or embedded in the body of the tag. A query tag can have nested param tags to pass parameters to the SQL statement. The syntax of the tag is shown here:

<sql:query  var="variable name"
            [scope="page|request|session|application"]
            [sql="SQL query statement"]
            [startRow="starting row"]
            [maxRows="maximum number of rows"]
            [dataSource="DataSource"]>
    JSP body content
</sql:query>

The query tag has six attributes:

An example of the query tag is listed here:

<sql:query sql="select * from employee where salary > ?">
    <sql:param value="${min_salary}"/>
  </sql:query>

Another example is as follows:

<sql:query var="roundlist"
  dataSource="jdbc:mysql://localhost/footydb,com.mysql.jdbc.Driver,footy,footy">
  SELECT * from round
</sql:query>

The setDataSource tag creates a DataSource for connecting to the database. The syntax for this tag is shown here:

<sql:setDataSource [var="variable name"]
                   [scope="page|request|session|application"]
                   [driver="JDBC driver"]
                   [url="JDBC URL for database"]
                   [user="Username to connect to the database"]
                   [password="Password to connect to the database"]
                   [dataSource="DataSource"]/>

The setDataSource tag has seven attributes:

An example of the setDataSource tag is listed here:

<sql:setDataSource  url="jdbc:mysql:///taglib"
                    driver="org.gjt.mm.mysql.Driver"
                    user="admin"
                    password="secret"/>
<sql:query sql="select * from employee where salary > ?">
  <sql:param value="${min_salary}"/>
</sql:query>

Other SQL tags are nested within a transaction tag. The tag provides them with a shared connection object and allows all the nested tags to run as one transaction. The syntax of the transaction tag is shown here:

<sql:transaction [dataSource="DataSource"]
       [isolation="read_committed|read_uncommitted|repeatable_read|serializable"] >
    JSP body content
</sql:transaction>

The transaction tag has two attributes:

An example of the transaction tag is listed here:

<sql:transaction>
  <sql:update sql="update employee set salary = ? where emp_id = ?">
    <sql:param value="${new_salary}"/>
    <sql:param value="${empId}"/>
  </sql:update>
  <sql:update sql="update employee set salary_deductions = ? where emp_id = ?">
    <sql:param value="${new_deductions}"/>
    <sql:param value="${empId}"/>
  </sql:update>
</sql:transaction>

The update tag executes an SQL update statement specified either via an attribute or embedded in the body of the tag. An update tag can have nested param tags to pass parameters to the SQL statement. The syntax of the tag is shown here:

<sql:update [var="variable name"]
            [scope="page|request|session|application"]
            [sql="SQL update statement"]
            [dataSource="DataSource"]>
    JSP body content
</sql:update>

The update tag has four attributes:

An example of the update tag is listed here:

<sql:update>
      UPDATE round SET startdate = ?, enddate = ?
      WHERE number = ?
      <sql:param value="${param.round_startdate}" />
      <sql:param value="${param.round_enddate}" />
      <sql:param value="${param.round_number}" />
    </sql:update>

The contains function determines whether an input string contains a specified substring. The syntax of the function is shown here:

boolean contains(java.lang.String, java.lang.String)

An example of the contains function is listed here:

<c:if test="${fn:contains(theString, searchString)}">

The containsIgnoreCase function determines whether an input string contains a specified substring. The syntax of the function is shown here:

boolean containsIgnoreCase(java.lang.String, java.lang.String)

An example of the containsIgnoreCase function is listed here:

<c:if test="${fn:containsIgnoreCase(theString, searchString)}">

The endsWith function determines whether an input string ends with a specified suffix. The syntax of the function is shown here:

boolean endsWith(java.lang.String, java.lang.String)

An example of the endsWith function is listed here:

<c:if test="${fn:endWith (theString, suffix)}">

The escapeXml function escapes characters that can be interpreted as XML markup. The syntax of the function is shown here:

java.lang.String escapeXml(java.lang.String)

An example of the escapeXml function is listed here:

${fn:escapeXml(xmlContainingText)}

The indexOf function returns the index within a string of a specified substring. The syntax of the function is shown here:

int indexOf(java.lang.String, java.lang.String)

An example of the indexOf function is listed here:

${fn:indexOf(theString, searchString)}

The join function concatenates all the elements of an array into a string with a specified separator. The syntax of the function is shown here:

String join (java.lang.String[], java.lang.String)

An example of the join function is listed here:

Your Path settings should be ${fn:join(filenamesArray, ";")}.

The length function returns the string length or the number of items in a collection. The syntax of the function is shown here:

int length(java.lang.Object)

An example of the length function is listed here:

There are ${fn:length(shoppingCart.Items)} items in your shopping cart.

The replace function replaces all occurrences of a string with another string. The syntax of the function is shown here:

boolean replace(java.lang.String, java.lang.String, java.lang.String)

An example of the replace function is listed here:

The CLASSPATH for Windows is ${fn:replace(classpathString, ":", ";")}.

The split function splits a string into an array of substrings based on a delimiter string. The syntax of the function is shown here:

java.lang.String[] split(java.lang.String, java.lang.String)

An example of the split function is listed here:

${fn:split(theString, delimiterString)}

The startsWith function determines whether an input string starts with a specified substring. The syntax of the function is shown here:

boolean startsWith(java.lang.String, java.lang.String)

An example of the startsWith function is listed here:

<c:if test="${fn:startsWith(theString, prefixString)}">

The substring function returns a subset of a string specified by start and end indices. The syntax of the function is shown here:

java.lang.String substring(java.lang.String, int, int)

An example of the substring function is listed here:

${fn:substring(theString, beginIndex, endIndex)}

The substringAfter function returns the part of a string after a specified substring. The syntax of the function is shown here:

java.lang.String substringAfter(java.lang.String, java.lang.String)

An example of the substringAfter function is listed here:

${fn:substringAfter(theString, substring)}

The substringBefore function returns the part of a string before a specified substring. The syntax of the function is shown here:

java.lang.String substringBefore(java.lang.String, java.lang.String)

An example of the substringBefore function is listed here:

${fn:substringBefore(theString, substring)}

The toLowerCase function converts all the characters of a string to lowercase. The syntax of the function is shown here:

java.lang.String toLowerCase(java.lang.String)

An example of the toLowerCase function is listed here:

${fn:toLowerCase(theString)}

The toUpperCase function converts all the characters of a string to uppercase. The syntax of the function is shown here:

java.lang.String toUpperCase(java.lang.String)

An example of the toUpperCase function is listed here:

${fn:toUpperCase(theString)}

The trim function removes white space from both ends of a string. The syntax of the function is shown here:

java.lang.String trim(java.lang.String)

An example of the trim function is listed here:

${fn:trim(theString)}