AUG Team - JS

jquery在浏览器滚动条上的应用

lorrons@gmail.com (lorron) — Fri, 09 Oct 2009 17:00:32 +0800

Google阅读器上有一个AJAX效果很不错，就是阅读项目时不需要翻页，浏览器滚动条往下拉到一定位置时自动加载新的一批项目进来，一直到所有项目加载完为止。对于我来说再好不过了，因为我很不喜欢翻页，尤其是输入页码再定位到页。要知道，数据量增加很频繁时，要通过定位页码来找到目标数据似乎并没有什么意义。我觉得用户体验成熟的WEB应用程序应当引导用户使用TAG或搜索等功能来找到目标数据。至于浏览数据，尤其是浏览最新的数据，利用浏览器滚动条来加载，是很好的尝试……

我试着用jquery来实现这个功能。先要得到滚动条的总长属性值：scrollHeight，还有滚动条当前位置属性值：scrollTop。然后通过计算，若当前值位于总长值三分之二时加载新数据。假设DOM上有一个元素为

，该元素overflow样式为scroll，也就是元素中的内容溢出元素指定高度时启用滚动条。利用jquery的load方法为元素加载一个已经存在的文件，我假设它是table.html。这个文件的内容可以是足以使浏览器滚屏的一张数据表。

为什么要隔2秒钟调用一次判断呢？因为只要$(”#mypage”).scroll事件一被触发，就会影hght和top值，这个值可能总是满足cando函数的判断，也就是top值总是位于hght的三分之二。因此可能会多次加载造成服务器负担加重。而每加载一次后把hght和top值赋0，也是这个原因。

这段代码的效果就是只要元素mypage的滚动条位置位于滚动条总长的三分之二时，追加table.html的内容到元素mypage中去。当然这样运行是无休止地加载下去。在真正的AJAX运用中，table.html可以换成asp或php脚本，接收get或post参数来进行处理，然后返回有意义的数据。jquery的get方法可以设置get方式的参数数据，比如：

$.get(”test.php”, { name: “boho”, id: “1″ } );

相当于http://hostlocal/test.php?name=boho&id=1这种形式的http访问。然后通过get方法的回调函数来获取test.php输出的内容：

$.get(”test.php”, {name:”boho”,id:”1″},function(data){
alert(”Data Loaded: ” + data);
});

来自Google的密码强度Javascript验证代码收藏

lorrons@gmail.com (lorron) — Thu, 22 Jan 2009 17:03:00 +0800

先看看效果吧：

http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
http://www.w3.org/1999/xhtml">

aaa

复制CSDN的BLOG代码，去掉前面行号的方法收藏

lorrons@gmail.com (lorron) — Thu, 22 Jan 2009 08:54:19 +0800

我们如果从CSDN的BLOG复制代码，出现前面的行号，比如
   1. /* 文本没有缩写 */
   2. /* Specify blanket rules for all elements */
   3. font-size:12px;
   4. line-height:160%;
   5. font-weight:bold;
   6. font-style:italic;
   7. font-family: "Lucida Grande",Arial,Sans-serif;
   8.
   9. /* 文本有缩写 */
10. /* Specify blanket rules for all elements */
11. font: 12px/160% bold italic "Lucida Grande",Arial,Sans-serif;
我们可以用正则表达式替换掉他们。
正则为
^\s+\d+\.
替换为空格就行了

好东西分享 [自动生成文章摘要]

lorrons@gmail.com (lorron) — Sat, 29 Nov 2008 02:19:04 +0800

function AutoIntro() {
FCKeditorAPI.GetInstance('txaIntro').SetHTML(FCKeditorAPI.GetInstance('txaContent').GetHTML().replace(/<[^>]+>/g, "").substring(0,200)); //FCK会自动处理未闭合的标签，我们不用多管它。要是标签被切了一半显示出来了自己编辑下就好。
}

Java正则表达式详解

lorrons@gmail.com (lorron) — Wed, 24 Sep 2008 04:16:20 +0800

Java正则表达式详解

来源:http://www.ccw.com.cn/htm/app/aprog/01_7_31_4.asp

如果你曾经用过Perl或任何其他内建正则表达式支持的语言，你一定知道用正则表达式处理文本和匹配模式是多么简单。如果你不熟悉这个术语，那么“正则表达式”（Regular Expression）就是一个字符构成的串，它定义了一个用来搜索匹配字符串的模式。

许多语言，包括Perl、PHP、Python、JavaScript和JScript，都支持用正则表达式处理文本，一些文本编辑器用正则表达式实现高级“搜索-替换”功能。那么Java又怎样呢？本文写作时，一个包含了用正则表达式进行文本处理的Java规范需求（Specification Request）已经得到认可，你可以期待在JDK的下一版本中看到它。

然而，如果现在就需要使用正则表达式，又该怎么办呢？你可以从Apache.org下载源代码开放的Jakarta-ORO库。本文接下来的内容先简要地介绍正则表达式的入门知识，然后以Jakarta-ORO API为例介绍如何使用正则表达式。

一、正则表达式基础知识

我们先从简单的开始。假设你要搜索一个包含字符“cat”的字符串，搜索用的正则表达式就是“cat”。如果搜索对大小写不敏感，单词“catalog”、“Catherine”、“sophisticated”都可以匹配。也就是说：

1.1 句点符号

假设你在玩英文拼字游戏，想要找出三个字母的单词，而且这些单词必须以“t”字母开头，以“n”字母结束。另外，假设有一本英文字典，你可以用正则表达式搜索它的全部内容。要构造出这个正则表达式，你可以使用一个通配符——句点符号“.”。这样，完整的表达式就是“t.n”，它匹配“tan”、“ten”、“tin”和“ton”，还匹配“t#n”、“tpn”甚至“t n”，还有其他许多无意义的组合。这是因为句点符号匹配所有字符，包括空格、Tab字符甚至换行符：

1.2 方括号符号

为了解决句点符号匹配范围过于广泛这一问题，你可以在方括号（“[]”）里面指定看来有意义的字符。此时，只有方括号里面指定的字符才参与匹配。也就是说，正则表达式“t[aeio]n”只匹配“tan”、“Ten”、“tin”和“ton”。但“Toon”不匹配，因为在方括号之内你只能匹配单个字符：

1.3 “或”符号

如果除了上面匹配的所有单词之外，你还想要匹配“toon”，那么，你可以使用“|”操作符。“|”操作符的基本意义就是“或”运算。要匹配“toon”，使用“t(a|e|i|o|oo)n”正则表达式。这里不能使用方扩号，因为方括号只允许匹配单个字符；这里必须使用圆括号“()”。圆括号还可以用来分组，具体请参见后面介绍。

1.4 表示匹配次数的符号

表一显示了表示匹配次数的符号，这些符号用来确定紧靠该符号左边的符号出现的次数：

假设我们要在文本文件中搜索美国的社会安全号码。这个号码的格式是999-99-9999。用来匹配它的正则表达式如图一所示。在正则表达式中，连字符（“-”）有着特殊的意义，它表示一个范围，比如从0到9。因此，匹配社会安全号码中的连字符号时，它的前面要加上一个转义字符“\”。

图一：匹配所有123-12-1234形式的社会安全号码

假设进行搜索的时候，你希望连字符号可以出现，也可以不出现——即，999-99-9999和999999999都属于正确的格式。这时，你可以在连字符号后面加上“？”数量限定符号，如图二所示：

图二：匹配所有123-12-1234和123121234形式的社会安全号码

下面我们再来看另外一个例子。美国汽车牌照的一种格式是四个数字加上二个字母。它的正则表达式前面是数字部分“[0-9]{4}”，再加上字母部分“[A-Z]{2}”。图三显示了完整的正则表达式。

图三：匹配典型的美国汽车牌照号码，如8836KV

1.5 “否”符号

“^”符号称为“否”符号。如果用在方括号内，“^”表示不想要匹配的字符。例如，图四的正则表达式匹配所有单词，但以“X”字母开头的单词除外。

图四：匹配所有单词，但“X”开头的除外

1.6 圆括号和空白符号

假设要从格式为“June 26, 1951”的生日日期中提取出月份部分，用来匹配该日期的正则表达式可以如图五所示：

图五：匹配所有Moth DD,YYYY格式的日期

新出现的“\s”符号是空白符号，匹配所有的空白字符，包括Tab字符。如果字符串正确匹配，接下来如何提取出月份部分呢？只需在月份周围加上一个圆括号创建一个组，然后用ORO API（本文后面详细讨论）提取出它的值。修改后的正则表达式如图六所示：

图六：匹配所有Month DD,YYYY格式的日期，定义月份值为第一个组

1.7 其它符号

为简便起见，你可以使用一些为常见正则表达式创建的快捷符号。如表二所示：

表二：常用符号

例如，在前面社会安全号码的例子中，所有出现“[0-9]”的地方我们都可以使用“\d”。修改后的正则表达式如图七所示：

图七：匹配所有123-12-1234格式的社会安全号码

二、Jakarta-ORO库

有许多源代码开放的正则表达式库可供Java程序员使用，而且它们中的许多支持Perl 5兼容的正则表达式语法。我在这里选用的是Jakarta-ORO正则表达式库，它是最全面的正则表达式API之一，而且它与Perl 5正则表达式完全兼容。另外，它也是优化得最好的API之一。

Jakarta-ORO库以前叫做OROMatcher，Daniel Savarese大方地把它赠送给了Jakarta Project。你可以按照本文最后参考资源的说明下载它。

我首先将简要介绍使用Jakarta-ORO库时你必须创建和访问的对象，然后介绍如何使用Jakarta-ORO API。

▲ PatternCompiler对象

首先，创建一个Perl5Compiler类的实例，并把它赋值给PatternCompiler接口对象。Perl5Compiler是PatternCompiler接口的一个实现，允许你把正则表达式编译成用来匹配的Pattern对象。

▲ Pattern对象

要把正则表达式编译成Pattern对象，调用compiler对象的compile()方法，并在调用参数中指定正则表达式。例如，你可以按照下面这种方式编译正则表达式“t[aeio]n”：

默认情况下，编译器创建一个大小写敏感的模式（pattern）。因此，上面代码编译得到的模式只匹配“tin”、“tan”、 “ten”和“ton”，但不匹配“Tin”和“taN”。要创建一个大小写不敏感的模式，你应该在调用编译器的时候指定一个额外的参数：

创建好Pattern对象之后，你就可以通过PatternMatcher类用该Pattern对象进行模式匹配。

▲ PatternMatcher对象

;PatternMatcher对象根据Pattern对象和字符串进行匹配检查。你要实例化一个Perl5Matcher类并把结果赋值给PatternMatcher接口。Perl5Matcher类是PatternMatcher接口的一个实现，它根据Perl 5正则表达式语法进行模式匹配：

使用PatternMatcher对象，你可以用多个方法进行匹配操作，这些方法的第一个参数都是需要根据正则表达式进行匹配的字符串：

· boolean matches(String input, Pattern pattern)：当输入字符串和正则表达式要精确匹配时使用。换句话说，正则表达式必须完整地描述输入字符串。

· boolean matchesPrefix(String input, Pattern pattern)：当正则表达式匹配输入字符串起始部分时使用。

· boolean contains(String input, Pattern pattern)：当正则表达式要匹配输入字符串的一部分时使用（即，它必须是一个子串）。

另外，在上面三个方法调用中，你还可以用PatternMatcherInput对象作为参数替代String对象；这时，你可以从字符串中最后一次匹配的位置开始继续进行匹配。当字符串可能有多个子串匹配给定的正则表达式时，用PatternMatcherInput对象作为参数就很有用了。用PatternMatcherInput对象作为参数替代String时，上述三个方法的语法如下：

· boolean matches(PatternMatcherInput input, Pattern pattern)

· boolean matchesPrefix(PatternMatcherInput input, Pattern pattern)

· boolean contains(PatternMatcherInput input, Pattern pattern)

三、应用实例

下面我们来看看Jakarta-ORO库的一些应用实例。

3.1 日志文件处理

任务：分析一个Web服务器日志文件，确定每一个用户花在网站上的时间。在典型的BEA WebLogic日志文件中，日志记录的格式如下：

分析这个日志记录，可以发现，要从这个日志文件提取的内容有两项：IP地址和页面访问时间。你可以用分组符号（圆括号）从日志记录提取出IP地址和时间标记。

首先我们来看看IP地址。IP地址有4个字节构成，每一个字节的值在0到255之间，各个字节通过一个句点分隔。因此，IP地址中的每一个字节有至少一个、最多三个数字。图八显示了为IP地址编写的正则表达式：

图八：匹配IP地址

IP地址中的句点字符必须进行转义处理（前面加上“\”），因为IP地址中的句点具有它本来的含义，而不是采用正则表达式语法中的特殊含义。句点在正则表达式中的特殊含义本文前面已经介绍。

日志记录的时间部分由一对方括号包围。你可以按照如下思路提取出方括号里面的所有内容：首先搜索起始方括号字符（“[”），提取出所有不超过结束方括号字符（“]”）的内容，向前寻找直至找到结束方括号字符。图九显示了这部分的正则表达式。

图九：匹配至少一个字符，直至找到“]”

