BeginnersBook-JSTL-教程-一-

BeginnersBook JSTL 教程（一）

原文：BeginnersBook

协议：CC BY-NC-SA 4.0

JSTL<c:catch>核心标签

原文： https://beginnersbook.com/2013/11/jstl-ccatch-core-tag/

<c:catch> JSTL 标签用于异常处理。之前我们分享了如何在 JSP 中进行异常处理 - 两种方式。在这篇文章中，我们将使用<c:catch>核心标签讨论异常处理。

语法：

<c:catch var ="variable_name">
 //Set of statements in which exception can occur
</c:catch>

variable_name可以是存储异常消息的任何变量。如果<c:catch>中包含的语句中发生异常那么这个变量包含异常消息。让我们借助一个例子来理解这一点。

例

在这个例子中，我们故意通过将整数除以零来抛出算术异常，然后我们使用表达式语言（EL）打印errormsg变量（包含异常消息）。

注：如果<c:catch>中的语句块中没有异常那么变量（例如它的errormsg）应该具有空值。这就是我们在打印变量值之前检查errormsg != null的原因。

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<html>
<head>
<title>JSTL c:catch Core Tag Example</title>
</head>
<body>
<%! 
int num1=10;
int num2=0; %>
<c:catch var ="errormsg">
  <% int res = num1/num2;
  out.println(res);%>
</c:catch>
<c:if test = "${errormsg != null}">
  <p>There has been an exception raised in the above
  arithmetic operation. Please fix the error.
  Exception is: ${errormsg}</p>
</c:if>
</body>
</html>

输出：

c-catch-example

JSTL<c:import>核心标签

原文： https://beginnersbook.com/2013/11/jstl-cimport-core-tag/

JSTL<c:import>标签用于将内容从另一个文件/页面导入到当前的 JSP 页面。

语法：

<c:import var="variable_name" url="relative_url"/>

这里variable_name是一个存储从另一个 URL 导入的数据的变量。relative_url是需要导入的文件/页面的地址。

<c:import>的属性

  • url：这是强制属性，需要始终提及。
  • var：如果未指定，则为可选属性，然后导入的数据将打印在当前页面上。对于例如声明<c:import url ="/ file.jsp"/>会在客户端（浏览器）上打印file.jsp的数据。
  • scope：它也是可选的。如果我们使用var属性，那么scope可以与它一起使用来指定存储在变量中的数据的范围。

例

这是一个包含一些数据的页面。我们将在index.jsp页面中导入此页面。

display.jsp

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<c:out value="Chaitanya"/>
<c:out value="BeginnersBook.com" />
<c:out value="This is just a String" />

index.jsp

这里我们将display.jsp中的数据导入变量mydata，然后我们使用<c:out>标签在浏览器上显示它。

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<html>
<head>
<title> JSTL c:import Tag Example</title>
</head>
<body>
<c:import var="mydata" url="/display.jsp"/>
<c:out value="${mydata}"/>
</body>
</html>

输出屏幕：

c-import-example

JSTL<c:forEach>和<c:forTokens>核心标签

原文： https://beginnersbook.com/2013/11/jstl-cforeach-and-cfortokens-core-tags/

JSTL 中的<c:forEach>标签用于执行有限次数的同一组语句。它类似于 java 中的for循环。当我们需要一次又一次地执行（执行）一组语句指定的次数时，基本上使用它。

<c:forTokens>也用于迭代，但它只适用于分隔符，这意味着使用此标签我们可以根据分隔符将输入数据分成多个部分。我们将在本文的一个例子的帮助下理解这一点。

<c:forEach>标签

<c:forEach>的语法

<c:forEach var="counter_variable_name" begin="intial_value" end="final_limit">
    //Block of statements
</c:forEach>

以下是<c:forEach>的三个主要属性。标签。

begin：初始计数器值。
end：循环执行的最终限制
var：计数器变量名

例

在这个例子中，我们使用<c:forEach>在循环中打印变量计数器的值。标签。循环从值 1 开始（在begin属性中提到）并且在值 10（end属性的值）处结束。

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<html>
<head>
<title>Example c:forEach tag in JSTL</title>
</head>
<body>
<c:forEach var="counter" begin="1" end="10">
 <c:out value="${counter}"/>
</c:forEach>
</body>
</html>

输出：

c-forEach-example

<c:forTokens>标签

<c:forTokens>语法

