Skip to content

B
beginnersbook-zh

OpenDocCN / beginnersbook-zh
10 个月 前同步成功

通知 0
Star 107
Fork 30
B
beginnersbook-zh

前往新版Gitcode，体验更适合开发者的 AI 搜索 >>

提交 a4011635 编写于 作者: W wizardforcel
浏览文件
操作

2019-08-05 16:26:13

上级 4565aedb
隐藏空白更改
内联 并排
Showing with 1789 addition and 0 deletion
docs/jstl/10.md 0 → 100644
浏览文件 @ a4011635
# JSTL＆lt; c：catch＆gt;核心标签
> 原文： [https://beginnersbook.com/2013/11/jstl-ccatch-core-tag/](https://beginnersbook.com/2013/11/jstl-ccatch-core-tag/)
**＆lt; c：catch＆gt; JSTL 标记**用于异常处理。之前我们分享了如何在 JSP 中进行异常处理 - 两种方式。在这篇文章中，我们将使用＆lt; c：catch＆gt;讨论异常处理。核心标签。
#### 句法：
```
<c:catch var ="variable_name">
//Set of statements in which exception can occur
</c:catch>
```
**variable_name** 可以是存储异常消息的任何变量。如果＆lt; c：catch＆gt;中包含的语句中发生异常那么这个变量包含异常消息。让我们借助一个例子来理解这一点。
#### 例
在这个例子中，我们故意通过将整数除以零来抛出算术异常，然后我们使用[表达式语言（EL）](https://beginnersbook.com/2013/11/jsp-expression-language-el/ "Expression language")打印 **errormsg** 变量（包含异常消息）。
**注**：如果＆lt; c：catch＆gt;中的语句块中没有异常那么变量（例如它的 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](../Images/a83be30c7e990aff0330787266c3bb71.jpg)
\ No newline at end of file
docs/jstl/11.md 0 → 100644
浏览文件 @ a4011635
# JSTL＆lt; c：import＆gt;核心标签
> 原文： [https://beginnersbook.com/2013/11/jstl-cimport-core-tag/](https://beginnersbook.com/2013/11/jstl-cimport-core-tag/)
JSTL＆lt; c：import＆gt; tag 用于将内容从另一个文件/页面导入到当前的 JSP 页面。
#### 句法：
```
<c:import var="variable_name" url="relative_url"/>
```
这里 **variable_name** 是一个存储从另一个 URL 导入的数据的变量。
**relative_url** 是需要导入的文件/页面的地址。
#### ＆lt; c：import＆gt;的属性
* **url** ：这是强制属性，需要始终提及。
* **var** ：如果未指定，则为可选属性，然后导入的数据将打印在当前页面上。对于例如声明＆lt; c：import url =“/ file.jsp”/＆gt;会在客户端（浏览器）上打印 file.jsp 的数据。
* **范围**：它也是可选的。如果我们使用 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** ，然后我们使用[＆lt; c：out＆gt;在浏览器上显示它。标签](https://beginnersbook.com/2013/11/jstl-cout-core-tag/)。
```
<%@ 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](../Images/2f51e8e7b311f5b39ad1673799d34137.jpg)
\ No newline at end of file
docs/jstl/12.md 0 → 100644
浏览文件 @ a4011635
# JSTL＆lt; c：forEach＆gt;和＆lt; c：forTokens＆gt;核心标签
> 原文： [https://beginnersbook.com/2013/11/jstl-cforeach-and-cfortokens-core-tags/](https://beginnersbook.com/2013/11/jstl-cforeach-and-cfortokens-core-tags/)
c 为 C：的 forEach＆GT; JSTL 中的 tag 用于执行有限次数的同一组语句。它类似于 java 中的 for 循环。当我们需要一次又一次地执行（执行）一组语句指定的次数时，基本上使用它。
c 为 C：forTokens＆GT;也用于迭代，但它只适用于分隔符，这意味着使用此标记我们可以根据分隔符将输入数据分成多个部分。我们将在本文的一个例子的帮助下理解这一点。
## c 为 C：的 forEach＆GT;标签
#### ＆lt; c：forEach＆gt;的语法
```
<c:forEach var="counter_variable_name" begin="intial_value" end="final_limit">
//Block of statements
</c:forEach>
```
以下是＆lt; c：forEach＆gt;的三个主要属性。标签。
**开始：**初始计数器值。
**结束：**循环执行的最终限制
**var** ：计数器变量名
#### 例
在这个例子中，我们使用＆lt; c：forEach＆gt;在循环中打印变量计数器的值。标签。循环从值 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](../Images/f64b9062fd9a8f34ee1a276a8a20d085.jpg)
## c 为 C：forTokens＆GT;标签
#### Syntax of &lt;c:forEach&gt;
```
<c:forTokens items="value(s)" delims="delimiter" var="variable_name">
//Set of statements
</c:forTokens>
```
以下是＆lt; c：forTokens＆gt;的三个主要属性。标签。
**项目：**数据值集。
**delims：**分隔符可以有任何值。它可以是数字，字符串或特殊字符。
**var** ：存储子字符串的变量名。
#### Example
在这个例子中，我们使用分隔符点（'。'）将字符串拆分为多个子字符串。
```
<%@ 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>
```
Output:
![c-forTokens-example](../Images/eb9859f97d25ab3f71f46a778aee80e5.jpg)
\ No newline at end of file
docs/jstl/13.md 0 → 100644
浏览文件 @ a4011635
# JSTL＆lt; c：forEach＆gt;和＆lt; c：forTokens＆gt;核心标签
> 原文： [https://beginnersbook.com/2013/11/jstl-cforeach-and-cfortokens-core-tags/](https://beginnersbook.com/2013/11/jstl-cforeach-and-cfortokens-core-tags/)
c 为 C：的 forEach＆GT; JSTL 中的 tag 用于执行有限次数的同一组语句。它类似于 java 中的 for 循环。当我们需要一次又一次地执行（执行）一组语句指定的次数时，基本上使用它。
c 为 C：forTokens＆GT;也用于迭代，但它只适用于分隔符，这意味着使用此标记我们可以根据分隔符将输入数据分成多个部分。我们将在本文的一个例子的帮助下理解这一点。
## c 为 C：的 forEach＆GT;标签
#### ＆lt; c：forEach＆gt;的语法
```
<c:forEach var="counter_variable_name" begin="intial_value" end="final_limit">
//Block of statements
</c:forEach>
```
以下是＆lt; c：forEach＆gt;的三个主要属性。标签。
**开始：**初始计数器值。
**结束：**循环执行的最终限制
**var** ：计数器变量名
#### 例
在这个例子中，我们使用＆lt; c：forEach＆gt;在循环中打印变量计数器的值。标签。循环从值 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](../Images/f64b9062fd9a8f34ee1a276a8a20d085.jpg)
## c 为 C：forTokens＆GT;标签
#### Syntax of &lt;c:forEach&gt;
```
<c:forTokens items="value(s)" delims="delimiter" var="variable_name">
//Set of statements
</c:forTokens>
```
以下是＆lt; c：forTokens＆gt;的三个主要属性。标签。
**项目：**数据值集。
**delims：**分隔符可以有任何值。它可以是数字，字符串或特殊字符。
**var** ：存储子字符串的变量名。
#### Example
在这个例子中，我们使用分隔符点（'。'）将字符串拆分为多个子字符串。
```
<%@ 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>
```
Output:
![c-forTokens-example](../Images/eb9859f97d25ab3f71f46a778aee80e5.jpg)
\ No newline at end of file
docs/jstl/14.md 0 → 100644
浏览文件 @ a4011635
# JSTL＆lt; c：param＆gt;核心标签
> 原文： [https://beginnersbook.com/2013/11/jstl-cparam-core-tag/](https://beginnersbook.com/2013/11/jstl-cparam-core-tag/)
**＆lt; c：param＆gt;** JSTL 标签主要与＆lt; c：url＆gt;一起使用。和＆lt; c：重定向＆gt;标签。基本上它将参数及其值添加到这些标记的输出中。在本教程中，我们将看到＆lt; c：param＆gt; tag 可以与＆lt; c：url＆gt;一起使用和＆lt; c：重定向＆gt;标签。
#### 句法：
```
<c:param name="parameter_name" value="parameter_value"/>
```
#### ＆lt; c：param＆gt;的属性标签
* **name：**指定参数的名称。
* **value** ：指定参数的值。
#### ＆lt; c：param＆gt;的示例
在这个例子中，我们使用＆lt; c：param＆gt;用于将参数添加到结果 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](../Images/e8995c40562c25bea6b7f6ef2e3457bc.jpg)
#### 实施例 2：＆lt; c：param＆gt;在＆lt; c：redirect＆gt;中使用标签
这里我们使用＆lt; c：param＆gt;传递参数以及重定向网址。标签，然后我们使用表达式语言的 [param 变量在重定向页面上显示这些参数。](https://beginnersbook.com/2013/11/jsp-expression-language-el/)
```
<%@ 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](../Images/4c26c4ce0b2126a3c4bfb01d2e0ae39d.jpg)
\ No newline at end of file
docs/jstl/15.md 0 → 100644
浏览文件 @ a4011635
# JSTL＆lt; c：url＆gt;核心标签
> 原文： [https://beginnersbook.com/2013/11/jstl-curl-core-tag/](https://beginnersbook.com/2013/11/jstl-curl-core-tag/)
**＆lt; c：url＆gt; JSTL 标签**用于网址格式，或者您可以说网址编码。这主要用于需要根据用户输入或基于变量值打开 JSP 页面时。它基本上将相对 url 转换为应用程序上下文的 url。现在可能听起来很混乱，但是按照本教程中给出的示例，您将能够很容易地掌握它。
#### 句法：
基本语法如下所示 - 属性“value”是＆lt; c：url＆gt;的必需属性。标签
```
<c:url value="/file1.jsp" />
```
此标签还有三个**可选属性**，如下所示 -
* **var** ：用于存储格式化 url（生成 url）的变量名。
* **context** ：用于指定应用程序（或项目名称）。不明白吗？我们将在稍后的示例的帮助下看到这一点。
* **scope** ：将存储 var 属性的范围。它可以是请求，页面，应用程序或会话。
让我们通过一个例子来理解这个标签和属性的使用 -
#### 示例 1：＆lt; c：url＆gt;的值属性
```
<%@ 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](../Images/502ca16ddd81c9d2f454179bd794e6e1.jpg)
#### 示例 2：＆lt; c：url＆gt;的 var 属性标签
让我们像这样修改示例 1。我们在＆lt; c：url＆gt;中添加了一个变量 myurl。现在＆lt; c：url＆gt;的结果将存储在变量 **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}
```
Output:
```
/MyJSPProject/file1.jsp
```
![c-url-example2](../Images/099d71dea158a8d13cf85ad8e4ad240f.jpg)
#### 示例 4：范围属性
```
<c:url var="myurl" value="/file1.jsp" context="/MyJSPProject" scope="session"/>
${requestScope.myurl}
```
输出：输出屏幕将为空白，因为我们已将 myurl 存储在[会话](https://beginnersbook.com/2013/11/jsp-implicit-object-session-with-examples/)范围内，我们正在尝试从 [requestScope](https://beginnersbook.com/2013/11/jsp-expression-language-el/) 获取后打印该值。
**正确用法：**这是应该编码的方式。这里我们存储在会话中并从 [sessionScope](https://beginnersbook.com/2013/11/jsp-expression-language-el/) 中获取，因此它可以正常工作。
```
<c:url var="myurl" value="/file1.jsp" context="/MyJSPProject" scope="session"/>
${sessionScope.myurl}
```
Output:
```
/MyJSPProject/file1.jsp
```
\ No newline at end of file
docs/jstl/16.md 0 → 100644
浏览文件 @ a4011635
# JSTL＆lt; c：重定向＆gt;核心标签
> 原文： [https://beginnersbook.com/2013/11/jstl-credirect-core-tag/](https://beginnersbook.com/2013/11/jstl-credirect-core-tag/)
c 为 C：重定向＆GT;用于将当前页面重定向到另一个 URL。
#### 句法：
```
<c:redirect url="http://www.anydomainhere.com/samplepage.jsp"/>
```
这是＆lt; c：redirect＆gt;的方式。标签看起来像。我们只需要在此标记的 **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。
\ No newline at end of file
docs/jstl/17.md 0 → 100644
浏览文件 @ a4011635
# JSTL 功能
\ No newline at end of file
docs/jstl/18.md 0 → 100644
浏览文件 @ a4011635
# fn：contains（） - JSTL 函数
> 原文： [https://beginnersbook.com/2013/12/fncontains-jstl-function/](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](../Images/d510515317259ddda2cb88fb1c435847.jpg)
\ No newline at end of file
docs/jstl/19.md 0 → 100644
浏览文件 @ a4011635
# fn：containsIgnoreCase（） - JSTL 函数
> 原文： [https://beginnersbook.com/2013/12/fn-containsignorecase-jstl-function/](https://beginnersbook.com/2013/12/fn-containsignorecase-jstl-function/)
在上一个教程中，我们了解了 [fn：contains（）函数](https://beginnersbook.com/2013/12/fncontains-jstl-function/)，它用于区分大小写的检查。在这篇文章中，我们将看到 **fn：containsIgnoreCase（）**函数，它执行不区分大小写的检查以查看提供的字符串是否是输入的子字符串。
#### 句法：
```
boolean fn:containsIgnoreCase(String input, String checkstring)
```
该函数的返回类型是 **boolean** 。与 fn：contains（）函数一样，它也接收两个字符串参数，并检查第一个字符串（第一个参数）中是否存在第二个字符串。它在评估期间不考虑这种情况。
#### fn 的示例：containsIgnoreCase（）
在这个例子中，我们有两个字符串 - string1＆amp;字符串 2。我们正在检查 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](../Images/a921915257c96fe49cdbb86e2a629155.jpg)
\ No newline at end of file
docs/jstl/2.md 0 → 100644
浏览文件 @ a4011635
# JSTL 核心标签
\ No newline at end of file
docs/jstl/20.md 0 → 100644
浏览文件 @ a4011635
# fn：indexOf（） - JSTL 函数
> 原文： [https://beginnersbook.com/2013/12/fn-indexof-jstl-function/](https://beginnersbook.com/2013/12/fn-indexof-jstl-function/)
**fn：indexOf（）函数**用于查找提供的字符串中字符串的起始位置（索引）。
#### 句法
```
int indexOf(String,  String )
```
此函数的返回类型为 int。它返回第一个字符串（函数的第一个参数）中第二个字符串（函数的第二个参数）的起始位置（或索引）。
**注意事项：**
* 当输入字符串中找不到**字符串**时，函数**返回-1** 。
* 功能区分大小写。它将同一字母表的大写和小写字符视为不同。
* 它返回**第一次出现**的索引，这意味着如果字符串在输入中存在多于一次，则函数将返回第一次出现的索引。参考例子。
#### fn：indexOf（）函数的示例
在这个例子中，我们找到几个字符串的索引并使用 [EL](https://beginnersbook.com/2013/11/jsp-expression-language-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](../Images/82931e0f045b0e9e3648ee785091f1fc.jpg)
\ No newline at end of file
docs/jstl/21.md 0 → 100644
浏览文件 @ a4011635
# fn：escapeXml（） - JSTL 函数
> 原文： [https://beginnersbook.com/2013/12/fn-escapexml-jstl-function/](https://beginnersbook.com/2013/12/fn-escapexml-jstl-function/)
fn：escapeXml（）JSTL 函数用于 HTML / XML 字符转义，这意味着它将 html / xml 标记视为字符串而不是标记标记。它类似于＆lt; c：out＆gt;的 [escapeXml 属性。标签](https://beginnersbook.com/2013/11/jstl-cout-core-tag/)。让我们在一个例子的帮助下理解这一点 -
#### 句法
```
String escapeXml(String input_string)
```
转义 html / xml 标记标记后，将 input_string 转换为输出字符串。
* 函数返回类型是 String
* 参数：输入字符串
#### fn：escapeXml（）示例
这里我们有两个字符串，其 html 标签为粗体（＆lt; b＆gt;）和斜体（＆lt; i＆gt;）。我们正在使用 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](../Images/4a5a5d96ed5aba6b00c86bfac8afe0bc.jpg)
\ No newline at end of file
docs/jstl/22.md 0 → 100644
浏览文件 @ a4011635
# fn：join（）和 fn：split（）JSTL 函数
> 原文： [https://beginnersbook.com/2013/12/fn-join-and-fn-split-jstl-functions/](https://beginnersbook.com/2013/12/fn-join-and-fn-split-jstl-functions/)
在本教程中，我们将看到 JSTL 的 fn：join（）和 fn：split（）函数。
### FN：加入（）
它将字符串与给定的分隔符连接起来并返回输出字符串。
#### 句法
```
String fn:join(String arrayofstrings, String separator)
```
它连接输入数组的所有元素以及它们之间提供的分隔符。此函数的返回类型是 String，它在连接后返回输出字符串。
#### 示例 - 使用 fn：join（）函数连接字符串
在这个例子中，我们有一个字符串数组，我们使用分隔符（'＆amp;'）连接它们。
```
<%@ 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>
```
**输出：**
正如你所看到的那样，所有这三个名字之间都加上了“＆amp;”。
![strings-join-example](../Images/f6a3cd25775035ab6fe316c776f4e69f.jpg)
### FN：分流（）
它将给定的字符串拆分为子串数组。拆分过程考虑我们在函数调用期间提供的定界符字符串。即我们提供字符串和分隔符作为函数的参数，并在根据分隔符字符串拆分输入后返回字符串数组。
#### Syntax
```
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>
```
**Output:**
![splitting-of-string](../Images/de485b3c2f418883cc37ce09936dfdff.jpg)
\ No newline at end of file
docs/jstl/23.md 0 → 100644
浏览文件 @ a4011635
# fn：length（） - JSTL 函数
> 原文： [https://beginnersbook.com/2013/12/fn-length-jstl-function/](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](../Images/623946bc1a4c0b93300e7c737ac8f390.jpg)
\ No newline at end of file
docs/jstl/24.md 0 → 100644
浏览文件 @ a4011635
# fn：trim（）和 fn：startsWith（）JSTL 函数
> 原文： [https://beginnersbook.com/2013/12/fn-trim-and-fn-startswith-jstl-functions/](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 的开头和结尾删除空格后，该函数返回字符串。
#### 例
在这个例子中，我们有一个字符串，它在字符串“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](../Images/8d646ef89ad19beeee4a4fdf134c0847.jpg)
#### fn：JSTL 中的 startsWith（）函数
它检查给定的字符串是否以特定的字符串值开头。
**Syntax:**
```
boolean fn:startsWith(String input, String prefix)
```
此函数返回一个布尔值。当字符串以给定前缀开头时它给出 true，否则返回 false。
#### Example
这里我们有一个长字符串和两个子字符串，我们正在检查字符串是否以任何子字符串开头。
```
<%@ 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](../Images/2ad13556dd4b2862da6645ab1197cb64.jpg)
\ No newline at end of file
docs/jstl/25.md 0 → 100644
浏览文件 @ a4011635
# fn：endsWith（） - JSTL 函数
> 原文： [https://beginnersbook.com/2013/12/fn-endswith-jstl-function/](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](../Images/0ba540e5ddfbf7443019be52aff5f4c6.jpg)
\ No newline at end of file
docs/jstl/26.md 0 → 100644
浏览文件 @ a4011635
# fn：substring（），fn：substringAfter（）＆amp; fn：substringBefore（）函数
> 原文： [https://beginnersbook.com/2013/12/jstl-substring-substringafter-substringbefore-functions/](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：子串的起始位置
* 结束：子串的结束位置
#### 示例 - 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](../Images/eafa7b97915c6e00215f88624d2454e3.jpg)
### FN：substringAfter（）
它返回给定字符串的一部分，该字符串位于提供的字符串值之后。
#### Syntax
```
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>
```
**Output:**
![substring-after-given-string](../Images/0a274f265060e374e4aa5310508148e3.jpg)
### FN：substringBefore（）
它与 fn：substringAfter 函数正好相反。它返回位于指定字符串值之前的原始字符串部分。
#### Syntax
```
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>
```
**Output:**
![substring-before-a-given-term](../Images/4168989930ceac88ddd1612484a61825.jpg)
\ No newline at end of file
docs/jstl/27.md 0 → 100644
浏览文件 @ a4011635
# fn：substring（），fn：substringAfter（）＆amp; fn：substringBefore（）函数
> 原文： [https://beginnersbook.com/2013/12/jstl-substring-substringafter-substringbefore-functions/](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：子串的起始位置
* 结束：子串的结束位置
#### 示例 - 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](../Images/eafa7b97915c6e00215f88624d2454e3.jpg)
### FN：substringAfter（）
它返回给定字符串的一部分，该字符串位于提供的字符串值之后。
#### Syntax
```
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>
```
**Output:**
![substring-after-given-string](../Images/0a274f265060e374e4aa5310508148e3.jpg)
### FN：substringBefore（）
它与 fn：substringAfter 函数正好相反。它返回位于指定字符串值之前的原始字符串部分。
#### Syntax
```
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>
```
**Output:**
![substring-before-a-given-term](../Images/4168989930ceac88ddd1612484a61825.jpg)
\ No newline at end of file
docs/jstl/28.md 0 → 100644
浏览文件 @ a4011635
# fn：substring（），fn：substringAfter（）＆amp; fn：substringBefore（）函数
> 原文： [https://beginnersbook.com/2013/12/jstl-substring-substringafter-substringbefore-functions/](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：子串的起始位置
* 结束：子串的结束位置
#### 示例 - 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](../Images/eafa7b97915c6e00215f88624d2454e3.jpg)
### FN：substringAfter（）
它返回给定字符串的一部分，该字符串位于提供的字符串值之后。
#### Syntax
```
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>
```
**Output:**
![substring-after-given-string](../Images/0a274f265060e374e4aa5310508148e3.jpg)
### FN：substringBefore（）
它与 fn：substringAfter 函数正好相反。它返回位于指定字符串值之前的原始字符串部分。
#### Syntax
```
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>
```
**Output:**
![substring-before-a-given-term](../Images/4168989930ceac88ddd1612484a61825.jpg)
\ No newline at end of file
docs/jstl/29.md 0 → 100644
浏览文件 @ a4011635
# fn：trim（）和 fn：startsWith（）JSTL 函数
> 原文： [https://beginnersbook.com/2013/12/fn-trim-and-fn-startswith-jstl-functions/](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 的开头和结尾删除空格后，该函数返回字符串。
#### 例
在这个例子中，我们有一个字符串，它在字符串“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](../Images/8d646ef89ad19beeee4a4fdf134c0847.jpg)
#### fn：JSTL 中的 startsWith（）函数
它检查给定的字符串是否以特定的字符串值开头。
**Syntax:**
```
boolean fn:startsWith(String input, String prefix)
```
此函数返回一个布尔值。当字符串以给定前缀开头时它给出 true，否则返回 false。
#### Example
这里我们有一个长字符串和两个子字符串，我们正在检查字符串是否以任何子字符串开头。
```
<%@ 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](../Images/2ad13556dd4b2862da6645ab1197cb64.jpg)
\ No newline at end of file
docs/jstl/3.md 0 → 100644
浏览文件 @ a4011635
# JSTL＆lt; c：out＆gt;核心标签
> 原文： [https://beginnersbook.com/2013/11/jstl-cout-core-tag/](https://beginnersbook.com/2013/11/jstl-cout-core-tag/)
**＆lt; c：out＆gt;是一个 JSTL 核心标记，**，用于在浏览器（客户端）上显示服务器端变量和硬编码值。您可能想知道变量的值和数据可以使用[表达语言（EL）](https://beginnersbook.com/2013/11/jsp-expression-language-el/ "EL")和[输出隐式对象](https://beginnersbook.com/2013/11/jsp-implicit-object-out-with-examples/ "Out implicit object")来显示，为什么我们需要＆lt; c：out＆gt; jstl 标签？区别在于＆lt; c：out＆gt; tag 转义 HTML / XML 标签但其他标签没有，请参考示例来理解这一点。
### 标签＆lt; c：out＆gt;例
在这个例子中，我们在浏览器上显示一个字符串，但是我们在值中使用了 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>
```
输出：
＆lt; b＆gt;这是＆lt; c：out＆gt;示例＆lt; / b＆gt;
![c-out-example](../Images/582c61a6d5ce915b48ba7f3d32746181.jpg)
＆lt; c：out＆gt;的 **escapeXml 属性标签**
假设我像这样修改上面的代码 - 我刚刚在标记中添加了 escapeXML 属性并将其标记为 false。 **默认情况下，escapeXML 属性的值为 true** 。由于我们将其标记为 false，因此它不会转义 HTML / XML 标记，并且标记将起作用。
```
<c:out value="${'<b>This is a <c:out> example </b>'}" escapeXml="false"/>
```
**输出：**
![c-out-example2](../Images/85bdcb5708a989960c916f6204b048b6.jpg)
**属性“默认”＆lt; c：out＆gt;标签**
上面我们看到了＆lt; c：out＆gt;的 escapeXML 属性。标签。此标记还有另一个属性“default”，用于显示＆lt; c：out＆gt;的值时的后备或默认值。 tag 为 null。下面是我们尝试使用标记打印字符串 str 的值的示例，并且由于字符串 str 值为 null，标记正在打印**默认属性**中设置的值。
```
<%! String str = null; %>
<c:out value="${str}" default="default value of c:out"/>
```
![c-out-example3](../Images/ffbab492317184dd3d44fdec53555463.jpg)
\ No newline at end of file
docs/jstl/30.md 0 → 100644
浏览文件 @ a4011635
# fn：toUpperCase（） - JSTL 函数
> 原文： [https://beginnersbook.com/2013/12/fn-touppercase-jstl-function/](https://beginnersbook.com/2013/12/fn-touppercase-jstl-function/)
它与 [fn：toLowerCase（）函数](https://beginnersbook.com/2013/12/fn-tolowercase-jstl-function/)正好相反。它将输入字符串转换为大写字符串。输入字符串的所有字符都被替换为相应的大写字符。需要更改的字符串作为函数的参数提供，并且函数返回转换后的字符串。我们可以将字符串作为变量传递，或者只是在函数调用期间对其进行硬编码。
#### 句法
```
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>
```
**输出：**
字符串**作者**和**网站**被所有大写字母替换。
![fn-toUpperCase-example](../Images/cd6a6d6734e4e63ce650f70d24cc5285.jpg)
\ No newline at end of file
docs/jstl/31.md 0 → 100644
浏览文件 @ a4011635
# fn：toLowerCase（） - JSTL 函数
> 原文： [https://beginnersbook.com/2013/12/fn-tolowercase-jstl-function/](https://beginnersbook.com/2013/12/fn-tolowercase-jstl-function/)
此函数将字符串转换为小写字符串。输入字符串中的任何大写字符都将替换为相应的小写字符。
#### 句法
```
String fn:toLowerCase(String  input)
```
返回类型：字符串;参数：String 类型的单个参数。在将输入字符串转换为小写后返回一个 String。
#### 示例 0f 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](../Images/8e323cd2622bfe829bfa385d79a15545.jpg)
\ No newline at end of file
docs/jstl/32.md 0 → 100644
浏览文件 @ a4011635
# fn：replace（） - JSTL 函数
> 原文： [https://beginnersbook.com/2013/12/fn-replace-jstl-function/](https://beginnersbook.com/2013/12/fn-replace-jstl-function/)
它在输入中搜索一个字符串，并用提供的字符串替换它。以下是 fn：replace（）函数的基本语法。
#### 句法
```
String fn:replace(String input, String search_for, String replace_with)
```
三个字符串参数和返回类型也是 String。它搜索**输入**中的 **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](../Images/02543ea786a7b481307b41848ef1b643.jpg)
\ No newline at end of file
docs/jstl/4.md 0 → 100644
浏览文件 @ a4011635
# JSTL＆lt; c：set＆gt;核心标签
> 原文： [https://beginnersbook.com/2013/11/jstl-cset-core-tag/](https://beginnersbook.com/2013/11/jstl-cset-core-tag/)
**＆lt; c：set＆gt;核心 JSTL 标记**用于为指定范围内的对象或变量赋值。让我们用**示例**来理解这一点。
这里我将一个字符串值赋给[应用程序范围](https://beginnersbook.com/2013/11/jsp-implicit-object-application-with-examples/ "Application")中的变量名称（它允许我在应用程序的任何 JSP 页面中访问我的变量）。在另一页（display.jsp）上，我使用[＆lt; c：out＆gt;在浏览器上打印了值。标签](https://beginnersbook.com/2013/11/jstl-cout-core-tag/ "&lt;c:out&gt; tag")和 [EL](https://beginnersbook.com/2013/11/jsp-expression-language-el/ "Expression language") 。
```
<%@ 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](../Images/fe72806d77eea95f6440cdc397c78e07.jpg)
![c-set-example2](../Images/024a86dd9cdbd4e31ce95287d089ce7b.jpg)
**＆lt; c：set＆gt;的属性标签**
**1）值：**它可以是硬编码值或表达式。例如以下是＆lt; c：set＆gt;的允许变体标签 -
变量 myvar 的值将存储在对象名称中。
```
<c:set var="name" scope="application" value="${myvar}"/>
```
表达式的结果将存储在对象中。
```
<c:set var="sum" scope="application" value="${1+3+6}"/>
```
2） **var：**它保存变量/对象名称
3）**范围：**可以是[请求](https://beginnersbook.com/2013/11/jsp-implicit-object-request-with-examples/ "Request object")，[会话](https://beginnersbook.com/2013/11/jsp-implicit-object-session-with-examples/ "Session object")，[页面](https://beginnersbook.com/2013/11/jsp-implicit-objects/ "Page object")和[应用程序](https://beginnersbook.com/2013/11/jsp-implicit-object-application-with-examples/ "application object")。在上面的例子中，我们已将范围指定为应用程序，但它可以是上述四个范围之外的任何内容。这一切都取决于要求。
\ No newline at end of file
docs/jstl/5.md 0 → 100644
浏览文件 @ a4011635
# JSTL＆lt; c：删除＆gt;核心标签
> 原文： [https://beginnersbook.com/2013/11/jstl-cremove-core-tag/](https://beginnersbook.com/2013/11/jstl-cremove-core-tag/)
**＆lt; c：删除＆gt;** 标记用于从指定范围或所有范围（页面，请求，会话和应用程序）中删除属性。
## 例
在下面的例子中，首先我使用[＆lt; c：set＆gt;设置了两个变量。标记](https://beginnersbook.com/2013/11/jstl-cset-core-tag/ "c:set")，然后我使用＆lt; c：remove＆gt;删除了其中一个标签。正如您在输出屏幕截图中看到的那样 - 当我尝试显示两个变量时，对于第二个属性，页面没有获得任何值，并使用＆lt; c：out＆gt;的[默认属性打印默认值。标签](https://beginnersbook.com/2013/11/jstl-cout-core-tag/ "c:out")。
```
<%@ 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](../Images/79a738305c7a4c1a1e3bd38980e12968.jpg)
![c-remove-example2](../Images/7c252f1b4d225a1056bd55370fb21659.jpg)
## ＆lt; c：remove＆gt;的范围属性标签
上面我们编码像这样
```
<c:remove var="author"/>
```
上面的代码从所有范围（页面，会话，应用程序，请求）中删除了一个属性。为了具体起见，我们必须在＆lt; c：remove＆gt;中指定 scope 属性。标签，就像我在下面所做的那样 - 下面的 JSTL 语句将从[会话范围](https://beginnersbook.com/2013/11/jsp-implicit-object-session-with-examples/ "Session")中删除变量 var。
```
<c:remove var="author" scope="session"/>
```
\ No newline at end of file
docs/jstl/6.md 0 → 100644
浏览文件 @ a4011635
# JSTL＆lt; c：if＆gt;核心标签
> 原文： [https://beginnersbook.com/2013/11/jstl-cif-core-tag/](https://beginnersbook.com/2013/11/jstl-cif-core-tag/)
**＆lt; c：if＆gt;是一个 JSTL 核心标签**，用于测试条件。它更像或类似于 java 中的 if 语句，它评估条件并在结果为真时执行代码块。
**语法：**
这是＆lt; c：if＆gt;的基本语法核心标签。包含在＆lt; c：if＆gt;范围内的语句集如果 **test =“true”**，则执行标记。对于使用此标记，我们通常使用[表达语言](https://beginnersbook.com/2013/11/jsp-expression-language-el/)来评估关系表达式。我们使用 EL，因为它在评估条件后返回布尔值（true / false），我们需要 test 属性的布尔值。
```
<c:if test="${condition}">
...
..
</c:if>
```
## ＆lt; c：if＆gt;的示例标签
在该示例中，我们使用[＆lt; c：set＆gt;定义了**年龄**变量。标签](https://beginnersbook.com/2013/11/jstl-cset-core-tag/)然后我们通过使用**＆lt; c：if＆gt;来检查投票的资格。标签**。
```
<%@ 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](../Images/44df108a19f4332e4fe7a9bd74a625af.jpg)
## c 为 C：如果＆GT;属性
上面我们已经看到＆lt; c：if＆gt;的基本用法我们只使用**测试属性**。然而，该标签还有另外两个可选属性，即 **var** 和**范围**。使用这些属性，您只需将测试结果存储在指定范围内的变量中。
* 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](../Images/bfc27ebc7c7068af8d5cba0a71ba7fd8.jpg)
\ No newline at end of file
docs/jstl/7.md 0 → 100644
浏览文件 @ a4011635
# JSTL＆lt; c：选择＆gt;，＆lt; c：当＆gt;，＆lt; c：否则＆gt;核心标签
> 原文： [https://beginnersbook.com/2013/11/jstl-cchoose-cwhen-cotherwise-core-tags/](https://beginnersbook.com/2013/11/jstl-cchoose-cwhen-cotherwise-core-tags/)
在本文中，我们讨论**＆lt; c：选择＆gt;，＆lt; c：when＆gt;和＆lt; c：否则＆gt; JSTL 的核心标签**。这些标签一起使用，如 **switch-case 和 java 中的默认**语句。 c 为 C：选择＆GT;就像开关一样，＆lt; c：when＆gt;喜欢可以在里面多次使用的情况＆lt; c：choose＆gt;用于评估不同的 2 条件。 c 为 C：否则＆GT;类似于默认语句，当所有＆lt; c：when＆gt;陈述是错误的。
**语法：**
基本结构看起来像这样 -
```
<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](../Images/9893eeb2d3914319bfc614b6f368f962.jpg)
\ No newline at end of file
docs/jstl/8.md 0 → 100644
浏览文件 @ a4011635
# JSTL＆lt; c：选择＆gt;，＆lt; c：当＆gt;，＆lt; c：否则＆gt;核心标签
> 原文： [https://beginnersbook.com/2013/11/jstl-cchoose-cwhen-cotherwise-core-tags/](https://beginnersbook.com/2013/11/jstl-cchoose-cwhen-cotherwise-core-tags/)
在本文中，我们讨论**＆lt; c：选择＆gt;，＆lt; c：when＆gt;和＆lt; c：否则＆gt; JSTL 的核心标签**。这些标签一起使用，如 **switch-case 和 java 中的默认**语句。 c 为 C：选择＆GT;就像开关一样，＆lt; c：when＆gt;喜欢可以在里面多次使用的情况＆lt; c：choose＆gt;用于评估不同的 2 条件。 c 为 C：否则＆GT;类似于默认语句，当所有＆lt; c：when＆gt;陈述是错误的。
**语法：**
基本结构看起来像这样 -
```
<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](../Images/9893eeb2d3914319bfc614b6f368f962.jpg)
\ No newline at end of file
docs/jstl/9.md 0 → 100644
浏览文件 @ a4011635
# JSTL＆lt; c：选择＆gt;，＆lt; c：当＆gt;，＆lt; c：否则＆gt;核心标签
> 原文： [https://beginnersbook.com/2013/11/jstl-cchoose-cwhen-cotherwise-core-tags/](https://beginnersbook.com/2013/11/jstl-cchoose-cwhen-cotherwise-core-tags/)
在本文中，我们讨论**＆lt; c：选择＆gt;，＆lt; c：when＆gt;和＆lt; c：否则＆gt; JSTL 的核心标签**。这些标签一起使用，如 **switch-case 和 java 中的默认**语句。 c 为 C：选择＆GT;就像开关一样，＆lt; c：when＆gt;喜欢可以在里面多次使用的情况＆lt; c：choose＆gt;用于评估不同的 2 条件。 c 为 C：否则＆GT;类似于默认语句，当所有＆lt; c：when＆gt;陈述是错误的。
**语法：**
基本结构看起来像这样 -
```
<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](../Images/9893eeb2d3914319bfc614b6f368f962.jpg)
\ No newline at end of file
docs/jstl/SUMMARY.md 0 → 100644
浏览文件 @ a4011635
+ [JSTL 核心标签](2.md)
+ [JSTL＆lt; c：out＆gt;核心标签](3.md)
+ [JSTL＆lt; c：set＆gt;核心标签](4.md)
+ [JSTL＆lt; c：删除＆gt;核心标签](5.md)
+ [JSTL＆lt; c：if＆gt;核心标签](6.md)
+ [JSTL＆lt; c：选择＆gt;，＆lt; c：当＆gt;，＆lt; c：否则＆gt;核心标签](7.md)
+ [JSTL＆lt; c：选择＆gt;，＆lt; c：当＆gt;，＆lt; c：否则＆gt;核心标签](8.md)
+ [JSTL＆lt; c：选择＆gt;，＆lt; c：当＆gt;，＆lt; c：否则＆gt;核心标签](9.md) + [JSTL＆lt; c：catch＆gt;核心标签](10.md)
+ [JSTL＆lt; c：import＆gt;核心标签](11.md)
+ [JSTL＆lt; c：forEach＆gt;和＆lt; c：forTokens＆gt;核心标签](12.md)
+ [JSTL＆lt; c：forEach＆gt;和＆lt; c：forTokens＆gt;核心标签](13.md)
+ [JSTL＆lt; c：param＆gt;核心标签](14.md)
+ [JSTL＆lt; c：url＆gt;核心标签](15.md)
+ [JSTL＆lt; c：重定向＆gt;核心标签](16.md)
+ [JSTL 功能](17.md)
+ [fn：contains（） - JSTL 函数](18.md)
+ [fn：containsIgnoreCase（） - JSTL 函数](19.md)
+ [fn：indexOf（） - JSTL 函数](20.md)
+ [fn：escapeXml（） - JSTL 函数](21.md)
+ [fn：join（）和 fn：split（）JSTL 函数](22.md)
+ [fn：length（） - JSTL 函数](23.md)
+ [fn：trim（）和 fn：startsWith（）JSTL 函数](24.md)
+ [fn：endsWith（） - JSTL 函数](25.md)
+ [fn：substring（），fn：substringAfter（）＆amp; fn：substringBefore（）函数](26.md)
+ [fn：substring（），fn：substringAfter（）＆amp; fn：substringBefore（）函数](27.md)
+ [fn：substring（），fn：substringAfter（）＆amp; fn：substringBefore（）函数](28.md)
+ [fn：trim（）和 fn：startsWith（）JSTL 函数](29.md)
+ [fn：toUpperCase（） - JSTL 函数](30.md)
+ [fn：toLowerCase（） - JSTL 函数](31.md)
+ [fn：replace（） - JSTL 函数](32.md)
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或