现在，把上述两个正则表达式加上分组符号（圆括号）后合并成单个表达式，这样就可以从日志记录提取出IP地址和时间。注意，为了匹配“- -”（但不提取它），正则表达式中间加入了“\s-\s-\s”。完整的正则表达式如图十所示。

图十：匹配IP地址和时间标记

现在正则表达式已经编写完毕，接下来可以编写使用正则表达式库的Java代码了。

为使用Jakarta-ORO库，首先创建正则表达式字符串和待分析的日志记录字符串：

这里使用的正则表达式与图十的正则表达式差不多完全相同，但有一点例外：在Java中，你必须对每一个向前的斜杠（“\”）进行转义处理。图十不是Java的表示形式，所以我们要在每个“\”前面加上一个“\”以免出现编译错误。遗憾的是，转义处理过程很容易出现错误，所以应该小心谨慎。你可以首先输入未经转义处理的正则表达式，然后从左到右依次把每一个“\”替换成“\\”。如果要复检，你可以试着把它输出到屏幕上。

初始化字符串之后，实例化PatternCompiler对象，用PatternCompiler编译正则表达式创建一个Pattern对象：

现在，创建PatternMatcher对象，调用PatternMatcher接口的contain()方法检查匹配情况：

接下来，利用PatternMatcher接口返回的MatchResult对象，输出匹配的组。由于logEntry字符串包含匹配的内容，你可以看到类如下面的输出：