<c:forTokens items="value(s)" delims="delimiter" var="variable_name">
 //Set of statements
</c:forTokens>

以下是<c:forTokens>的三个主要属性。标签。

items：数据值集。
delims：分隔符可以有任何值。它可以是数字，字符串或特殊字符。
var：存储子字符串的变量名。

示例

在这个例子中，我们使用分隔符点（'.'）将字符串拆分为多个子字符串。

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<html>
<head>
<title>Example c:forTokens tag in JSTL</title>
</head>
<body>
<c:forTokens items="www.beginnersbook.com" delims="." var="site">
 <c:out value="${site}"/>
</c:forTokens>
</body>
</html>

输出：

c-forTokens-example

JSTL<c:param>核心标签

原文： https://beginnersbook.com/2013/11/jstl-cparam-core-tag/

<c:param> JSTL 标签主要与<c:url>一起使用。和<c:redirect>标签。基本上它将参数及其值添加到这些标签的输出中。在本教程中，我们将看到<c:param>标签可以与<c:url>和<c:redirect>标签一起使用。

语法：

<c:param name="parameter_name" value="parameter_value"/>

<c:param>的属性标签

  • name：指定参数的名称。
  • value：指定参数的值。

<c:param>的示例

在这个例子中，我们使用<c:param>标签用于将参数添加到结果 URL。

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<html>
<head>
<title>JSTL c:param Tag Example</title>
</head>
<body>
<c:url value="/mypage.jsp" var="completeURL">
 <c:param name="Id" value="736"/>
 <c:param name="user" value="chaitanya"/>
</c:url>
${completeURL}
</body>
</html>

输出：

c-param-example

实施例 2：<c:param>在<c:redirect>中使用标签

这里我们使用<c:param>标签传递参数以及重定向网址，然后我们使用表达式语言的param变量在重定向页面上显示这些参数。

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<html>
<head>
<title>c:param Example2</title>
</head>
<body>
<c:redirect url="/display.jsp" >
 <c:param name="UserId" value="222"/>
 <c:param name="UserName" value="ChaitanyaSingh"/>
</c:redirect>
${completeURL}
</body>
</html>

display.jsp

USER ID IS: ${param.UserId}
USER NAME IS: ${param.UserName}

输出：

c-param-example2

JSTL<c:url>核心标签

原文： https://beginnersbook.com/2013/11/jstl-curl-core-tag/

<c:url> JSTL 标签**用于网址格式，或者您可以说网址编码。这主要用于需要根据用户输入或基于变量值打开 JSP 页面时。它基本上将相对 url 转换为应用上下文的 url。现在可能听起来很混乱，但是按照本教程中给出的示例，您将能够很容易地掌握它。

语法：

基本语法如下所示 - 属性value是<c:url>标签的必需属性。

<c:url value="/file1.jsp" />

此标签还有三个可选属性，如下所示：

  • var：用于存储格式化 url（生成 url）的变量名。
  • context：用于指定应用（或项目名称）。不明白吗？我们将在稍后的示例的帮助下看到这一点。
  • scope：将存储var属性的范围。它可以是请求，页面，应用或会话。

让我们通过一个例子来理解这个标签和属性的使用：

示例 1：<c:url>的值属性

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<html>
<head>
<title>JSTL c:url Tag Example</title>
</head>
<body>
<c:url value="/file1.jsp"/>
</body>
</html>

输出：上面的代码输出如下。注意：BeginnersBook是我的项目名称（换句话说是 JSP 应用名称）。

/BeginnersBook/file1.jsp

c-url-example1

示例 2：<c:url>标签的var属性

让我们像这样修改示例 1。我们在<c:url>中添加了一个变量myurl。现在<c:url>的结果将存储在变量myurl中。

<c:url var="myurl" value="/file1.jsp"/>
${myurl}

输出：

/BeginnersBook/file1.jsp

示例 3：上下文属性

默认情况下，此标签将当前应用作为上下文，但是我们可以在c url中明确指定上下文，如下例所示：

注意：上下文的值应始终以/开头，否则您将收到以下异常消息：

HTTP 状态 500 - javax.servlet.ServletException：javax.servlet.jsp.JspTagException：在 URL 标签中，当指定“context”属性时，“context”和“url”的值必须以“/”开头。

<c:url var="myurl" value="/file1.jsp" context="/MyJSPProject"/>
${myurl}

输出：

/MyJSPProject/file1.jsp