3.2 HTML处理实例一

下面一个任务是分析HTML页面内FONT标记的所有属性。HTML页面内典型的FONT标记如下所示：

程序将按照如下形式，输出每一个FONT标记的属性：

在这种情况下，我建议你使用两个正则表达式。第一个如图十一所示，它从字体标记提取出“"face="Arial, Serif" size="+2" color="red"”。

图十一：匹配FONT标记的所有属性

第二个正则表达式如图十二所示，它把各个属性分割成名字-值对。

图十二：匹配单个属性，并把它分割成名字-值对

分割结果为：

现在我们来看看完成这个任务的Java代码。首先创建两个正则表达式字符串，用Perl5Compiler把它们编译成Pattern对象。编译正则表达式的时候，指定Perl5Compiler.CASE_INSENSITIVE_MASK选项，使得匹配操作不区分大小写。

接下来，创建一个执行匹配操作的Perl5Matcher对象。

假设有一个String类型的变量html，它代表了HTML文件中的一行内容。如果html字符串包含FONT标记，匹配器将返回true。此时，你可以用匹配器对象返回的MatchResult对象获得第一个组，它包含了FONT的所有属性：

接下来创建一个PatternMatcherInput对象。这个对象允许你从最后一次匹配的位置开始继续进行匹配操作，因此，它很适合于提取FONT标记内属性的名字-值对。创建PatternMatcherInput对象，以参数形式传入待匹配的字符串。然后，用匹配器实例提取出每一个FONT的属性。这通过指定PatternMatcherInput对象（而不是字符串对象）为参数，反复地调用PatternMatcher对象的contains()方法完成。PatternMatcherInput对象之中的每一次迭代将把它内部的指针向前移动，下一次检测将从前一次匹配位置的后面开始。

本例的输出结果如下：

3.3 HTML处理实例二

下面我们来看看另一个处理HTML的例子。这一次，我们假定Web服务器从widgets.acme.com移到了newserver.acme.com。现在你要修改一些页面中的链接：

执行这个搜索的正则表达式如图十三所示：

图十三：匹配修改前的链接

如果能够匹配这个正则表达式，你可以用下面的内容替换图十三的链接：

注意#字符的后面加上了$1。Perl正则表达式语法用$1、$2等表示已经匹配且提取出来的组。图十三的表达式把所有作为一个组匹配和提取出来的内容附加到链接的后面。

现在，返回Java。就象前面我们所做的那样，你必须创建测试字符串，创建把正则表达式编译到Pattern对象所必需的对象，以及创建一个PatternMatcher对象：

接下来，用com.oroinc.text.regex包Util类的substitute()静态方法进行替换，输出结果字符串：

Util.substitute()方法的语法如下：

这个调用的前两个参数是以前创建的PatternMatcher和Pattern对象。第三个参数是一个Substiution对象，它决定了替换操作如何进行。本例使用的是Perl5Substitution对象，它能够进行Perl5风格的替换。第四个参数是想要进行替换操作的字符串，最后一个参数允许指定是否替换模式的所有匹配子串（Util.SUBSTITUTE_ALL），或只替换指定的次数。

【结束语】在这篇文章中，我为你介绍了正则表达式的强大功能。只要正确运用，正则表达式能够在字符串提取和文本修改中起到很大的作用。另外，我还介绍了如何在Java程序中通过Jakarta-ORO库利用正则表达式。至于最终采用老式的字符串处理方式（使用StringTokenizer，charAt，和substring），还是采用正则表达式，这就有待你自己决定了。

长文章分页类

lorrons@gmail.com (lorron) — Sat, 19 Jul 2008 02:00:49 +0800

Tags: 分页, JS

长文章分页类

有些新闻内容比较长，想分不同的几页来显示，简短的就可以一页，长点的可以随意分2页或者3页，求一个比较好的分页方式，或者一种思路。

通过编辑时手动插入特定字符串作为分页符，然后页面显示时判断分页。

分页有这么几个技术难点：

1、分段，就是上面说的希望段落1在第一页，段落2在第二页；这样的设计需要人为添加分页符号，然后程序判断分页；
2、文章中间存在html代码，比如文章是带Table的，分页会造成html错误；没有Table，分页在中间也会带来相应的问题；这个还没有很好的解决办法；

还是手动插入分页符比较好琢磨。
主要是怕编辑粘贴的不全。
要是怕半截表格打乱整个页面可以把内容放到之间试试，如果该页内容里有半个就抱着编辑哭吧。
要是怕最后有半截html标签（型如

一个Htm长文章分页的例子

New Document

header

footer

Java正则表达式四种常用功能

lorrons@gmail.com (lorron) — Sun, 13 Jul 2008 08:09:35 +0800

Tags: 正则表达式, 正则

查询：

Java代码

String str="abc efg ABC";
String regEx="a|f"; //表示a或f
Pattern p=Pattern.compile(regEx);
Matcher m=p.matcher(str);
boolean rs=m.find();

String str="abc efg ABC";    String regEx="a|f";   //表示a或f     Pattern p=Pattern.compile(regEx);    Matcher m=p.matcher(str);    boolean rs=m.find();

如果str中有regEx，那么rs为true，否则为flase。如果想在查找时忽略大小写，则可以写成：

Java代码

Pattern p=Pattern.compile(regEx,Pattern.CASE_INSENSITIVE);

Pattern p=Pattern.compile(regEx,Pattern.CASE_INSENSITIVE);

提取：

Java代码

String regEx=".+\\\\(.+)$";
String str="c:\\dir1\\dir2\\name.txt";
Pattern p=Pattern.compile(regEx);
Matcher m=p.matcher(str);
boolean rs=m.find();
for(int i=1;i<=m.groupCount();i++){
System.out.println(m.group(i));
}

String regEx=".+\\\\(.+)$";    String str="c:\\dir1\\dir2\\name.txt";    Pattern p=Pattern.compile(regEx);    Matcher m=p.matcher(str);    boolean rs=m.find();    for(int i=1;i<=m.groupCount();i++){        System.out.println(m.group(i));    }

以上的执行结果为name.txt，提取的字符串储存在m.group(i)中，其中i最大值为

Java代码

m.groupCount();

m.groupCount();

分割：

Java代码

String regEx="::";
Pattern p=Pattern.compile(regEx);
String[] r=p.split("xd::abc::cde");

String regEx="::";    Pattern p=Pattern.compile(regEx);    String[] r=p.split("xd::abc::cde");

执行后，r就是{"xd","abc","cde"}，其实分割时还有更简单的方法：

Java代码

String str="xd::abc::cde";
String[] r=str.split("::");

String str="xd::abc::cde";String[] r=str.split("::");

替换（删除）：

Java代码

String regEx="a+"; //表示一个或多个a
Pattern p=Pattern.compile(regEx);
Matcher m=p.matcher("aaabbced a ccdeaa");
String s=m.replaceAll("A");

String regEx="a+"; //表示一个或多个a    Pattern p=Pattern.compile(regEx);    Matcher m=p.matcher("aaabbced a ccdeaa");    String s=m.replaceAll("A");

结果为"Abbced A ccdeA" 。如果写成空串，既可达到删除的功能，比如：

Java代码

String s=m.replaceAll("");
结果为"bbced ccde"

String s=m.replaceAll("");结果为"bbced  ccde"

附：

引用

\d 等於 [0-9] 数字
\D 等於 [^0-9] 非数字
\s 等於 [ \t\n\x0B\f\r] 空白字元
\S 等於 [^ \t\n\x0B\f\r] 非空白字元
\w 等於 [a-zA-Z_0-9] 数字或是英文字
\W 等於 [^a-zA-Z_0-9] 非数字与英文字
^ 表示每行的开头
$ 表示每行的结尾

Java正则表达式入门

lorrons@gmail.com (lorron) — Sun, 13 Jul 2008 08:06:59 +0800

Tags: 正则表达式, 正则