c-url-example2

示例 4：scope属性

<c:url var="myurl" value="/file1.jsp" context="/MyJSPProject" scope="session"/>
${requestScope.myurl}

输出：输出屏幕将为空白，因为我们已将myurl存储在会话范围内，我们正在尝试从requestScope获取后打印该值。

正确用法：这是应该编码的方式。这里我们存储在会话中并从sessionScope中获取，因此它可以正常工作。

<c:url var="myurl" value="/file1.jsp" context="/MyJSPProject" scope="session"/>
${sessionScope.myurl}

输出：

/MyJSPProject/file1.jsp

JSTL<c:redirect>核心标签

原文： https://beginnersbook.com/2013/11/jstl-credirect-core-tag/

<c:redirect>用于将当前页面重定向到另一个 URL。

语法：

<c:redirect url="http://www.anydomainhere.com/samplepage.jsp"/>

这是<c:redirect>的方式。标签看起来像。我们只需要在此标签的 URL 属性中提供相对地址，页面将自动重定向加载时提供的 URL。

例

在这里，我们根据变量myurl的值将页面重定向到不同的 URL。如果值为 1，则页面将重定向到http://beginnersbook.com，对于 2，它将转到http://www.google.com。

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<html>
<head>
<title> JSTL c:redirect Tag Example</title>
</head>
<body>
  <c:set var="myurl" value="2" scope="request"/>
  <c:if test="${myurl<1}">
     <c:redirect url="http://beginnersbook.com"/>
  </c:if>
  <c:if test="${myurl>1}">
     <c:redirect url="http://www.google.com"/>
  </c:if>
</body>
</html>

输出：由于变量myurl的值为 2，因此页面将定向到http://www.google.com。

JSTL 函数

fn:contains() - JSTL 函数

原文： https://beginnersbook.com/2013/12/fncontains-jstl-function/

fn:contains()函数检查给定字符串是否作为子字符串存在于输入中。它执行区分大小写检查，这意味着它在检查子字符串时会考虑这种情况。

语法：

boolean fn:contains(String inputstring, String checkstring)

该函数的返回类型是boolean。当输入字符串中存在检查字符串时返回true，否则返回false。它有两个字符串参数 - 第一个有输入字符串，第二个参数有需要在输入字符串中检查的字符串。

fn:contains()的例子

在此示例中，我们检查新密码是否包含旧密码作为子字符串，如果是，则我们向用户显示消息。

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn" %>
<html>
<head>
<title>fn:contains example</title>
</head>
<body>
<c:set var="oldPassword" value="HelloPass"/>
<c:set var="newPassword" value="HelloPassNew" />
<c:if test="${fn:contains(newPassword, oldPassword)}">
 <c:out value="New Password should not contain old password as substring"/>
</c:if>
</body>
</html>

输出：

fn-contains-example

fn:containsIgnoreCase() - JSTL 函数

原文： https://beginnersbook.com/2013/12/fn-containsignorecase-jstl-function/

在上一个教程中，我们了解了fn:contains()函数，它用于区分大小写的检查。在这篇文章中，我们将看到fn:containsIgnoreCase()函数，它执行不区分大小写的检查以查看提供的字符串是否是输入的子字符串。

语法：

boolean fn:containsIgnoreCase(String input, String checkstring)

该函数的返回类型是boolean。与fn:contains()函数一样，它也接收两个字符串参数，并检查第一个字符串（第一个参数）中是否存在第二个字符串。它在评估期间不考虑大小写。

fn:containsIgnoreCase()的示例

在这个例子中，我们有两个字符串 - ·string1和string2。我们正在检查string1中是否存在string2。如果结果为true，那么我们正在显示一条消息。

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn" %>
<html>
<head>
<title>fn:containsIgnoreCase() example</title>
</head>
<body>
<c:set var="string1" value="Hi This is CHAITANYA from BeginnersBook.com"/>
<c:set var="string2" value="chaitanya" />
<c:if test="${fn:containsIgnoreCase(string1, string2)}">
 <c:out value="Case Insensitive Check: String1 contains string2"/>
</c:if>
</body>
</html>

输出：

fn-containsIgnoreCase-example

JSTL 核心标签

fn:indexOf() - JSTL 函数

原文： https://beginnersbook.com/2013/12/fn-indexof-jstl-function/

fn:indexOf()函数用于查找提供的字符串中字符串的起始位置（索引）。

语法

int indexOf(String,  String )

此函数的返回类型为int。它返回第一个字符串（函数的第一个参数）中第二个字符串（函数的第二个参数）的起始位置（或索引）。

注意事项：

  • 当输入字符串中找不到字符串时，函数返回 -1。
  • 功能区分大小写。它将同一字母表的大写和小写字符视为不同。
  • 它返回第一次出现的索引，这意味着如果字符串在输入中存在多于一次，则函数将返回第一次出现的索引。参考例子。

fn:indexOf()函数的示例

在这个例子中，我们找到几个字符串的索引并使用 EL 显示它们。

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn" %>
<html>
<head>
<title>JSTL fn:indexOf() example</title>
</head>
<body>
${fn:indexOf("My name is Chaitanya Singh", "chaitanya")}
${fn:indexOf("My name is Chaitanya Singh", "Chaitanya")}
${fn:indexOf("This is an example", "is")}
${fn:indexOf("JSTL function - indexOf function", "function")}
</body>
</html>

输出：

fn-indexOf-example

fn:escapeXml() - JSTL 函数

原文： https://beginnersbook.com/2013/12/fn-escapexml-jstl-function/

fn:escapeXml()JSTL 函数用于 HTML / XML 字符转义，这意味着它将 html / xml 标签视为字符串而不是标签。它类似于<c:out>标签的 escapeXml属性x。让我们在一个例子的帮助下理解这一点：

语法

String escapeXml(String input_string)

转义 html / xml 标签标签后，将input_string转换为输出字符串。

  • 函数返回类型是String
  • 参数：input_string

fn:escapeXml()示例

这里我们有两个字符串，其 html 标签为粗体（<b>）和斜体（<i>）。我们正在使用 fn:escapeXml()函数处理它们。

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn" %>
<html>
<head>
<title>JSTL fn:escapeXml() example</title>
</head>
<body>
Message1: <b>Hi This is just a message</b>
<br>Message2: <i>This is an example</i>
<br>Message1 and fn:escapeXml(): ${fn:escapeXml("<b>Hi This is just a message</b>")}
<br>Message2 and fn:escapeXml(): ${fn:escapeXml("<i>This is an example</i>")}
</body>
</html>

输出：

正如您在输入字符串上使用函数时所看到的那样，html 标签不起作用并按原样打印，就像另一个普通字符串一样。

fn-escapeXml-example

fn:join()和 fn:split()JSTL 函数

原文： https://beginnersbook.com/2013/12/fn-join-and-fn-split-jstl-functions/

在本教程中，我们将看到 JSTL 的 fn:join()和 fn:split()函数。

fn:join()

它将字符串与给定的分隔符连接起来并返回输出字符串。

语法

String fn:join(String arrayofstrings, String separator)

它连接输入数组的所有元素以及它们之间提供的分隔符。此函数的返回类型是String，它在连接后返回输出字符串。

示例 - 使用fn:join()函数连接字符串

在这个例子中，我们有一个字符串数组，我们使用分隔符（'&'）连接它们。

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn" %>
<html>
<head>
<title>JSTL fn:join() example</title>
</head>
<body>
<%
String arr[]={"Chaitanya", "Rahul", "Ajeet"};
session.setAttribute("names", arr);
%>
${fn:join(names, " & ")}
</body>
</html>

输出：

正如你所看到的那样，所有这三个名字之间都加上了&。

strings-join-example

fn:split()

它将给定的字符串拆分为子串数组。拆分过程考虑我们在函数调用期间提供的定界符字符串。即我们提供字符串和分隔符作为函数的参数，并在根据分隔符字符串拆分输入后返回字符串数组。

语法

String[] fn:split(String inputstring, String delimiterstring)

示例 - 使用fn:split()函数连接字符串

在这个例子中，我们有一个输入字符串，其间的空格字符很少。我们使用fn:split()函数将空格分隔为分隔符。该函数返回子字符串的数组。

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn" %>
<html>
<head>
<title>JSTL fn:split() example</title>
</head>
<body>
<c:set var="msg" value="This is an example of JSTL function"/>
<c:set var="arrayofmsg" value="${fn:split(msg,' ')}"/>
<c:forEach var="i" begin="0" end="6">
 arrayofmsg[${i}]: ${arrayofmsg[i]}<br>
</c:forEach>
</body>
</html>

输出：

splitting-of-string

fn:length() - JSTL 函数