众所周知，在程序开发中，难免会遇到需要匹配、查找、替换、判断字符串的情况发生，而这些情况有时又比较复杂，如果用纯编码方式解决，往往会浪费程序员的时间及精力。因此，学习及使用正则表达式，便成了解决这一矛盾的主要手段。
大家都知道，正则表达式是一种可以用于模式匹配和替换的规范，一个正则表达式就是由普通的字符（例如字符a到z）以及特殊字符（元字符）组成的文字模式，它用以描述在查找文字主体时待匹配的一个或多个字符串。正则表达式作为一个模板，将某个字符模式与所搜索的字符串进行匹配。
自从jdk1.4推出java.util.regex包，就为我们提供了很好的JAVA正则表达式应用平台。
因为正则表达式是一个很庞杂的体系，所以我仅例举些入门的概念，更多的请参阅相关书籍及自行摸索。
\\ 反斜杠
\t 间隔 ('\u0009')
\n 换行 ('\u000A')
\r 回车 ('\u000D')
\d 数字等价于[0-9]
\D 非数字等价于[^0-9]
\s 空白符号 [\t\n\x0B\f\r]
\S 非空白符号 [^\t\n\x0B\f\r]
\w 单独字符 [a-zA-Z_0-9]
\W 非单独字符 [^a-zA-Z_0-9]
\f 换页符
\e Escape
\b 一个单词的边界
\B 一个非单词的边界
\G 前一个匹配的结束
^为限制开头
^java 条件限制为以Java为开头字符
$为限制结尾
java$ 条件限制为以java为结尾字符
.为限制一个任意字符
java.. 条件限制为java后除换行外任意两个字符
加入特定限制条件「[]」
[a-z] 条件限制在小写a to z范围中一个字符
[A-Z] 条件限制在大写A to Z范围中一个字符
[a-zA-Z] 条件限制在小写a to z或大写A to Z范围中一个字符
[0-9] 条件限制在小写0 to 9范围中一个字符
[0-9a-z] 条件限制在小写0 to 9或a to z范围中一个字符
[0-9[a-z]] 条件限制在小写0 to 9或a to z范围中一个字符(交集)
[]中加入^后加再次限制条件「[^]」
[^a-z] 条件限制在非小写a to z范围中一个字符
[^A-Z] 条件限制在非大写A to Z范围中一个字符
[^a-zA-Z] 条件限制在非小写a to z或大写A to Z范围中一个字符
[^0-9] 条件限制在非小写0 to 9范围中一个字符
[^0-9a-z] 条件限制在非小写0 to 9或a to z范围中一个字符
[^0-9[a-z]] 条件限制在非小写0 to 9或a to z范围中一个字符(交集)
在限制条件为特定字符出现0次以上时，可以使用「*」
J* 0个以上J
.* 0个以上任意字符
J.*D J与D之间0个以上任意字符
在限制条件为特定字符出现1次以上时，可以使用「+」
J+ 1个以上J
.+ 1个以上任意字符
J.+D J与D之间1个以上任意字符
在限制条件为特定字符出现有0或1次以上时，可以使用「?」
JA? J或者JA出现
限制为连续出现指定次数字符「{a}」
J{2} JJ
J{3} JJJ
文字a个以上，并且「{a,}」
J{3,} JJJ,JJJJ,JJJJJ,???(3次以上J并存)
文字个以上，b个以下「{a,b}」
J{3,5} JJJ或JJJJ或JJJJJ
两者取一「|」
J|A J或A
Java|Hello Java或Hello
「()」中规定一个组合类型
比如，我查询index中间的数据，可写作(.+?)
在使用Pattern.compile函数时，可以加入控制正则表达式的匹配行为的参数：
Pattern Pattern.compile(String regex, int flag)
flag的取值范围如下：
Pattern.CANON_EQ 当且仅当两个字符的"正规分解(canonical decomposition)"都完全相同的情况下，才认定匹配。比如用了这个标志之后，表达式"a\u030A"会匹配"?"。默认情况下，不考虑"规范相等性(canonical equivalence)"。
Pattern.CASE_INSENSITIVE(?i) 默认情况下，大小写不明感的匹配只适用于US-ASCII字符集。这个标志能让表达式忽略大小写进行匹配。要想对Unicode字符进行大小不明感的匹配，只要将UNICODE_CASE与这个标志合起来就行了。
Pattern.COMMENTS(?x) 在这种模式下，匹配时会忽略(正则表达式里的)空格字符(译者注：不是指表达式里的"\\s"，而是指表达式里的空格，tab，回车之类)。注释从#开始，一直到这行结束。可以通过嵌入式的标志来启用Unix行模式。
Pattern.DOTALL(?s) 在这种模式下，表达式'.'可以匹配任意字符，包括表示一行的结束符。默认情况下，表达式'.'不匹配行的结束符。
Pattern.MULTILINE
(?m) 在这种模式下，'^'和'$'分别匹配一行的开始和结束。此外，'^'仍然匹配字符串的开始，'$'也匹配字符串的结束。默认情况下，这两个表达式仅仅匹配字符串的开始和结束。
Pattern.UNICODE_CASE
(?u) 在这个模式下，如果你还启用了CASE_INSENSITIVE标志，那么它会对Unicode字符进行大小写不明感的匹配。默认情况下，大小写不敏感的匹配只适用于US-ASCII字符集。
Pattern.UNIX_LINES(?d) 在这个模式下，只有'\n'才被认作一行的中止，并且与'.'，'^'，以及'$'进行匹配。
抛开空泛的概念，下面写出几个简单的Java正则用例：
◆比如，在字符串包含验证时
//查找以Java开头,任意结尾的字符串

Java代码

Pattern pattern = Pattern.compile("^Java.*");
Matcher matcher = pattern.matcher("Java不是人");
boolean b= matcher.matches();

  Pattern pattern = Pattern.compile("^Java.*");  Matcher matcher = pattern.matcher("Java不是人");  boolean b= matcher.matches();

//当条件满足时，将返回true，否则返回false

Java代码

System.out.println(b);

  System.out.println(b);

◆以多条件分割字符串时

Java代码

Pattern pattern = Pattern.compile("[, |]+");
String[] strs = pattern.split("Java Hello World Java,Hello,,World|Sun");
for (int i=0;i
System.out.println(strs[i]);
}