原文： https://beginnersbook.com/2013/12/fn-length-jstl-function/

JSTL 函数 fn:length()用于计算字符串的长度或查找集合中元素的数量。

语法

int length(Object)

此函数的返回类型为int。它返回作为参数提供的对象的长度。

fn:length()的示例

这里我们使用函数计算三个不同字符串的长度。

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn" %>
<html>
<head>
<title>JSTL fn:length() example</title>
</head>
<body>
<c:set var="string1" value="This is String1"/>
<c:set var="string2" value="Hi"/>
<c:set var="string3" value="string3"/>
Length of String1 is: ${fn:length(string1)}<br>
Length of String2 is: ${fn:length(string2)}<br>
Length of String3 is: ${fn:length(string3)}
</body>
</html>

输出：

fn-length-example

fn:trim()和 fn:startsWith()JSTL 函数

原文： https://beginnersbook.com/2013/12/fn-trim-and-fn-startswith-jstl-functions/

在这篇文章中，我们讨论了两个对字符串进行操作的函数。这些函数是fn:trim()和fn:startsWith()。函数fn:trim()从字符串的开头和结尾删除空格，fn:startsWith()检查指定的字符串是否是给定字符串的前缀。

JSTL fn:trim()函数

它从提供的字符串的开头和结尾删除空格字符。

语法：

String fn:trim(String input)

从String input的开头和结尾删除空格后，该函数返回字符串。

例

在这个例子中，我们有一个字符串，它在字符串"mymsg"的开头和结尾附加了很少的空格字符，我们正在使用该函数截断这些空格。

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn" %>
<html>
<head>
<title>fn:trim() example in JSTL</title>
</head>
<body>
<c:set var="mymsg" value=" This is the test String       "/>
${fn:trim(mymsg)}
</body>
</html>

输出截图：

trim-string-example

fn:startsWith()函数

它检查给定的字符串是否以特定的字符串值开头。

语法：

boolean fn:startsWith(String input, String prefix)

此函数返回一个布尔值。当字符串以给定前缀开头时它给出true，否则返回false。

示例

这里我们有一个长字符串和两个子字符串，我们正在检查字符串是否以任何子字符串开头。

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn" %>
<html>
<head>
<title>fn:startsWith example</title>
</head>
<body>
<c:set var="mymsg" value="Example of JSTL function"/>
The string starts with "Example": ${fn:startsWith(mymsg, 'Example')}
<br>The string starts with "JSTL": ${fn:startsWith(mymsg, 'JSTL')}
</body>
</html>

输出： PFB 上面例子的输出截图。

check-string-starting-from-given-string

fn:endsWith() - JSTL 函数

原文： https://beginnersbook.com/2013/12/fn-endswith-jstl-function/

fn:endsWith()函数用于检查字符串的后缀。它检查给定的字符串是否以特定字符串结尾。检查是区分大小写的。

语法

boolean fn:endsWith(input_string, suffix_string)

它验证input_string是否以suffix_string结尾。如果测试成功，则函数返回true，否则它给false。函数的返回类型是boolean，它接收两个字符串作为参数。

注意：它在进行检查时考虑了大小写。

fn 的例子：endsWith（）

在示例中，我们有一个输入字符串"BeginnersBook.com"和另外 4 个字符串。我们正在验证输入字符串是否以给定的四个字符串结束。

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn" %>
<html>
<head>
<title>JSTL fn:endsWith() example</title>
</head>
<body>
String ends with ".com": ${fn:endsWith("BeginnersBook.com", "com")}
<br>String ends with "book.com": ${fn:endsWith("BeginnersBook.com", "book.com")}
<br>String ends with "Book.com": ${fn:endsWith("BeginnersBook.com", "Book.com")}
<br>String ends with "Book.co": ${fn:endsWith("BeginnersBook.com", "Book.co")}
</body>
</html>

输出：

fn-endsWith-example

fn:substring()，fn:substringAfter()和fn:substringBefore()函数

原文： https://beginnersbook.com/2013/12/jstl-substring-substringafter-substringbefore-functions/

在本教程中，我们将讨论 JSTL 的``fn:substring()，fn:substringAfter()和 fn:substringBefore()函数。所有这些函数都用于从给定的输入字符串中获取字符串的一部分。在所有三个函数中获得输出的方式是不同的。

fn:substring()

此函数根据给定的开始和结束位置返回给定输入字符串的子字符串。

语法

String fn:substring(String inputstring, int start, int end)
  • 返回函数类型：String
  • inputstring：需要从中获取子字符串的字符串
  • start：子串的起始位置
  • end：子串的结束位置

示例 - fn:substring()函数

在这个例子中，我们通过提供子字符串的起始和结束位置从给定字符串中获取子字符串。

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn" %>
<html>
<head>
<title>JSTL fn:substring() example</title>
</head>
<body>
<c:set var="msg" value="This is an example of JSTL function"/>
${fn:substring(msg, 10, 26)}
</body>
</html>

输出：

substring-from-given-string

fn:substringAfter()

它返回给定字符串的一部分，该字符串位于提供的字符串值之后。

语法

String fn:substringAfter(String input, String afterstring)

在此函数返回afterstring之后输入中存在的内容。请参阅以下示例，以便更清楚地了解此主题。

fn:substringAfter()的示例

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn" %>
<html>
<head>
<title>JSTL fn:substringAfter() example</title>
</head>
<body>
<c:set var="name" value="Rahul Pratap Singh"/>
${fn:substringAfter(name, "Pr")}
</body>
</html>

输出：

substring-after-given-string

fn:substringBefore()

它与fn:substringAfter函数正好相反。它返回位于指定字符串值之前的原始字符串部分。

语法

String fn:substringBefore(String input, String beforestring)

beforestring之前的input部分将作为此函数的输出返回

fn:substringBefore()的示例

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn" %>
<html>
<head>
<title>JSTL fn:substringBefore() example</title>
</head>
<body>
<c:set var="justastring" value="Hi, How are you??"/>
${fn:substringBefore(justastring, "are")}
</body>
</html>

输出：

substring-before-a-given-term

JSTL<c:out>核心标签

原文： https://beginnersbook.com/2013/11/jstl-cout-core-tag/

<c:out>是一个 JSTL 核心标签，用于在浏览器（客户端）上显示服务器端变量和硬编码值。您可能想知道变量的值和数据可以使用表达语言（EL）和out隐式对象来显示，为什么我们需要<c:out> jstl 标签？区别在于<c:out>标签转义 HTML / XML 标签但其他标签没有，请参考示例来理解这一点。

标签<c:out>示例

在这个例子中，我们在浏览器上显示一个字符串，但是我们在值中使用了 html 标签，我们希望看到结果是什么以及它是如何使用 HTML 标签的。

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<html>
<head>
<title>c:out Tag Example</title>
</head>
<body>
<c:out value="${'<b>This is a <c:out> example </b>'}"/>
</body>
</html>

输出：