Pattern pattern = Pattern.compile("[, |]+");String[] strs = pattern.split("Java Hello World  Java,Hello,,World|Sun");for (int i=0;i
◆文字替换（首次出现字符）
Java代码 
    Pattern pattern = Pattern.compile("正则表达式");   
    Matcher matcher = pattern.matcher("正则表达式 Hello World,正则表达式 Hello World");   
    //替换第一个符合正则的数据
    System.out.println(matcher.replaceFirst("Java")); 
Pattern pattern = Pattern.compile("正则表达式");Matcher matcher = pattern.matcher("正则表达式 Hello World,正则表达式 Hello World");//替换第一个符合正则的数据System.out.println(matcher.replaceFirst("Java"));

◆文字替换（全部）
Java代码 
    Pattern pattern = Pattern.compile("正则表达式");   
    Matcher matcher = pattern.matcher("正则表达式 Hello World,正则表达式 Hello World");   
    //替换第一个符合正则的数据
    System.out.println(matcher.replaceAll("Java")); 
Pattern pattern = Pattern.compile("正则表达式");Matcher matcher = pattern.matcher("正则表达式 Hello World,正则表达式 Hello World");//替换第一个符合正则的数据System.out.println(matcher.replaceAll("Java"));

◆文字替换（置换字符）
Java代码 
    Pattern pattern = Pattern.compile("正则表达式");   
    Matcher matcher = pattern.matcher("正则表达式 Hello World,正则表达式 Hello World ");   
    StringBuffer sbr = new StringBuffer();   
    while (matcher.find()) {   
        matcher.appendReplacement(sbr, "Java");   
    }   
    matcher.appendTail(sbr);   
    System.out.println(sbr.toString()); 
Pattern pattern = Pattern.compile("正则表达式");Matcher matcher = pattern.matcher("正则表达式 Hello World,正则表达式 Hello World ");StringBuffer sbr = new StringBuffer();while (matcher.find()) {    matcher.appendReplacement(sbr, "Java");}matcher.appendTail(sbr);System.out.println(sbr.toString());

◆验证是否为邮箱地址
Java代码 
    String str="ceponline@yahoo.com.cn";   
    Pattern pattern = Pattern.compile("[\\w\\.\\-]+@([\\w\\-]+\\.)+[\\w\\-]+",Pattern.CASE_INSENSITIVE);   
    Matcher matcher = pattern.matcher(str);   
    System.out.println(matcher.matches()); 
String str="ceponline@yahoo.com.cn";Pattern pattern = Pattern.compile("[\\w\\.\\-]+@([\\w\\-]+\\.)+[\\w\\-]+",Pattern.CASE_INSENSITIVE);Matcher matcher = pattern.matcher(str);System.out.println(matcher.matches());

◆去除html标记
Java代码 
    Pattern pattern = Pattern.compile("<.+?>", Pattern.DOTALL);   
    Matcher matcher = pattern.matcher("主页");   
    String string = matcher.replaceAll("");   
    System.out.println(string); 
Pattern pattern = Pattern.compile("<.+?>", Pattern.DOTALL);Matcher matcher = pattern.matcher("主页");String string = matcher.replaceAll("");System.out.println(string);

◆查找html中对应条件字符串
Java代码 
    Pattern pattern = Pattern.compile("href=\"(.+?)\"");   
    Matcher matcher = pattern.matcher("主页");   
    if(matcher.find())   
      System.out.println(matcher.group(1));   
    } 
Pattern pattern = Pattern.compile("href=\"(.+?)\"");Matcher matcher = pattern.matcher("主页");if(matcher.find())  System.out.println(matcher.group(1));}

◆截取http://地址 
//截取url
Java代码 
    Pattern pattern = Pattern.compile("(http://|https://){1}[\\w\\.\\-/:]+");   
    Matcher matcher = pattern.matcher("dsdsdsfdf");   
    StringBuffer buffer = new StringBuffer();   
    while(matcher.find()){                 
        buffer.append(matcher.group());           
        buffer.append("\r\n");                 
    System.out.println(buffer.toString());   
    } 
Pattern pattern = Pattern.compile("(http://|https://){1}[\\w\\.\\-/:]+");Matcher matcher = pattern.matcher("dsdsdsfdf");StringBuffer buffer = new StringBuffer();while(matcher.find()){                  buffer.append(matcher.group());            buffer.append("\r\n");              System.out.println(buffer.toString());}

◆替换指定{}中文字
Java代码 
    String str = "Java目前的发展史是由{0}年-{1}年";   
    String[][] object={new String[]{"\\{0\\}","1995"},new String[]{"\\{1\\}","2007"}};   
    System.out.println(replace(str,object));   
     
    public static String replace(final String sourceString,Object[] object) {   
                String temp=sourceString;       
    for(int i=0;i    
                      String[] result=(String[])object[i];   
                   Pattern    pattern = Pattern.compile(result[0]);   
                   Matcher matcher = pattern.matcher(temp);   
                   temp=matcher.replaceAll(result[1]);   
                }   
    return temp;   
    } 