`<b>这是<c:out>示例</b>

c-out-example

<c:out>标签的escapeXml属性

假设我像这样修改上面的代码 - 我刚刚在标签中添加了escapeXML属性并将其标签为false。 默认情况下，escapeXML属性的值为true。由于我们将其标签为false，因此它不会转义 HTML / XML 标签，并且标签将起作用。

<c:out value="${'<b>This is a <c:out> example </b>'}" escapeXml="false"/>

输出：

c-out-example2

<c:out>标签的default属性

上面我们看到了<c:out>的escapeXML属性。标签。此标签还有另一个属性default，用于显示<c:out>的值为null时的后备或默认值。下面是我们尝试使用标签打印字符串str的值的示例，并且由于字符串str值为null，标签正在打印default属性中设置的值。

<%! String str = null; %>
<c:out value="${str}" default="default value of c:out"/>

c-out-example3

fn:toUpperCase() - JSTL 函数

原文： https://beginnersbook.com/2013/12/fn-touppercase-jstl-function/

它与fn:toLowerCase()函数正好相反。它将输入字符串转换为大写字符串。输入字符串的所有字符都被替换为相应的大写字符。需要更改的字符串作为函数的参数提供，并且函数返回转换后的字符串。我们可以将字符串作为变量传递，或者只是在函数调用期间对其进行硬编码。

语法

String fn:toUpperCase(String input)

它将输入字符串转换为大写后返回String。

fn:toUpperCase()的示例

在这里，我们使用该函数将少量字符串转换为其大写字母。

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn" %>
<html>
<head>
<title>fn:toUpperCase() example</title>
</head>
<body>
  <c:set var="site" value="BeginnersBook.com"/>
  <c:set var="author" value="Chaitanya"/>
  Hi This is ${fn:toUpperCase(author)} from ${fn:toUpperCase(site)}.
</body>
</html>

输出：

字符串"author"和"site"被所有大写字母替换。

fn-toUpperCase-example

fn:toLowerCase() - JSTL 函数

原文： https://beginnersbook.com/2013/12/fn-tolowercase-jstl-function/

此函数将字符串转换为小写字符串。输入字符串中的任何大写字符都将替换为相应的小写字符。

语法

String fn:toLowerCase(String  input)

返回类型：String；参数：String类型的单个参数。在将输入字符串转换为小写后返回一个String。

fn:toLowerCase()示例

在这个例子中，我们将这个函数应用于两个字符串 - 一个是字符串变量，另一个是硬编码字符串，作为函数的参数给出。正如您在输出中看到的那样，它已将变量的值和硬编码的字符串值替换为小写。在此代码之后提供输出的屏幕截图。

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn" %>
<html>
<head>
<title>fn:toLowerCase() example</title>
</head>
<body>
<c:set var="message" value="This is An Example of JSTL Function"/>
${fn:toLowerCase(message)}
${fn:toLowerCase("HELLO")}
</body>
</html>

输出：

fn-toLowerCase-example

fn:replace() - JSTL 函数

原文： https://beginnersbook.com/2013/12/fn-replace-jstl-function/

它在输入中搜索一个字符串，并用提供的字符串替换它。以下是fn:replace()函数的基本语法。

语法

String fn:replace(String input, String search_for, String replace_with)

三个字符串参数和返回类型也是String。它搜索input中的search_for字符串，并将其替换为replace_with字符串。如果未找到该字符串，则返回实际输入。

注：它区分大小写处理。

例

在这个例子中，我们在两个输入字符串上使用fn:replace()函数。

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn" %>
<html>
<head>
<title>JSTL fn:replace() example</title>
</head>
<body>
<c:set var="author" value="Chaitanya Singh"/>
<c:set var="randomstring" value="abc def abc ghi ABC"/>
${fn:replace(author, "Chaitanya", "Rahul")} 
${fn:replace(randomstring, "abc", "hello")}
</body>
</html>

输出：

观察输出，你会发现randomstring变量中的"ABC"保持不变，而其他"abc"子串被"hello"替换。它发生的原因是区分大小写，我们在上面的例子中替换了小写的"abc"。

fn-replace-example

JSTL<c:set>核心标签

原文： https://beginnersbook.com/2013/11/jstl-cset-core-tag/

<c:set>核心 JSTL 标签用于为指定范围内的对象或变量赋值。让我们用示例来理解这一点。

这里我将一个字符串值赋给应用范围中的变量name（它允许我在应用的任何 JSP 页面中访问我的变量）。在另一页（display.jsp）上，我使用<c:out>标签和 EL 在浏览器上打印了值。

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<html>
<head>
<title>Example of c:set tag</title>
</head>
<body>
<c:set var="name" scope="application" value="Chaitanya Pratap Singh"/>
<a href="display.jsp">Display</a>
</body>
</html>

display.jsp

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<c:out value="${name}"/>

输出：以下是上述示例输出的屏幕截图。

c-set-example

c-set-example2

<c:set>标签的属性

1）value：它可以是硬编码值或表达式。例如以下是<c:set>的允许变体标签：

变量myvar的值将存储在对象名称中。

<c:set var="name" scope="application" value="${myvar}"/>

表达式的结果将存储在对象中。

<c:set var="sum" scope="application" value="${1+3+6}"/>

2）var：它保存变量/对象名称

3）scope：可以是request，session，page和application。在上面的例子中，我们已将范围指定为应用，但它可以是上述四个范围之外的任何内容。这一切都取决于要求。

JSTL<c:delete>核心标签

原文： https://beginnersbook.com/2013/11/jstl-cremove-core-tag/

<c:delete>标签用于从指定范围或所有范围（页面，请求，会话和应用）中删除属性。

例

在下面的例子中，首先我使用<c:set>标签设置了两个变量，然后我使用<c:remove>删除了其中一个标签。正如您在输出屏幕截图中看到的那样 - 当我尝试显示两个变量时，对于第二个属性，页面没有获得任何值，并使用<c:out>标签](https://beginnersbook.com/2013/11/jstl-cout-core-tag/)的default属性打印默认值。

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<html>
<head>
<title>Example of c:remove tag</title>
</head>
<body>
<c:set var="Site" scope="session" value="BeginnersBook.com"/>
<c:set var="author" scope="session" value="Chaitanya"/>
<c:remove var="author"/>
<a href="display.jsp">check attributes</a>
</body>
</html>

display.jsp

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<c:out value="${Site}"/><br>
<c:out value="${author}" default="Attribute has no value"/>

c-remove-example

c-remove-example2

<c:remove>标签的scope属性

上面我们编码像这样

<c:remove var="author"/>

上面的代码从所有范围（页面，会话，应用，请求）中删除了一个属性。为了具体起见，我们必须在<c:remove>中指定scope属性，就像我在下面所做的那样 - 下面的 JSTL 语句将从会话范围中删除变量var。

<c:remove var="author" scope="session"/>

JSTL<c:if>核心标签

原文： https://beginnersbook.com/2013/11/jstl-cif-core-tag/

<c:if>是一个 JSTL 核心标签，用于测试条件。它更像或类似于 java 中的if语句，它评估条件并在结果为真时执行代码块。

语法：

这是<c:if>的基本语法核心标签。包含在<c:if>范围内的语句集如果为"true"，则执行标签。为了使用此标签，我们通常使用表达语言来评估关系表达式。我们使用 EL，因为它在评估条件后返回布尔值（true/false），我们需要test属性的布尔值。

<c:if test="${condition}">
...
..
</c:if>

<c:if>的示例标签

在该示例中，我们使用<c:set>标签定义了age变量。然后我们通过使用<c:if>来检查投票的资格。

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<html>
<head>
<title>JSTL c:if Tag Example</title>
</head>
<body>
<c:set var="age" value="26"/>
<c:if test="${age >= 18}">
 <c:out value="You are eligible for voting!"/>
</c:if>
<c:if test="${age < 18}">
 <c:out value="You are not eligible for voting!"/>
</c:if>
</body>
</html>

输出：

c-if-example

<c:if>属性

上面我们已经看到<c:if>的基本用法我们只使用test属性。然而，该标签还有另外两个可选属性，即var和scope。使用这些属性，您只需将测试结果存储在指定范围内的变量中。

  • var：将存储测试结果的变量名称。
  • scope：定义存储值的范围。对于例如如果是会话，则可以访问存储的var值，直到会话处于活动状态。

var和scope属性的示例

将测试结果存储在请求范围中的变量res中。为了打印我们给requestScope.res的值，因为变量存储在请求中，但是你甚至可以单独给出变量名（res），它可以正常工作。

<c:if test="${17 >= 18}" var="res" scope="request">
</c:if>
<c:out value="${requestScope.res}"/>

c-if-example2

JSTL<c:choose>，<c:when>，<c:otherwise>核心标签

原文： https://beginnersbook.com/2013/11/jstl-cchoose-cwhen-cotherwise-core-tags/

在本文中，我们讨论<c:choose>，<c:when>和<c:otherwise> JSTL 的核心标签。这些标签一起使用，如 java 中的switch-case和default语句。<c:choose>就像switch一样，<c:when>就像可以在里面多次使用的case，用于评估不同的两个条件。<c:otherwise>类似于默认语句，当所有<c:when>语句是false的。

语法：

基本结构看起来像这样：

<c:choose>
    <c:when test="${condition1}">
       //do something if condition1 is true
    </c:when>
    <c:when test="${condition2}">
        //do something if condition2 is true
    </c:when>
    <c:otherwise>
        //Statements which gets executed when all <c:when> tests are false.
    </c:otherwise>
</c:choose>

例

在这个例子中，我们有三个数字，我们使用这三个核心标签来比较它们。示例非常简单易懂。在示例代码之后提供输出的屏幕截图。

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<html>
<head>
<title>c:choose, c:when and c:otherwise Tag Example</title>
</head>
<body>
<c:set var="number1" value="${222}"/>
<c:set var="number2" value="${12}"/>
<c:set var="number3" value="${10}"/>
<c:choose>
 <c:when test="${number1 < number2}">
     ${"number1 is less than number2"}
 </c:when>
 <c:when test="${number1 <= number3}">
     ${"number1 is less than equal to number2"}
 </c:when>
 <c:otherwise>
     ${"number1 is largest number!"}
 </c:otherwise>
</c:choose>
</body>
</html>

输出：

c-choose-example

posted @ 2024-10-24 18:12  绝不原创的飞龙  阅读(7)  评论(0)  编辑  收藏  举报