String str = "Java目前的发展史是由{0}年-{1}年";String[][] object={new String[]{"\\{0\\}","1995"},new String[]{"\\{1\\}","2007"}};System.out.println(replace(str,object));public static String replace(final String sourceString,Object[] object) {            String temp=sourceString;                for(int i=0;i
◆以正则条件查询指定目录下文件
Java代码 
    //用于缓存文件列表
    private ArrayList files = new ArrayList();   
    //用于承载文件路径
    private String _path;   
    //用于承载未合并的正则公式
    private String _regexp;   
     
    class MyFileFilter implements FileFilter {   
     
    /**
                  * 匹配文件名称
                  */
    public boolean accept(File file) {   
    try {   
                     Pattern pattern = Pattern.compile(_regexp);   
                     Matcher match = pattern.matcher(file.getName());                   
    return match.matches();   
                   } catch (Exception e) {   
    return true;   
                   }   
                 }   
               }   
     
    /**
            * 解析输入流
            * @param inputs
            */
           FilesAnalyze (String path,String regexp){   
               getFileName(path,regexp);   
           }   
     
    /**
            * 分析文件名并加入files
            * @param input
            */
    private void getFileName(String path,String regexp) {   
    //目录
                 _path=path;   
                 _regexp=regexp;   
                 File directory = new File(_path);   
                 File[] filesFile = directory.listFiles(new MyFileFilter());   
    if (filesFile == null) return;   
    for (int j = 0; j < filesFile.length; j++) {   
                   files.add(filesFile[j]);   
                 }   
    return;   
               }   
     
    /**
            * 显示输出信息
            * @param out
            */
    public void print (PrintStream out) {   
               Iterator elements = files.iterator();   
    while (elements.hasNext()) {   
                   File file=(File) elements.next();   
                       out.println(file.getPath());       
               }   
           }   
     
    public static void output(String path,String regexp) {   
     
               FilesAnalyze fileGroup1 = new FilesAnalyze(path,regexp);   
               fileGroup1.print(System.out);   
           }   
     
    public static void main (String[] args) {   
               output("C:\\","[A-z|.]*");   
           } 
 //用于缓存文件列表        private ArrayList files = new ArrayList();        //用于承载文件路径        private String _path;        //用于承载未合并的正则公式        private String _regexp;                class MyFileFilter implements FileFilter {              /**               * 匹配文件名称               */              public boolean accept(File file) {                try {                  Pattern pattern = Pattern.compile(_regexp);                  Matcher match = pattern.matcher(file.getName());                                  return match.matches();                } catch (Exception e) {                  return true;                }              }            }                /**         * 解析输入流         * @param inputs         */        FilesAnalyze (String path,String regexp){            getFileName(path,regexp);        }                /**         * 分析文件名并加入files         * @param input         */        private void getFileName(String path,String regexp) {            //目录              _path=path;              _regexp=regexp;              File directory = new File(_path);              File[] filesFile = directory.listFiles(new MyFileFilter());              if (filesFile == null) return;              for (int j = 0; j < filesFile.length; j++) {                files.add(filesFile[j]);              }              return;            }            /**         * 显示输出信息         * @param out         */        public void print (PrintStream out) {            Iterator elements = files.iterator();            while (elements.hasNext()) {                File file=(File) elements.next();                    out.println(file.getPath());                }        }        public static void output(String path,String regexp) {            FilesAnalyze fileGroup1 = new FilesAnalyze(path,regexp);            fileGroup1.print(System.out);        }            public static void main (String[] args) {            output("C:\\","[A-z|.]*");        }

Java正则的功用还有很多，事实上只要是字符处理，就没有正则做不到的事情存在。（当然，正则解释时较耗时间就是了|||……）

常用的正则表达式

lorrons@gmail.com (lorron) — Sun, 13 Jul 2008 08:04:16 +0800

Tags: 正则, 正则表达式

"^\d+$"　　//非负整数（正整数 + 0）
"^[0-9]*[1-9][0-9]*$"　　//正整数
"^((-\d+)|(0+))$"　　//非正整数（负整数 + 0）
"^-[0-9]*[1-9][0-9]*$"　　//负整数
"^-?\d+$"　　　　//整数
"^\d+(\.\d+)?$"　　//非负浮点数（正浮点数 + 0）
"^(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$"　　//正浮点数
"^((-\d+(\.\d+)?)|(0+(\.0+)?))$"　　//非正浮点数（负浮点数 + 0）
"^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$"　　//负浮点数
"^(-?\d+)(\.\d+)?$"　　//浮点数
"^[A-Za-z]+$"　　//由26个英文字母组成的字符串
"^[A-Z]+$"　　//由26个英文字母的大写组成的字符串
"^[a-z]+$"　　//由26个英文字母的小写组成的字符串
"^[A-Za-z0-9]+$"　　//由数字和26个英文字母组成的字符串
"^\w+$"　　//由数字、26个英文字母或者下划线组成的字符串
"^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$"　　　　//email地址
"^[a-zA-z]+://(\w+(-\w+)*)(\.(\w+(-\w+)*))*(\?\S*)?$"　　//url
/^(d{2}|d{4})-((0([1-9]{1}))|(1[1|2]))-(([0-2]([1-9]{1}))|(3[0|1]))$/ // 年-月-日
/^((0([1-9]{1}))|(1[1|2]))/(([0-2]([1-9]{1}))|(3[0|1]))/(d{2}|d{4})$/ // 月/日/年
"^([w-.]+)@(([[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.)|(([w-]+.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(]?)$" //Emil
"(d+-)?(d{4}-?d{7}|d{3}-?d{8}|^d{7,8})(-d+)?" //电话号码
"^(d{1,2}|1dd|2[0-4]d|25[0-5]).(d{1,2}|1dd|2[0-4]d|25[0-5]).(d{1,2}|1dd|2[0-4]d|25[0-5]).(d{1,2}|1dd|2[0-4]d|25[0-5])$" //IP地址
匹配中文字符的正则表达式： [\u4e00-\u9fa5]
匹配双字节字符(包括汉字在内)：[^\x00-\xff]
匹配空行的正则表达式：\n[\s| ]*\r
匹配HTML标记的正则表达式：/<(.*)>.*<\/\1>|<(.*) \/>/
匹配首尾空格的正则表达式：(^\s*)|(\s*$)
匹配Email地址的正则表达式：\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*
匹配网址URL的正则表达式：^[a-zA-z]+://(\\w+(-\\w+)*)(\\.(\\w+(-\\w+)*))*(\\?\\S*)?$
匹配帐号是否合法(字母开头，允许5-16字节，允许字母数字下划线)：^[a-zA-Z][a-zA-Z0-9_]{4,15}$
匹配国内电话号码：(\d{3}-|\d{4}-)?(\d{8}|\d{7})?
匹配腾讯QQ号：^[1-9]*[1-9][0-9]*$
下表是元字符及其在正则表达式上下文中的行为的一个完整列表：
\ 将下一个字符标记为一个特殊字符、或一个原义字符、或一个后向引用、或一个八进制转义符。
^ 匹配输入字符串的开始位置。如果设置了 RegExp 对象的Multiline 属性，^ 也匹配 ’\n’ 或 ’\r’ 之后的位置。
$ 匹配输入字符串的结束位置。如果设置了 RegExp 对象的Multiline 属性，$ 也匹配 ’\n’ 或 ’\r’ 之前的位置。
* 匹配前面的子表达式零次或多次。
+ 匹配前面的子表达式一次或多次。+ 等价于 {1,}。
? 匹配前面的子表达式零次或一次。? 等价于 {0,1}。
{n} n 是一个非负整数，匹配确定的n 次。
{n,} n 是一个非负整数，至少匹配n 次。
{n,m} m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次。在逗号和两个数之间不能有空格。
? 当该字符紧跟在任何一个其他限制符 (*, +, ?, {n}, {n,}, {n,m}) 后面时，匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。
. 匹配除 "\n" 之外的任何单个字符。要匹配包括 ’\n’ 在内的任何字符，请使用象 ’[.\n]’ 的模式。
(pattern) 匹配pattern 并获取这一匹配。
(?:pattern) 匹配pattern 但不获取匹配结果，也就是说这是一个非获取匹配，不进行存储供以后使用。
(?=pattern) 正向预查，在任何匹配 pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。
(?!pattern) 负向预查，与(?=pattern)作用相反
x|y 匹配 x 或 y。
[xyz] 字符集合。
[^xyz] 负值字符集合。
[a-z] 字符范围，匹配指定范围内的任意字符。
[^a-z] 负值字符范围，匹配任何不在指定范围内的任意字符。
\b 匹配一个单词边界，也就是指单词和空格间的位置。
\B 匹配非单词边界。
\cx 匹配由x指明的控制字符。
\d 匹配一个数字字符。等价于 [0-9]。
\D 匹配一个非数字字符。等价于 [^0-9]。
\f 匹配一个换页符。等价于 \x0c 和 \cL。
\n 匹配一个换行符。等价于 \x0a 和 \cJ。
\r 匹配一个回车符。等价于 \x0d 和 \cM。
\s 匹配任何空白字符，包括空格、制表符、换页符等等。等价于[ \f\n\r\t\v]。
\S 匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。
\t 匹配一个制表符。等价于 \x09 和 \cI。
\v 匹配一个垂直制表符。等价于 \x0b 和 \cK。
\w 匹配包括下划线的任何单词字符。等价于’[A-Za-z0-9_]’。
\W 匹配任何非单词字符。等价于 ’[^A-Za-z0-9_]’。
\xn 匹配 n，其中 n 为十六进制转义值。十六进制转义值必须为确定的两个数字长。
\num 匹配 num，其中num是一个正整数。对所获取的匹配的引用。
\n 标识一个八进制转义值或一个后向引用。如果 \n 之前至少 n 个获取的子表达式，则 n 为后向引用。否则，如果 n 为八进制数字 (0-7)，则 n 为一个八进制转义值。
\nm 标识一个八进制转义值或一个后向引用。如果 \nm 之前至少有is preceded by at least nm 个获取得子表达式，则 nm 为后向引用。如果 \nm 之前至少有 n 个获取，则 n 为一个后跟文字 m 的后向引用。如果前面的条件都不满足，若 n 和 m 均为八进制数字 (0-7)，则 \nm 将匹配八进制转义值 nm。
\nml 如果 n 为八进制数字 (0-3)，且 m 和 l 均为八进制数字 (0-7)，则匹配八进制转义值 nml。
\un 匹配 n，其中 n 是一个用四个十六进制数字表示的Unicode字符。
匹配中文字符的正则表达式： [u4e00-u9fa5]
匹配双字节字符(包括汉字在内)：[^x00-xff]
应用：计算字符串的长度（一个双字节字符长度计2，ASCII字符计1）
String.prototype.len=function(){return this.replace([^x00-xff]/g,"aa").length;}
匹配空行的正则表达式：n[s| ]*r
匹配HTML标记的正则表达式：/<(.*)>.*|<(.*) />/
匹配首尾空格的正则表达式：(^s*)|(s*$)
应用：javascript中没有像vbscript那样的trim函数，我们就可以利用这个表达式来实现，如下：
String.prototype.trim = function()
{
return this.replace(/(^s*)|(s*$)/g, "");
}
利用正则表达式分解和转换IP地址：
下面是利用正则表达式匹配IP地址，并将IP地址转换成对应数值的Javascript程序：
function IP2V(ip)
{
re=/(d+).(d+).(d+).(d+)/g //匹配IP地址的正则表达式
if(re.test(ip))
{
return RegExp.$1*Math.pow(255,3))+RegExp.$2*Math.pow(255,2))+RegExp.$3*255+RegExp.$4*1
}
else
{
throw new Error("Not a valid IP address!")
}
}
不过上面的程序如果不用正则表达式，而直接用split函数来分解可能更简单，程序如下：
var ip="10.100.20.168"
ip=ip.split(".")
alert("IP值是："+(ip[0]*255*255*255+ip[1]*255*255+ip[2]*255+ip[3]*1))
匹配Email地址的正则表达式：w+([-+.]w+)*@w+([-.]w+)*.w+([-.]w+)*
匹配网址URL的正则表达式：http://([w-]+.)+[w-]+(/[w- ./?%&=]*)?
利用正则表达式去除字串中重复的字符的算法程序：
var s="abacabefgeeii"
var s1=s.replace(/(.).*1/g,"$1")
var re=new RegExp("["+s1+"]","g")
var s2=s.replace(re,"")
alert(s1+s2) //结果为：abcefgi
我原来在CSDN上发贴寻求一个表达式来实现去除重复字符的方法，最终没有找到，这是我能想到的最简单的实现方法。思路是使用后向引用取出包括重复的字符，再以重复的字符建立第二个表达式，取到不重复的字符，两者串连。这个方法对于字符顺序有要求的字符串可能不适用。
得用正则表达式从URL地址中提取文件名的javascript程序，如下结果为page1
s="http://www.9499.net/page1.htm"
s=s.replace(/(.*/){0,}([^.]+).*/ig,"$2")
alert(s)
利用正则表达式限制网页表单里的文本框输入内容：
用正则表达式限制只能输入中文：onkeyup="value=value.replace(/[^u4E00-u9FA5]/g,'')" onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^u4E00-u9FA5]/g,''))"
用正则表达式限制只能输入全角字符： onkeyup="value=value.replace(/[^uFF00-uFFFF]/g,'')" onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^uFF00-uFFFF]/g,''))"
用正则表达式限制只能输入数字：onkeyup="value=value.replace(/[^d]/g,'') "onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^d]/g,''))"
用正则表达式限制只能输入数字和英文：onkeyup="value=value.replace(/[W]/g,'') "onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^d]/g,''))"

密码强度测试

lorrons@gmail.com (lorron) — Tue, 01 Jul 2008 21:36:05 +0800

[CODE=html]

密码强度测试

[/CODE]

AUG Team - JS

jquery在浏览器滚动条上的应用

来自Google的密码强度Javascript验证代码 收藏

复制CSDN的BLOG代码，去掉前面行号的方法收藏

好东西分享 [自动生成文章摘要]

Java正则表达式详解

Java正则表达式详解

长文章分页类

Java正则表达式四种常用功能

查询：

Java正则表达式入门

常用的正则表达式

密码强度测试

来自Google的密码强度Javascript验证代码收藏