社区
ASP
帖子详情
关于ASP正则表达式。提取html中的文本内容
Richai
2017-12-25 09:03:42
最近有个很操蛋的项目。拿不到数据库。于是用网站下载软件把整站下载下来。全是静态页面。现在要把文章内容页通过正则表达把内容提取出来入库。网上试了很多正则表达式都不行。直接上图。求大神帮我看下。我ASP学的不是很好。
每篇文章都是从 <a style=font-size:12pt;FONT-FAMILY="仿宋_GB2312";line-height=150%><br> 这种标签开始到<div align="right">这个标签结束
...全文
1374
5
打赏
收藏
关于ASP正则表达式。提取html中的文本内容
最近有个很操蛋的项目。拿不到数据库。于是用网站下载软件把整站下载下来。全是静态页面。现在要把文章内容页通过正则表达把内容提取出来入库。网上试了很多正则表达式都不行。直接上图。求大神帮我看下。我ASP学的不是很好。 每篇文章都是从 这种标签开始到这个标签结束
复制链接
扫一扫
分享
转发到动态
举报
写回复
配置赞助广告
用AI写文章
5 条
回复
切换为时间正序
请发表友善的回复…
发表回复
打赏红包
太阳风暴1985
2018-02-18
打赏
举报
回复
查找到唯一性就可以了啊。
hookee
2018-02-17
打赏
举报
回复
把 <a style=font-size:12pt;FONT-FAMILY="仿宋_GB2312";line-height=150%><br>和<div align="right"> 先用replace() 换成简单的字符 比如my_start my_end,然后写正则就简单了。
Richai
2017-12-25
打赏
举报
回复
在上传一个文字稍微多一点的把。因为对方要求保密。所以就马赛克了。麻烦大神帮我看看。
Richai
2017-12-25
打赏
举报
回复
自己顶下。
。祈祷大神看到
Richai
2017-12-25
打赏
举报
回复
这是代码。然后注释掉的是我获取的标题。是可以获取到的。就是不能获取文章内容。求大神帮我看看。有什么办法能获取到正文。小弟感激不尽!
精通
正则表达式
基于.NET
ASP
PHP JSP JavaScript
1.运行环境 本书7~10章所附代码的运行环境 Windows家族,.NET Framework 2.0及以上版本 IIS 5.0及以上版本 本书14~16章所附代码的运行环境 Windows家族,Apache 2.0及以上版本 PHP 5.0及以上版本 本书17~18章所附代码的运行环境 Windows家族,Tomcat JDK6.0 本书19~21章所附代码的调试环境 IE 6.0及以上版本 2.调试环境 本书7~10章所附代码的调试环境 Windows家族,.NET Framework 2.0及以上版本 Visual Studio 2005及以上版本、
ASP
.NET 2.0及以上版本 本书14~16章所附代码的调试环境 Windows家族,Apache 2.0及以上版本 PHP 5.0及以上版本 本书17~18章所附代码的调试环境 JDK6.0 Eclipse3.2+Lomboz 本书19~21章所附代码的调试环境 IE 6.0及以上版本
文本
编辑器 3.本书所附光盘范例 第7章(/07/) DataTypeApplication/Default.
asp
x 检查和转换数据 第8章(/08/) StringApplication/StringDealwith.
asp
x 字符串处理 StringBuilderApplication/DealWithStringBuilder.
asp
x 动态字符串处理 第9章(/09/) RegexApplication/Default.
asp
x
正则表达式
类的应用 RegexApplication/GetPage
Html
Data.
asp
x 获取网页的
内容
第10章(/10/)
ASP
NETValidator/Compare.
asp
x 比较验证
ASP
NETValidator/CompareCheck.
asp
x 数据类型检查
ASP
NETValidator/CompareValue.
asp
x 值比较验证
ASP
NETValidator/CustomClient.
asp
x 自定义客户端验证
ASP
NETValidator/CustomServer.
asp
x 自定义服务器端验证
ASP
NETValidator/NotNull.
asp
x 非空验证
ASP
NETValidator/NotNullInitValue.
asp
x 不等于初始化值的验证
ASP
NETValidator/RangeDate.
asp
x 日期范围验证
ASP
NETValidator/RangeInt.
asp
x 整数范围验证
ASP
NETValidator/RangeLetter.
asp
x 字母范围验证
ASP
NETValidator/REDate.
asp
x 日期格式验证
ASP
NETValidator/REEmail.
asp
x 电子邮件格式验证
ASP
NETValidator/REIdentity.
asp
x 身份证号码格式验证
ASP
NETValidator/REInt.
asp
x 整数格式验证
ASP
NETValidator/RENumber.
asp
x 数值格式验证
ASP
NETValidator/REPhone.
asp
x 电话号码格式验证
ASP
NETValidator/REUrl.
asp
x URL地址格式验证
ASP
NETValidator/SummaryDialog.
asp
x 对话框式验证摘要
ASP
NETValidator/SummaryPage.
asp
x 网页式验证摘要 第11章(/11/) 判断是否为对象.
asp
判断是否为对象 判断是否为数值.
asp
判断是否为数值 判断是否为数组.
asp
判断是否为数组 判断是否为日期.
asp
判断是否为日期 判断是否为空.
asp
判断是否为空 判断是否为空值.
asp
判断是否为空值 获取变量类型信息.
asp
获取变量类型信息 第12章(/11/) 从
中
截取字符串.
asp
从
中
截取字符串 切分字符串.
asp
切分字符串 删除字符串前后导空格.
asp
删除字符串前导空格.
asp
删除字符串后导空格.
asp
反向截取字符串.
asp
反向查找字符串.
asp
字符串倒序排列.
asp
字符串大写转化.
asp
字符串小写转化.
asp
字符串替换.
asp
将数组元素连接为字符串.
asp
构造制定字符串.
asp
正向截取字符串.
asp
正向查找字符串.
asp
获取字符串长度.
asp
第13章(/14/) Matches集合与Macth对象.
asp
指定忽略大小写.
asp
获取Matches集合.
asp
进行正则匹配替换.
asp
进行正则匹配检验.
asp
第14章(/14/) 浮点型数据测试.php 浮点型数据测试 字符串数据测试.php 字符串数据测试 数组数据测试.php 数组数据测试 对象测试.php 对象测试 数据类型识别.php 数据类型识别 强制类型转化.php 强制类型转化 计算圆周面积程序.php 计算圆周面积程序 字符串转化.php 字符串转化 数值转化.php 数值转化 数组转化.php 数组转化 第15章(/15/) 计算字符串的长度.php 计算字符串的长度 访问单个字符.php 访问单个字符 检索字符的位置.php 检索字符的位置 截取子字符.php 截取子字符 查找字符串出现的次数.php 查找字符串出现的次数 替换子字符串.php 替换子字符串 按照特定字符进行分割.php 按照特定字符进行分割 按照指定数目进行分割.php 按照指定数目进行分割 删除字符串的空白.php 删除字符串的空白 字符串的填补.php 字符串的填补 字符串大小写的转换.php 字符串大小写的转换 字符串的反转.php 字符串的反转 字符串按ASCII码顺序比较.php 字符串按ASCII码顺序比较 字符串按“自然排序”法比较.php 字符串按“自然排序”法比较 根据单词的发音比较.php 根据单词的发音比较 根据单词的相似性比较.php 根据单词的相似性比较 查找子字符串.php 查找子字符串 搜寻出现的字符.php 搜寻出现的字符 字符匹配.php 字符匹配 字符替换.php 字符替换 字符串翻译.php 字符串翻译 格式化数字.php 格式化数字 格式化表单字符串.php 格式化表单字符串 24.php 格式化字符串 25.php 格式化
HTML
实体 26.php
HTML
标签的清理 解析URL字符串.php 解析URL字符串 解析查询字符串.php 解析查询字符串 URL编码处理.php URL编码处理 查询字符串的构造.php 查询字符串的构造 第16章(/16/) 字符串模式匹配.php 字符串模式匹配 字符串大小模式匹配.php 字符串大小模式匹配 日期字符串模式匹配.php 日期字符串模式匹配 模式替换.php 模式替换 模式分割.php 模式分割
正则表达式
匹配.php
正则表达式
匹配 其他的
正则表达式
匹配.php 其他的
正则表达式
匹配 取得
正则表达式
的全部匹配.php 取得
正则表达式
的全部匹配 返回与模式匹配的数组单元.php 返回与模式匹配的数组单元
正则表达式
的替换.php
正则表达式
的替换
正则表达式
的拆分.php
正则表达式
的拆分 表单验证.php 表单验证 UBBCode.php UBB代码 ubb.
html
UBB代码输入界面 ubb.php UBB代码输出界面 Apache日志分析.php Apache日志分析 第17章(/17/) JSPExample1.jsp JSP页面
中
整型数据的使用 JSPExample2.jsp JSP页面
中
循环输出整型数据 JSPExample3.jsp 计算一光年的距离 JSPExample4.jsp JSP页面
中
计算圆的面积 JSPExample5.jsp JSP页面
中
字符数据的简单使用 JSPExample6.jsp 结合布尔类型变量判断学生成绩等级 JSPExample7.jsp text.
html
页面提交至该页,并显示提交数据 text.
html
页面数据提交至JSPExample7.jsp JSPExample8.jsp 不同类型混合运算自动转换 JSPExample9.jsp 不同类型混合运算强制转换 JSPExample10.jsp 字符串类型与其他数据类型的转换 JSPExample11.jsp 解析字符串的子字符串 stringOP.
html
页面数据提交至JSPExample12.jsp JSPExample12.jsp 字符串替换 JSPExample13.jsp 字符串大小写转换、反转等操作 logon.
html
页面数据提交至JSPExample14.jsp JSPExample14.jsp 字符串数据的比较 JSPExample15.jsp 字符串数据的连接 JSPExample16.jsp 字符串数据的格式化 第18章(/18/) 1.jsp Pattern对象使用split方法示例一 2.jsp Pattern对象使用split方法示例二 3.jsp Matcher对象使用appendReplacement方法示例 4.jsp Matcher对象使用groupCount方法示例 5.jsp Matcher对象使用find方法示例 6.jsp Matcher对象使用group方法示例 7.jsp 字符串对象使用split方法 8.jsp Matcher对象使用replaceAll方法示例 9.
html
页面数据提交至9.jsp 9.jsp 利用
正则表达式
验证邮箱地址 10.
html
页面数据提交至10.jsp 10.jsp 利用
正则表达式
验证URL地址 11.
html
页面数据提交至11.jsp 11.jsp 利用
正则表达式
验证电话号码 第20章(/20/) 从字符串
中
提取
子串(1).
html
从字符串
中
提取
子串(1) 从字符串
中
提取
子串(2).
html
从字符串
中
提取
子串(2) 从字符串
中
提取
子串(3).
html
从字符串
中
提取
子串(3) 删除或替换数组
中
部分数据.
html
删除或替换数组
中
部分数据 删除数组
中
最后一个元素.
html
删除数组
中
最后一个元素 删除数组
中
的第一个元素.
html
删除数组
中
的第一个元素 反序排列数组
中
的元素.
html
反序排列数组
中
的元素 在字符串上加入超级链接.
html
在字符串上加入超级链接 在字符串两端加上小字体标记.
html
在字符串两端加上小字体标记 在字符串两端加入上标标签.
html
在字符串两端加入上标标签 在字符串两端加入下标标签.
html
在字符串两端加入下标标签 在字符串两端加入斜体标签.
html
在字符串两端加入斜体标签 在字符串两端加入锚点标志.
html
在字符串两端加入锚点标志 在字符串的两端加上固定宽度字体标记.
html
在字符串的两端加上固定宽度字体标记 在字符串的两端加上粗体标志.
html
在字符串的两端加上粗体标志 在字符串的两端加入下划线标记.
html
在字符串的两端加入下划线标记 在指定字符串的两端加上大字体标志.
html
在指定字符串的两端加上大字体标志 在数组前面插入数据.
html
在数组前面插入数据 对数组
中
的元素进行排序.
html
对数组
中
的元素进行排序 将一个或多个字符串连接到当前字符串的末尾.
html
将一个或多个字符串连接到当前字符串的末尾 将字符串分割并存储到数组
中
.
html
将字符串分割并存储到数组
中
将字符串转化为大写格式.
html
将字符串转化为大写格式 将字符串转化为小写格式.
html
将字符串转化为小写格式 将指定的数据添加到数组
中
.
html
将指定的数据添加到数组
中
将数组元素连接为字符串.
html
将数组元素连接为字符串 替换字符串
中
指定的
内容
.
html
替换字符串
中
指定的
内容
根据指定的Unicode编码返回一个字符串.
html
根据指定的Unicode编码返回一个字符串 比较两个字符串的大小.
html
比较两个字符串的大小 获取字符串的长度.
html
获取字符串的长度 获取指定位置的字符的Unicode编码.
html
获取指定位置的字符的Unicode编码 获取指定字符(串)第一次在字符串
中
出现的位置.
html
获取指定字符(串)第一次在字符串
中
出现的位置 获取数组
中
的一部分数据.
html
获取数组
中
的一部分数据 设置字符串输出时的前景色.
html
设置字符串输出时的前景色 设置字符串输出时的字体大小.
html
设置字符串输出时的字体大小 返回一个包含数组
中
全部数据的字符串.
html
返回一个包含数组
中
全部数据的字符串 返回字符串
中
指定位置处的字符.
html
返回字符串
中
指定位置处的字符 连接其他数组到当前数组末尾.
html
连接其他数组到当前数组末尾 第21章(/21/) 判断字符串
中
是否存在匹配
内容
.
html
判断字符串
中
是否存在匹配
内容
对字符串进行匹配检测.
html
对字符串进行匹配检测 替换字符串
中
的指定
内容
.
html
替换字符串
中
的指定
内容
编译
正则表达式
.
html
编译
正则表达式
获取与
正则表达式
进行匹配检测的字符串.
html
获取与
正则表达式
进行匹配检测的字符串 获取匹配
内容
右侧的字符信息.
html
获取匹配
内容
右侧的字符信息 获取匹配
内容
左侧的字符信息.
html
获取匹配
内容
左侧的字符信息 获取匹配的
内容
的最后一个索引位置.
html
获取匹配的
内容
的最后一个索引位置 获取子匹配的结果.
html
获取子匹配的结果 获取字符串
中
所有的匹配信息.
html
获取字符串
中
所有的匹配信息 获取最近一次匹配的
内容
.
html
获取最近一次匹配的
内容
获取最近一次匹配的最后一个子匹配.
html
获取最近一次匹配的最后一个子匹配 获取第一次匹配的起始位置(1).
html
获取第一次匹配的起始位置(1) 获取第一次匹配的起始位置(2).
html
获取第一次匹配的起始位置(2)
18.C#字符串和
正则表达式
参考手册 影印版
C#字符串和
正则表达式
参考手册 目 录 第1章 系统处理
文本
的方式 1 1.1 .NET Framework 1 1.1.1 公共语言运行时 2 1.1.2 .NET Framework类库 3 1.2
文本
是一种数据类型 4 1.2.1 C#的数据类型 5 1.2.2 字符和字符集 6 1.2.3 字符串数据类型 10 1.3
文本
存储 10 1.3.1 高速缓存技术 12 1.3.2 内置 13 1.3.3 其他方法 14 1.3.4 .NET实现 14 1.4 字符串操作 18 1.4.1 连接字符串 18 1.4.2 从字符串
中
提取
子串 20 1.4.3 比较字符串 20 1.4.4 字符串转换 21 1.4.5 格式化字符串 21 1.5 字符串用法 22 1.5.1 构建字符串 22 1.5.2 分析字符串 24 1.6 国际化 25 1.7 小结 27 第2章 String类和StringBuilder类 28 2.1 学习本章要用到的工具 28 2.2
文本
结构 29 2.3 String类 30 2.3.1 内置字符串 32 2.3.2 构建 34 2.3.3 字符串的转义 36 2.4 StringBuilder类 37 2.4.1 长度和容量 39 2.4.2 ToString()方法 41 2.5 字符串操作 42 2.5.1 连接字符串 42 2.5.2 从字符串
中
提取
子串 45 2.5.3 比较字符串 46 2.5.4 格式化 50 2.6 字符串的使用 54 2.6.1 建立字符串 54 2.6.2 标记 58 2.6.3 颠倒字符串次序 61 2.6.4 插入、删除和替换 61 2.7 小结 66 第3章 字符串转换 68 3.1 ToString()方法 68 3.2 把数值表示为字符串 69 3.3 把日期和时间表示为字符串 74 3.4 把其他对象表示为字符串 76 3.5 用字符串表示字符串 78 3.6 把字符串转换为其他类型 79 3.6.1 把字符串转换成数字 79 3.6.2 把字符串转换为日期和时间 82 3.7 在集合与数组之间移动字符串 84 3.7.1 数组 85 3.7.2 ArrayList对象 86 3.7.3 IDictionary对象 88 3.8 小结 88 第4章 国际化 89 4.1 Unicode 89 4.2 .NET Framework的编码类 91 4.3 处理字符串 95 4.3.1 CultureInfo类 96 4.3.2 大写和小写 99 4.3.3 不需要区分文化的操作 101 4.3.4 排序 101 4.4 处理字符 106 4.4.1 关于字符的必要信息 107 4.4.2 代理对 107 4.4.3 组合字符 112 4.5 格式化Unicode字符串 114 4.6 字符串用作资源 115 4.7 小结 119 第5章
正则表达式
120 5.1 System.Text.RegularExpressions命名空间 120 5.2 Regex类 121 5.2.1 RegexOptions枚举 121 5.2.2 类构造函数 122 5.2.3 IsMatch()方法 123 5.2.4 Replace()方法 124 5.2.5 Split()方法 125 5.3 Match类和MatchCollection类 127 5.4 Regex测试器示例 131 5.5
正则表达式
基础语法 139 5.5.1 匹配不同类型的字符 139 5.5.2 指定匹配位置 141 5.5.3 指定重复字符 142 5.5.4 指定替换 149 5.5.5 特殊字符 149 5.6 小结 151 第6章
正则表达式
的高级概念 152 6.1 分组、替换和反向引用 152 6.1.1 简单的分组 153 6.1.2 Group类和GroupCollection类 156 6.1.3 替换 161 6.1.4 反向引用 162 6.1.5 高级组 163 6.2 在
正则表达式
中
作决策 168 6.3 在
正则表达式
内设定选项 171 6.4
正则表达式
引擎的规则 171 6.5 小结 173 第7章
正则表达式
模式 174 7.1 验证字符 174 7.2 验证数字 175 7.2.1 只包含数字 175 7.2.2 只包含整型数 175 7.2.3 只包含浮点数 176 7.3 验证电话号码 177 7.4 验证邮政编码 18
面向对象C#初级入门精讲
本套餐面向对象C#零基础入门精讲系列课程包括以下课程。课程1C#开发入门,课程2: C#语言基础,课程3:C#编程基础,课程4:面向对象基础,课程5:面向对象,课程6:WinForm基础,课程7:C#常用类,课程8:文件操作,课程9:集合,课程10:
正则表达式
及应用。专题标签:C#面向对象, C#,文件操作,正则,
正则表达式
。课程定位:抓住精髓 实例精讲 分析透彻 通俗易懂,为.NET开发奠定坚实基础
正则表达式
正则表达式
中
的特殊字符 字符 含意 \ 做为转意,即通常在"\"后面的字符不按原来意义解释,如/b/匹配字符"b",当b前面加了反斜杆后/\b/,转意为匹配一个单词的边界。 -或- 对
正则表达式
功能字符的还原,如"*"匹配它前面元字符0次或多次,/a*/将匹配a,aa,aaa,加了"\"后,/a\*/将只匹配"a*"。 ^ 匹配一个输入或一行的开头,/^a/匹配"an A",而不匹配"An a" $ 匹配一个输入或一行的结尾,/a$/匹配"An a",而不匹配"an A" * 匹配前面元字符0次或多次,/ba*/将匹配b,ba,baa,baaa + 匹配前面元字符1次或多次,/ba*/将匹配ba,baa,baaa ? 匹配前面元字符0次或1次,/ba*/将匹配b,ba (x) 匹配x保存x在名为$1...$9的变量
中
x|y 匹配x或y {n} 精确匹配n次 {n,} 匹配n次以上 {n,m} 匹配n-m次 [xyz] 字符集(character set),匹配这个集合
中
的任一一个字符(或元字符) [^xyz] 不匹配这个集合
中
的任何一个字符 [\b] 匹配一个退格符 \b 匹配一个单词的边界 \B 匹配一个单词的非边界 \cX 这儿,X是一个控制符,/\cM/匹配Ctrl-M \d 匹配一个字数字符,/\d/ = /[0-9]/ \D 匹配一个非字数字符,/\D/ = /[^0-9]/ \n 匹配一个换行符 \r 匹配一个回车符 \s 匹配一个空白字符,包括\n,\r,\f,\t,\v等 \S 匹配一个非空白字符,等于/[^\n\f\r\t\v]/ \t 匹配一个制表符 \v 匹配一个重直制表符 \w 匹配一个可以组成单词的字符(alphanumeric,这是我的意译,含数字),包括下划线,如[\w]匹配"$5.98"
中
的5,等于[a-zA-Z0-9] \W 匹配一个不可以组成单词的字符,如[\W]匹配"$5.98"
中
的$,等于[^a-zA-Z0-9]。 用re = new RegExp("pattern",["flags"]) 的方式比较好 pattern :
正则表达式
flags: g (全文查找出现的所有 pattern) i (忽略大小写) m (多行查找) vaScript动态
正则表达式
问题 请问
正则表达式
可以动态生成吗? 例如JavaScript
中
: var str = "strTemp"; 要生成: var re = /strTemp/; 如果是字符连接: var re = "/" + str + "/"即可 但是要生成表达式,可以实现吗?怎样实现? [JAVA] javascript
正则表达式
秋雨叶 发表于 2004-12-9 14:54:13
正则表达式
是一个描述字符模式的对象。 JavaScript的RegExp对象和String对象定义了使用
正则表达式
来执行强大的模式匹配和
文本
检索与替换函数的方法. 在JavaScript
中
,
正则表达式
是由一个RegExp对象表示的.当然,可以使用一个RegExp()构造函数来创建RegExp对象, 也可以用JavaScript 1.2
中
的新添加的一个特殊语法来创建RegExp对象.就像字符串直接量被定义为包含在引号内的字符一样,
正则表达式
直接量也被定义为包含在一对斜杠(/)之间的字符.所以,JavaScript可能会包含如下的代码: var pattern = /s$/; 这行代码创建一个新的RegExp对象,并将它赋给变量parttern.这个特殊的RegExp对象和所有以字母"s"结尾的字符串都匹配.用RegExp()也可以定义 一个等价的
正则表达式
,代码如下: var pattern = new RegExp("s$"); 无论是用
正则表达式
直接量还是用构造函数RegExp(),创建一个RegExp对象都是比较容易的.较为困难的任务是用
正则表达式
语法来描述字符的模式. JavaScript采用的是Perl语言
正则表达式
语法的一个相当完整的子集.
正则表达式
的模式规范是由一系列字符构成的.大多数字符(包括所有字母数字字符)描述的都是按照字面意思进行匹配的字符.这样说来,
正则表达式
/java/就和 所有包含子串 "java" 的字符串相匹配.虽然
正则表达式
中
的其它字符不是按照字面意思进行匹配的,但它们都具有特殊的意义.
正则表达式
/s$/ 包含两个字符. 第一个特殊字符 "s" 是按照字面意思与自身相匹配.第二个字符 "$" 是一个特殊字符,它所匹配的是字符串的结尾.所以
正则表达式
/s$/ 匹配的就是以字母 "s" 结尾 的字符串. 1.直接量字符 我们已经发现了,在
正则表达式
中
所有的字母字符和数字都是按照字面意思与自身相匹配的.JavaScript的
正则表达式
还通过以反斜杠(\)开头的转义序列支持某些非 字母字符.例如,序列 "\n" 在字符串
中
匹配的是一个直接量换行符.在
正则表达式
中
,许多标点符号都有特殊的含义.下面是这些字符和它们的含义:
正则表达式
的直接量字符 字符 匹配 ________________________________ 字母数字字符 自身 \ f 换页符 \ n 换行符 \ r 回车 \ t 制表符 \ v 垂直制表符 \ / 一个 / 直接量 \ \ 一个 \ 直接量 \ . 一个 . 直接量 \ * 一个 * 直接量 \ + 一个 + 直接量 \ ? 一个 ? 直接量 \ | 一个 | 直接量 \ ( 一个 ( 直接量 \ ) 一个 ) 直接量 \ [ 一个 [ 直接量 \ ] 一个 ] 直接量 \ { 一个 { 直接量 \ } 一个 } 直接量 \ XXX 由十进制数 XXX 指 定的ASCII码字符 \ Xnn 由十六进制数 nn 指定的ASCII码字符 \ cX 控制字符^X. 例如, \cI等价于 \t, \cJ等价于 \n ___________________________________________________ 如果想在
正则表达式
中
使用特殊的标点符号,必须在它们之前加上一个 "\" . 2.字符类 将单独的直接符放进
中
括号内就可以组合成字符类.一个字符类和它所包含的任何一个字符都匹配,所以
正则表达式
/ [abc] / 和字母 "a" , "b" , "c"
中
的任何一个 都匹配.另外还可以定义否定字符类,这些类匹配的是除那些包含在
中
括号之内的字符外的所有字符.定义否定字符尖时,要将一个 ^ 符号作为从左
中
括号算起的第 一个字符.
正则表达式
的集合是 / [a-zA-z0-9] / . 由于某些字符类非常常用,所以JavaScript的
正则表达式
语法包含一些特殊字符和转义序列来表示这些常用的类.例如, \s 匹配的是空格符,制表符和其它空白符, \s 匹配的则是空白符之外的任何字符. 正则表灰式的字符类 字符 匹配 ____________________________________________________ [...] 位于括号之内的任意字符 [^...] 不在括号之
中
的任意字符 . 除了换行符之外的任意字符,等价于[^\n] \w 任何单字字符, 等价于[a-zA-Z0-9] \W 任何非单字字符,等价于[^a-zA-Z0-9] \s 任何空白符,等价于[\ t \ n \ r \ f \ v] \S 任何非空白符,等价于[^\ t \ n \ r \ f \ v] \d 任何数字,等价于[0-9] \D 除了数字之外的任何字符,等价于[^0-9] [\b] 一个退格直接量(特例) ________________________________________________________________ 3.复制 用以上的正则表式的语法,可以把两位数描述成 / \ d \ d /,把四位数描述成 / \d \ d \ d \ d /.但我们还没有一种方法可以用来描述具有任意多数位的数字或者是一个 字符串.这个串由三个字符以及跟随在字母之后的一位数字构成.这些复杂的模式使用的
正则表达式
语法指定了该表达式
中
每个元素要重复出现的次数. 指定复制的字符总是出现在它们所作用的模式后面.由于某种复制类型相当常用.所以有一些特殊的字符专门用于表示它们.例如: +号匹配的就是复制前一模式一次 或多次的模式.下面的表列出了复制语法.先看一个例子: /\d{2, 4}/ //匹配2到4间的数字. /\w{3} \d?/ //匹配三个单字字符和一个任意的数字. /\s+java\s+/ //匹配字符串"java" ,并且该串前后可以有一个或多个空格. /[^"] * / //匹配零个或多个非引号字符.
正则表达式
的复制字符 字符 含义 __________________________________________________________________ {n, m} 匹配前一项至少n次,但是不能超过m次 {n, } 匹配前一项n次,或者多次 {n} 匹配前一项恰好n次 ? 匹配前一项0次或1次,也就是说前一项是可选的. 等价于 {0, 1} + 匹配前一项1次或多次,等价于{1,} * 匹配前一项0次或多次.等价于{0,} ___________________________________________________________________ 4.选择,分组和引用
正则表达式
的语法还包括指定选择项,对子表达式分组和引用前一子表达式的特殊字符.字符| 用于分隔供选择的字符.例如: /ab|cd|ef/ 匹配的是字符串 "ab",或者是 字符串 "cd",又或者 "ef". /\d{3}|[a-z]{4}/ 匹配的是要么是一个三位数,要么是四个小写字母.在
正则表达式
中
括号具有几种作用.它的主要作用是把单独的项目分组 成子表达式,以便可以像处理一个独立的单元那种用 *、+或? 来处理那些项目.例如: /java(script) ?/ 匹配的是字符串 "java",其后既可以有 "script",也可以没有. / (ab|cd) + |ef) / 匹配的既可以是字符串 "ef",也可以是字符串"ab" 或者 "cd" 的一次或多次重复. 在
正则表达式
中
,括号的第二个用途是在完整的模式
中
定义子模式。当一个
正则表达式
成功地和目标字符串相匹配时,可以从目标串
中
抽出和括号
中
的子模式相匹配 的部分.例如,假定我们正在检索的模式是一个或多个字母后面跟随一位或多位数字,那么我们可以使用模式 / [a-z] + \ d+/.但是由于假定我们真正关心的是每个匹配 尾部的数字,那么如果我们将模式的数字部分放在括号
中
(/ [a-z] + (\d+)/) ,我们就可以从所检索到的任何匹配
中
抽取数字了,之后我们会对此进行解析的. 代括号的子表达式的另一个用途是,允许我们在同一
正则表达式
的后面引用前面的子表达式.这是通过在字符串 \ 后加一位或多位数字来实现的.数字指的是代括号的 子表达式在
正则表达式
中
的位置.例如: \1 引用的是第一个代括号的子表达式. \3 引用的是第三个代括号的子表达式.注意,由于子表达式可以嵌套在其它子表达式
中
, 所以它的位置是被计数的左括号的位置. 例如:在下面的
正则表达式
被指定为 \2: /([Jj]ava([Ss]cript)) \sis \s (fun\w*) / 对
正则表达式
中
前一子表达式的引用所指定的并不是那个子表达式的模式,而是与那个模式相匹配的
文本
.这样,引用就不只是帮助你输入
正则表达式
的重复部分的快 捷方式了,它还实施了一条规约,那就是一个字符串各个分离的部分包含的是完全相同的字符.例如:下面的
正则表达式
匹配的就是位于单引号或双引号之内的所有字 符.但是,它要求开始和结束的引号匹配(例如两个都是双引号或者都是单引号): /[' "] [^ ' "]*[' "]/ 如果要求开始和结束的引号匹配,我们可以使用如下的引用: /( [' "] ) [^ ' "] * \1/ \1匹配的是第一个代括号的子表达式所匹配的模式.在这个例子
中
,它实施了一种规约,那就是开始的引号必须和结束的引号相匹配.注意,如果反斜杠后跟随的数字比 代括号的子表达式数多,那么它就会被解析为一个十进制的转义序列,而不是一个引用.你可以坚持使用完整的三个字符来表示转义序列,这们就可以避免混淆了.例如, 使用 \044,而不是\44.下面是
正则表达式
的选择、分组和引用字符: 字符 含义 ____________________________________________________________________ | 选择.匹配的要么是该符号左边的子表达式,要么它右边的子表达式 (...) 分组.将几个项目分为一个单元.这个单元可由 *、+、?和|等符号使用,而且还可以记住和这个组匹配的字符以供此后引 用使用 \n 和第n个分组所匹配的字符相匹配.分组是括号
中
的子表达式(可能是嵌套的).分组号是从左到右计数的左括号数 ____________________________________________________________________ 5.指定匹配的位置 我们已经看到了,一个
正则表达式
中
的许多元素才能够匹配字符串的一个字符.例如: \s 匹配的只是一个空白符.还有一些
正则表达式
的元素匹配的是字符之间宽度为 0的空间,而不是实际的字符例如: \b 匹配的是一个词语的边界,也就是处于一个/w字字符和一个\w非字字符之间的边界.像\b 这样的字符并不指定任何一个匹配了的 字符串
中
的字符,它们指定的是匹配所发生的合法位置.有时我们称这些元素为
正则表达式
的锚.因为它们将模式定位在检索字符串
中
的一个特定位置.最常用的锚元 素是 ^, 它使模式依赖于字符串的开头,而锚元素$则使模式定位在字符串的末尾. 例如:要匹配词 "javascript" ,我们可以使用
正则表达式
/^ javascript $/. 如果我们想检索 "java" 这个词自身 (不像在 "javascript"
中
那样作为前缀),那么我们可以使 用模式 /\s java \s /, 它要求在词语java之前和之后都有空格.但是这样作有两个问题.第一: 如果 "java" 出现在一个字符的开头或者是结尾.该模式就不会与之匹配,除 非在开头和结尾处有一个空格. 第二: 当这个模式找到一个与之匹配的字符时,它返回的匹配的字符串前端和后端都有空格,这并不是我们想要的.因此,我们使用词语 的边界 \b 来代替真正的空格符 \s 进行匹配. 结果表达式是 /\b java \b/. 下面是
正则表达式
的锚字符: 字符 含义 ____________________________________________________________________ ^ 匹配的是字符的开头,在多行检索
中
,匹配的是一行的开头 $ 匹配的是字符的结尾,在多行检索
中
,匹配的是一行的结尾 \b 匹配的是一个词语的边界.简而言之就是位于字符\w 和 \w之间的位置(注意:[\b]匹配的是退格符) \B 匹配的是非词语的边界的字符 _____________________________________________________________________ 6.属性 有关
正则表达式
的语法还有最后一个元素,那就是
正则表达式
的属性,它说明的是高级模式匹配的规则.和其它
正则表达式
语法不同,属性是在 / 符号之外说明的.即它 们不出现在两个斜杠之间,而是位于第二个斜杠之后.javascript 1.2支持两个属性.属性 i 说明模式匹配应该是大小写不敏感的.属性 g 说明模式匹配应该是全局的.也 就是说,应该找出被检索的字符串
中
所有的匹配.这两种属性联合起来就可以执行一个全局的,大小写不敏感的匹配. 例如: 要执行一个大小不敏感的检索以找到词语 "java" (或者是 "java" 、"JAVA"等) 的第一个具体值,我们可以使用大小不敏感的
正则表达式
/\b java\b/i .如果要在 一个字符串
中
找到 "java" 所有的具体值,我们还可以添加属性 g, 即 /\b java \b/gi . 以下是
正则表达式
的属性: 字符 含义 _________________________________________ i 执行大小写不敏感的匹配 g 执行一个全局的匹配,简而言之,就是找到所有的匹配,而不是在找到第一个之后就停止了 _________________________________________ 除属性 g 和 i 之外,
正则表达式
就没有其它像属性一样的特性了.如果将构造函数 RegExp 的静态属性 multiline 设置为 true ,那么模式匹配将以多行的模式进行.在这 种模式下,锚字符 ^ 和 $ 匹配的不只是检索字符串的开头和结尾,还匹配检索字符串内部的一行的开头和结尾.例如: 模式 /Java$/ 匹配的是 "Java",但是并不匹配 "Java\nis fun" .如果我们设置了 multiline 属性,那么后者也将被匹配: RegExp.multiline = true; 在JAVASCRIPT里面判断一个字符串是否是电子邮件的格式: if(formname.email.value!=formname.email.value.match(/^\w +[@]\w +[.][\w.] +$/)) { alert("您的电子邮件格式错误!"); formname.email.focus(); return false; } 阅读全文(42) | 回复(0) | 引用(0) | [用365key收藏此日志] [RED]function dateVerify(date){ var reg = /^(\d{4})(-)(\d{2})\2(\d{2})$/; var r = date.match(reg); if(r==null) return false; var d= new Date(r[1], r[3]-1,r[4]); var newStr=d.getFullYear()+r[2]+(d.getMonth()+1)+r[2]+d.getDate(); date=r[1]+r[2]+((r[3]-1)+1)+r[2]+((r[4]-1)+1); return newStr==date; }[/RED] javascript的17种
正则表达式
作者: 不祥 时间: 2004-6-9 "^\\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 JavaScript
中
的
正则表达式
(2) 作者 :
中
国论坛网收集 来源 :http://www.51one.net 加入时间 :2004-8-25
正则表达式
对象的属性及方法 预定义的
正则表达式
拥有有以下静态属性:input, multiline, lastMatch, lastParen, leftContext, rightContext和$1到$9。其
中
input和multiline可以预设置。其他属性的值在执行过exec或test方法后被根据不同条件赋以不同的值。许多属性同时拥有长和短(perl风格)的两个名字,并且,这两个名字指向同一个值。(JavaScript模拟perl的
正则表达式
)
正则表达式
对象的属性 属性 含义 $1...$9 如果它(们)存在,是匹配到的子串 $_ 参见input $* 参见multiline $& 参见lastMatch $+ 参见lastParen $` 参见leftContext $'' 参见rightContext constructor 创建一个对象的一个特殊的函数原型 global 是否在整个串
中
匹配(bool型) ignoreCase 匹配时是否忽略大小写(bool型) input 被匹配的串 lastIndex 最后一次匹配的索引 lastParen 最后一个括号括起来的子串 leftContext 最近一次匹配以左的子串 multiline 是否进行多行匹配(bool型) prototype 允许附加属性给对象 rightContext 最近一次匹配以右的子串 source
正则表达式
模式 lastIndex 最后一次匹配的索引
正则表达式
对象的方法 方法 含义 compile
正则表达式
比较 exec 执行查找 test 进行匹配 toSource 返回特定对象的定义(literal representing),其值可用来创建一个新的对象。重载Object.toSource方法得到的。 toString 返回特定对象的串。重载Object.toString方法得到的。 valueOf 返回特定对象的原始值。重载Object.valueOf方法得到 例子 var myReg = /(w+)s(w+)/; var str = "John Smith"; var newstr = str.replace(myReg, "$2, $1"); document.write(newstr); 将输出"Smith, John" javascript
正则表达式
检验 /********************************************************************************* * EO_JSLib.js * javascript
正则表达式
检验 **********************************************************************************/ //校验是否全由数字组成 function isDigit(s) { var patrn=/^[0-9]{1,20}$/; if (!patrn.exec(s)) return false return true } //校验登录名:只能输入5-20个以字母开头、可带数字、“_”、“.”的字串 function isRegisterUserName(s) { var patrn=/^[a-zA-Z]{1}([a-zA-Z0-9]|[._]){4,19}$/; if (!patrn.exec(s)) return false return true } //校验用户姓名:只能输入1-30个以字母开头的字串 function isTrueName(s) { var patrn=/^[a-zA-Z]{1,30}$/; if (!patrn.exec(s)) return false return true } //校验密码:只能输入6-20个字母、数字、下划线 function isPasswd(s) { var patrn=/^(\w){6,20}$/; if (!patrn.exec(s)) return false return true } //校验普通电话、传真号码:可以“+”开头,除数字外,可含有“-” function isTel(s) { //var patrn=/^[+]{0,1}(\d){1,3}[ ]?([-]?(\d){1,12})+$/; var patrn=/^[+]{0,1}(\d){1,3}[ ]?([-]?((\d)|[ ]){1,12})+$/; if (!patrn.exec(s)) return false return true } //校验手机号码:必须以数字开头,除数字外,可含有“-” function isMobil(s) { var patrn=/^[+]{0,1}(\d){1,3}[ ]?([-]?((\d)|[ ]){1,12})+$/; if (!patrn.exec(s)) return false return true } //校验邮政编码 function isPostalCode(s) { //var patrn=/^[a-zA-Z0-9]{3,12}$/; var patrn=/^[a-zA-Z0-9 ]{3,12}$/; if (!patrn.exec(s)) return false return true } //校验搜索关键字 function isSearch(s) { var patrn=/^[^`~!@#$%^&*()+=|\\\][\]\{\}:;'\,./?]{1}[^`~!@$%^&()+=|\\\][\]\{\}:;'\,.?]{0,19}$/; if (!patrn.exec(s)) return false return true } function isIP(s) //by zergling { var patrn=/^[0-9.]{1,20}$/; if (!patrn.exec(s)) return false return true }
正则表达式
regular expression详述(一) http://www.kymita.com/888.
asp
2002-12-15 蓝箭工作室
正则表达式
是regular expression,看来英文比
中
文要好理解多了,就是检查表达式符 不符合规定!!
正则表达式
有一个功能十分强大而又十分复杂的对象RegExp,在JavaScript1.2 版本以 上提供。 下面我们看看有关
正则表达式
的介绍:
正则表达式
对象用来规范一个规范的表达式(也就是表达式符不符合特定的要求,比如是不是Email 地址格式等),它具有用来检查给出的字符串是否符合规则的属性和方法。 除此之外,你用RegExp构造器建立的个别
正则表达式
对象的属性,就已经预先定义好了
正则表达式
对象的静态属性,你可以随时使用它们。 核心对象: 在JavaScript 1.2, NES 3.0以上版本提供。 在JavaScript 1.3以后版本增加了toSource方法。 建立方法: 文字格式或RegExp构造器函数。 文字建立格式使用以下格式: /pattern/flags即/模式/标记 构造器函数方法使用方法如下: new RegExp("pattern"[, "flags"])即new RegExp("模式"[,"标记"]) 参数: pattern(模式) 表示
正则表达式
的
文本
flags(标记) 如果指定此项,flags可以是下面值之一: g: global match(全定匹配) i: ignore case(忽略大小写) gi: both global match and ignore case(匹配所有可能的值,也忽略大小写) 注意:
文本
格式
中
的参数不要使用引号标记,而构造器函数的参数则要使用引号标记。所以下面的 表达式建立同样的
正则表达式
: /ab+c/i new RegExp("ab+c", "i") 描述: 当使用构造函数的时候,必须使用正常的字符串避开规则(在字符串
中
加入前导字符\ )是必须的。 例如,下面的两条语句是等价的: re = new RegExp("\\w+") re = /\w+/ 下面的提供了在
正则表达式
中
能够使用的完整对特殊字符的一个完整的列表和描述。 表1.3:
正则表达式
中
的特殊字符: 字符\ 意义:对于字符,通常表示按字面意义,指出接着的字符为特殊字符,\不作解释。 例如:/b/匹配字符'b',通过在b 前面加一个反斜杠\,也就是/\b/,则该字符变成特殊字符,表示 匹配一个单词的分界线。 或者: 对于几个字符,通常说明是特殊的,指出紧接着的字符不是特殊的,而应该按字面解释。 例如:*是一个特殊字符,匹配任意个字符(包括0个字符);例如:/a*/意味匹配0个或多个a。 为了匹配字面上的*,在a前面加一个反斜杠;例如:/a\*/匹配'a*'。 字符^ 意义:表示匹配的字符必须在最前边。 例如:/^A/不匹配"an A,"
中
的'A',但匹配"An A."
中
最前面的'A'。 字符$ 意义:与^类似,匹配最末的字符。 例如:/t$/不匹配"eater"
中
的't',但匹配"eat"
中
的't'。 字符* 意义:匹配*前面的字符0次或n次。 例如:/bo*/匹配"A ghost booooed"
中
的'boooo'或"A bird warbled"
中
的'b',但不匹配"A goat g runted"
中
的任何字符。 字符+ 意义:匹配+号前面的字符1次或n次。等价于{1,}。 例如:/a+/匹配"candy"
中
的'a'和"caaaaaaandy."
中
的所有'a'。 字符? 意义:匹配?前面的字符0次或1次。 例如:/e?le?/匹配"angel"
中
的'el'和"angle."
中
的'le'。 字符. 意义:(小数点)匹配除换行符外的所有单个的字符。 例如:/.n/匹配"nay, an apple is on the tree"
中
的'an'和'on',但不匹配'nay'。 字符(x) 意义:匹配'x'并记录匹配的值。 例如:/(foo)/匹配和记录"foo bar."
中
的'foo'。匹配子串能被结果数组
中
的素[1], ..., [n] 返 回,或被RegExp对象的属性$1, ..., $9返回。 字符x|y 意义:匹配'x'或者'y'。 例如:/green|red/匹配"green apple"
中
的'green'和"red apple."
中
的'red'。 字符{n} 意义:这里的n是一个正整数。匹配前面的n个字符。 例如:/a{2}/不匹配"candy,"
中
的'a',但匹配"caandy,"
中
的所有'a'和"caaandy."
中
前面的两个 'a'。 字符{n,} 意义:这里的n是一个正整数。匹配至少n个前面的字符。 例如:/a{2,}不匹配"candy"
中
的'a',但匹配"caandy"
中
的所有'a'和"caaaaaaandy."
中
的所有'a' 字符{n,m} 意义:这里的n和m都是正整数。匹配至少n个最多m个前面的字符。 例如:/a{1,3}/不匹配"cndy"
中
的任何字符,但匹配 "candy,"
中
的'a',"caandy,"
中
的前面两个 'a'和"caaaaaaandy"
中
前面的三个'a',注意:即使"caaaaaaandy"
中
有很多个'a',但只匹配前面的三 个'a'即"aaa"。 字符[xyz] 意义:一字符列表,匹配列出
中
的任一字符。你可以通过连字符-指出一个字符范围。 例如:[abcd]跟[a-c]一样。它们匹配"brisket"
中
的'b'和"ache"
中
的'c'。 字符[^xyz] 意义:一字符补集,也就是说,它匹配除了列出的字符外的所有东西。 你可以使用连字符-指出一 字符范围。 例如:[^abc]和[^a-c]等价,它们最早匹配"brisket"
中
的'r'和"chop."
中
的'h'。 字符[\b] 意义:匹配一个空格(不要与\b混淆) 字符\b 意义:匹配一个单词的分界线,比如一个空格(不要与[\b]混淆) 例如:/\bn\w/匹配"noonday"
中
的'no',/\wy\b/匹配"possibly yesterday."
中
的'ly'。 字符\B 意义:匹配一个单词的非分界线 例如:/\w\Bn/匹配"noonday"
中
的'on',/y\B\w/匹配"possibly yesterday."
中
的'ye'。 字符\cX 意义:这里的X是一个控制字符。匹配一个字符串的控制字符。 例如:/\cM/匹配一个字符串
中
的control-M。 字符\d 意义:匹配一个数字,等价于[0-9]。 例如:/\d/或/[0-9]/匹配"B2 is the suite number."
中
的'2'。 字符\D 意义:匹配任何的非数字,等价于[^0-9]。 例如:/\D/或/[^0-9]/匹配"B2 is the suite number."
中
的'B'。 字符\f 意义:匹配一个表单符 字符\n 意义:匹配一个换行符 字符\r 意义:匹配一个回车符 字符\s 意义:匹配一个单个white空格符,包括空格,tab,form feed,换行符,等价于[ \f\n\r\t\v]。 例如:/\s\w*/匹配"foo bar."
中
的' bar'。 字符\S 意义:匹配除white空格符以外的一个单个的字符,等价于[^ \f\n\r\t\v]。 例如:/\S/\w*匹配"foo bar."
中
的'foo'。 字符\t 意义:匹配一个制表符 字符\v 意义:匹配一个顶头制表符 字符\w 意义:匹配所有的数字和字母以及下划线,等价于[A-Za-z0-9_]。 例如:/\w/匹配"apple,"
中
的'a',"$5.28,"
中
的'5'和"3D."
中
的'3'。 字符\W 意义:匹配除数字、字母外及下划线外的其它字符,等价于[^A-Za-z0-9_]。 例如:/\W/或者/[^$A-Za-z0-9_]/匹配"50%."
中
的'%'。 字符\n 意义:这里的n是一个正整数。匹配一个
正则表达式
的最后一个子串的n的值(计数左圆括号)。 例如:/apple(,)\sorange\1/匹配"apple, orange, cherry, peach."
中
的'apple, orange',下面 有一个更加完整的例子。 注意:如果左圆括号
中
的数字比\n指定的数字还小,则\n取下一行的八进制escape作为描述。 字符\ooctal和\xhex 意义:这里的\ooctal是一个八进制的escape值,而\xhex是一个十六进制的escape值,允许在一个
正则表达式
中
嵌入ASCII码。 当表达式被检查的时候,文字符号提供了编辑
正则表达式
的方法。利用文字符号可以使到正则表达 式保持为常数。例如,如果你在一个循环
中
使用文字符号来构造一个
正则表达式
,
正则表达式
不需进行 反复编译。
正则表达式
对象构造器,例如,new RegExp("ab+c"),提供
正则表达式
的运行时编译。当你知道正 则表达式的模式会变化的时候,应该使用构造函数,或者你不知道
正则表达式
的模式,而它们是从另外 的源获得的时候,比如由用户输入时。一旦你定义好了
正则表达式
,该
正则表达式
可在任何地方使用, 并且可以改变,你可以使用编译方法来编译一个新的
正则表达式
以便重新使用。 一个分离预先定义的RegExp对象可以在每个窗口
中
使用;也就是说,每个分离的JavaScript线程运 行以获得自己的RegExp对象。因为每个脚本在一个线程
中
是不可
中
断的,这就确保了不同的脚本不会覆 盖RegExp对象的值。 预定义的RegExp对象包含的静态属性:input, multiline, lastMatch,lastParen, leftContext, rightContext, 以及从$1到$9。input和multiline属性能被预设。其它静态属性的值是在执行个别正则 表达式对象的exec和test方法后,且在执行字符串的match和replace方法后设置的。 属性 注意RegExp对象的几个属性既有长名字又有短名字(象Perl)。这些名字都是指向相同的值。Perl是 一种编程语言,而JavaScript模仿了它的
正则表达式
。 属性$1, ..., $9 取得匹配的子串,如果有的话 属性$_ 参考input 属性$* 参考multiline 属性$& 参考lastMatch 属性$+ 参考lastParen 属性$` 参考leftContext 属性$' 参考rightContext 属性constructor 指定用来建立对象原型函 属性global 决定是否测试
正则表达式
是否不能匹配所有的字符串,或者只是与最先的冲突。 属性ignoreCase 决定试图匹配字符串的时候是否忽略大小写 属性input 当
正则表达式
被匹配的时候,为相反的字符串。 属性lastIndex 决定下一次匹配从那里开始 属性lastMatch 最后一个匹配的字符 属性lastParen 子串匹配的时候,最后一个parenthesized,如果有的话。 属性leftContext 最近一次匹配前的子串。 属性multiline 是否在串的多行
中
搜索。 属性prototype 允许附加属性到所有的对象 属性rightContext 最近一次匹配后的的子串。 属性source 模式
文本
方法 compile方法 编译一个
正则表达式
对象 exec方法 运行
正则表达式
匹配 test方法 测试正则达式匹配 toSource方法 返回一个对象的文字描述指定的对象;你可以使用这个值来建立一个新的对象。不考虑Object.toS ource方法。 toString方法 返回一个字符串描述指定的对象,不考虑Object.toString对象。 valueOf方法 返回指定对角的原始值。不考虑Object.valueOf方法。 另外,这个对象继承了对象的watch和unwatch方法 例子: 例1、下述示例脚本使用replace方法来转换串
中
的单词。在替换的
文本
中
,脚本使用全局 RegExp 对象的$1和$2属性的值。注意,在作为第二个参数传递给replace方法的时候,RegExp对象的$属性的名 称。 re = /(\w+)\s(\w+)/; str = "John Smith"; newstr=str.replace(re,"$2, $1"); document.write(newstr) 显示结果:"Smith, John". 例2、下述示例脚本
中
,RegExp.input由Change事件处理句柄设置。在getInfo函数
中
,exec 方法 使用RegExp.input的值作为它的参数,注意RegExp预置了$属性。 function getInfo(abc) { re = /(\w+)\s(\d+)/; re.exec(abc.value); window.alert(RegExp.$1 + ", your age is " + RegExp.$2); } 请输入你的姓和年龄,输入完后按回车键。 $1, ..., $9属性 用圆括号括着的匹配子串,如果有的话。 是RegExp的属性 静态,只读 在JavaScript 1.2, NES 3.0以上版本提供 描述:因为input是静态属性,不是个别
正则表达式
对象的属性。你可以使用RegExp.input 访问该 属性。 能加上圆括号的子串的数量不受限制,但
正则表达式
对象只能保留最后9 条。如果你要访问所有的 圆括号内的匹配字串,你可以使用返回的数组。 这些属性能用在RegExp.replace方法替换后的字符串(输出结果)。当使用这种方式的时候,不用预 先考虑RegExp对象。下面给出例子。当
正则表达式
中
没有包含圆括号的时候,该脚本解释成$n的字面意 义。(这里的n是一个正整数)。 例如: 下例脚本使用replace 方法来交换串
中
单词的位置。在替换后的
文本
字串
中
,脚本使用
正则表达式
RegExp对象的$1和$2属性的值。注意:当它们向replace方法传递参数的时候,这里没有考虑 $ 属性的 RegExp对象的名称。 re = /(\w+)\s(\w+)/; str = "John Smith"; newstr=str.replace(re,"$2, $1"); document.write(newstr) 显示的输出结果为:Smith, John。
正则表达式
regular expression详述(二) http://www.kymita.com/888.
asp
2002-12-15 蓝箭工作室
正则表达式
详述(二) 以下这些不是
正则表达式
的新增对象请参阅对应的JavaScript对象的属性 $_属性 参考input $*属性 参考multiline $&属性 参考lastMatch $+属性 参考lastParen $`属性 参考leftContext $'属性 参考rightContext compile方法 在脚本运行期间编译
正则表达式
对象 属于RegExp的方法 在JavaScript 1.2, NES 3.0以上版本提供 语法: regexp.compile(pattern[, flags]) 以数: regexp
正则表达式
的名称,可以是变量名或文字串。 pattern
正则表达式
的定义
文本
。 flags 如果指定的话,可以是下面其
中
的一个: "g": 匹配所有可能的字串 "i": 忽略大小写 "gi": 匹配所有可能的字串及忽略大小写 描述: 使用compile方法来编译一个
正则表达式
created with the RegExp constructor function。这样 就强制
正则表达式
只编译一次,而不是每次遇到
正则表达式
的时候都编译一次。当你确认
正则表达式
能 保持不变的时候可使用compile 方法来编译它(在获得它的匹配模式后),这样就可以在脚本
中
重复多次使用它。 你亦可以使用compile 方法来改变在运行期间改变
正则表达式
。例如,假如
正则表达式
发生变化, 你可以使用compile方法来重新编译该对象来提高使用效率。 使用该方法将改变
正则表达式
的source, global和ignoreCasesource属性的值。 constructor 指出建立对象原型的function。注意这个属性的值由函数本身提供,而不是一个字串包含RegExp的name.Property提供。 在JavaScript 1.1, NES 2.0以上版本提供 ECMA版本ECMA-262 描述:参考Object.constructor. exec方法 在指定的字符串运行匹配搜索。返回一个结果数组。 是RegExp的方法 在JavaScript 1.2, NES 3.0以上版本提供 语法: regexp.exec([str])regexp([str]) 参数: regexp,
正则表达式
的名称,可以是一个变量名或文字定义串。 str,要匹配
正则表达式
的字符串,如果省略,将使用RegExp.input的值。 描述:就如在语法描述
中
的一样,正则表达工的exec方法能够被直接调用(使用regexp.exec(str))或者间接调用(使用regexp(str))。 假如你只是运行以找出是否匹配,可以使用String搜索方法。 假如匹配成功,exec方法返回一个数组并且更新
正则表达式
对象属性的值和预先定义的
正则表达式
对象、RegExp。如果匹配失败,exec方法返回null。 请看下例: //匹配一个b接着一个或多个d,再接着一个b //忽略大小写 myRe=/d(b+)(d)/ig; myArray = myRe.exec("cdbBdbsbz"); 下面是该脚本的返回值:对象 属性/Index 描述 例子 myArray myArray的
内容
["dbBd", "bB", "d"] index 基于0的匹配index 1 input 原始字符串 cdbBdbsbz [0] 最后匹配的字符 dbBd [1], ...[n] 用圆括号括住的匹配字符串,如果有的话。不限制括号的个数。 [1] = bB [2] = d myRe lastIndex 开始下次匹配操作的index值 5 ignoreCase 指出"i"是否使用以忽略大小写 true global 指出是否使用"g"标记来进行匹配所有可能的字串 true source 定义模式的
文本
字符串 d(b+)(d) RegExp lastMatch$& 最后匹配的字符 dbBd leftContext$\Q 最新匹配前面的子串 c rightContext$' 最新匹配后面的子串 bsbz $1, ...$9 圆括号内的匹配子串,如果有的话。圆括号的个数不受限制,但RegExp只能保留最后9个 $1 = bB $2 = d lastParen $+ 最后一个加上圆括号的匹配子串,如果有的话 d 假如你的
正则表达式
使用了"g"标记,你可以多次使用exec 方法来连续匹配相同的串。当你这样做 的时候,新的匹配将从由
正则表达式
的lastIndex 属性值确定的子串
中
开始。例如,假定你使用下面的脚本: myRe=/ab*/g;str = "abbcdefabh" myArray = myRe.exec(str); document.writeln("Found "+myArray[0]+". Next match starts at "+myRe.lastIndex) mySecondArray = myRe.exec(str); document.writeln("Found "+mySecondArray[0]+". Next match starts at "+myRe.lastIndex) 这个脚本显示如下结果: Found abb. Next match starts at 3 Found ab. Next match starts at 9 例子: 在下面的例子
中
,用户输入一个名字,脚本根据输入执行匹配操作。接着检查数组看是否和其它用户的名字匹配。 本脚本假定已注册的用户的姓已经存进了数组A
中
,或许从一个数据库
中
取得。 A = ["zhao","qian","sun","li","liang"] function lookup() { firstName = /\w+/i(); if (!firstName) window.alert (RegExp.input + "非法输入"); else { count=0; for (i=0;i 输入你的姓然后按回车键。 global属性
正则表达式
中
是否使用了"g"标记。 RegExp属性,只读 在JavaScript 1.2, NES 3.0以上版本提供 描述: global是一个个别
正则表达式
对象的属性 如果使用了"g"标记,global的值为true;否则为 false。"g"标记指定
正则表达式
测试所有可能的匹配。 你不能直接改变该属性的值,但可以调用compile方法来改变它。 ignoreCase 检查
正则表达式
是否使用了"i"标记 RegExp属性,只读 在JavaScript 1.2, NES 3.0以上版本提供 描述: ignoreCase是个别
正则表达式
对象的一个属性。 如果使用了"i"标记,则返回true,否则返回false。"i"标记指示在进行匹配的时候忽略大小写。 你不能直接改变该属性的值,但可以通过调用compile方法来改变它 input 指出
正则表达式
要测试那个字串。$_是这个属性的另一个名字。 RegExp的属性,静态 在JavaScript 1.2, NES 3.0以上版本提供 描述:因为input是静态的,不是某个个别的
正则表达式
对象的属性。你也可以使用 RegExp.input来表示。 如果没有给
正则表达式
的exec或test方法提供字符串,并且RegExp.input
中
有值,则使用它的值来调用该方法。 脚本或浏览器能够预置input属性。如果被预置了值且调用exec或 test方法的时候没有提供字符串 则调用exec或test的时候使用input的值。input可以被浏览器以下面的方式设置: 当text表单域处理句柄被调用的时候,input被设置为该text输入的字串。 当textarea表单域处理句柄被调用的时候,input被设置为textarea域内输入的字串。注意multili ne亦被设置成true从而能匹配多行
文本
。 当select表单域处理句柄被调用的时候,input被设置成selected text的值。 当链接对象的处理句柄被调用的时候,input被设置成和之间的字符串。 事件理现句柄处理完毕后,input属性的值被清除。 lastIndex 可读/可写的一个整数属性,指出下一次匹配从哪里开始。 RegExp的属性 在JavaScript 1.2, NES 3.0以上版本提供 描述:lastIndex 是个别的
正则表达式
对象的属性。 这个属性只有当
正则表达式
的"g"标记被使用以进行全串匹配的时候才被设置。实行以下规则: 如果lastIndex大小字符串的长度,regexp.test和regexp.exec失败,且lastIndex被设为0。 如果lastIndex等于字串的长度且
正则表达式
匹配空字符串,则
正则表达式
从lastIndex的位置开始匹配。 如果lastIndex等于字符串的长度且
正则表达式
不匹配空字符串,则
正则表达式
不匹配input,且lastIndex被置为0。 否则,lastIndex被设置成最近一次匹配的下一点。 例如,按下面的顺序执行脚本: re = /(hi)?/g 匹配空字符串 re("hi") 返回["hi", "hi"],lastIndex置为2 re("hi") 返回[""],一个空数组,它的下标为0的元素就是匹配字符串。在这种情况下,返回空 串是因为lastIndex等于2(且仍然是2),并且"hi"的长度也是2。 lastMatch 最后一次匹配字符串,$&是同样的意思。 RegExp的属性,静态,只读 在JavaScript 1.2, NES 3.0以上版本提供 描述:因为lastMatch是静态的,所以它不是个别指定
正则表达式
的属性。你也可以使用RegExp.lastMatch。 lastParen 最后一次加上括号的匹配字符串,如果有的话。$+是同样的意思。 RegExp属性,静态,只读 在JavaScript 1.2, NES 3.0以上版本提供 描述:因为lastParen是静态的,它不是某个个别正则式的属性,你可以使用RegExp.lastParen 表达同样的意思。 leftContext 最近一次匹配前面的子串,$`具有相同的意思。 RegExp的属性,静态,只读 在JavaScript 1.2, NES 3.0以上版本提供 描述:因为leftContext是静态的,不是某一个
正则表达式
的属性,所以可以使用RegExp.leftContext来表达想同的意思。 multiline 反映是否匹配多行
文本
,$*是相同的意思。 RegExp的属性,静态 在JavaScript 1.2, NES 3.0以上版本提供 描述:因为multiline是静态的,而不是某个个别
正则表达式
的属性,所以能够用RegExp.multiline表达相同的意思。 如果允许匹配多行
文本
,则multiline为true,如果搜索必须在换行时停止,则为false。 脚本或浏览器能够设置multiline属性。当一个textarea的事件处理句柄被调用的时候,multiline 被置为true。在事件处理句柄处理完毕后,multiline属性值被清除。也就是说,如果你设置了multili ne为true,则执行任何的事件处理句柄后,multiline被置为false。 prototype 描绘类的原型。你可以根据要求使用prototype来增加类的属性或方法。为了获得prototypes 的资 料,请参阅RegExp的Function.prototype.Property属性。 从JavaScript 1.1, NES 2.0版本开始提供 ECMA版本ECMA-262 rightContext 最后一次匹配的右边的字符串,$'是同样的效果。 RegExp的属性,静态,只读 从 JavaScript 1.2, NES 3.0以上版本开始提供 描述:因为rightContext是静态的,不是某个个别正则表达工的属性,可以使用RegExp.rightContext来达到相同的效果。 source 一个只读属性,包含
正则表达式
定义的模式,不包侨forward slashes和"g"或"i"标记。 RegExp的属性,只读 从JavaScript 1.2, NES 3.0以上版本开始提供 描述:source是个别
正则表达式
对象的属性,你不能直接改变它的值,但可以通过调用compile 方法来改变它。 test 执行指定字符串的
正则表达式
匹配搜索,返回true或false。 RegExp的方法 从JavaScript 1.2, NES 3.0以上版本开始提供 语法:regexp.test([str]) 参数:regexp,
正则表达式
的名称,可以是变量名或
正则表达式
定义文字串 str,要匹配的字符串,如果省略,将使用RegExp.input的值为作参数 描述:当你需要知道一个字符串能否匹配某个正则表达工,可以使用test方法(与String.search方 法类似); 为了获得更多的信息(但速度将变慢),可以使用exec方法(与String.match方法类似)。 例子:下面的例子显示test是否成功的提示: function testinput(re, str){ if (re.test(str)) midstring = " contains "; else midstring = " does not contain "; document.write (str + midstring + re.source); } toSource 返回一个字符串象征对象的源码 RegExp的方法 从JavaScript 1.3以上版本开始提供 语法:toSource() 参数:没有 描述:toSource方法返回下述的值: 对于内置的RegExp对象,toSource返回下面的字符象征源码不可用: function Boolean(){ [native code] } 在RegExp场合
中
, toSource返回象征源码的字符串,通常这个方法是由JavaScript内部自动调用而不是不代码
中
显式调用。 更多请看Object.toSource toString 返回描绘指定对象的字符串。 RegExp的方法 从JavaScript 1.1, NES 2.0开始提供 ECMA版本ECMA-262 语法:toString() 参数:无 描述:RegExp对象不考虑Object对象的toString方法;它不继承Object.toString,对于RegExp 对 象,toString方法返回一个代表该对象的字符串。 例如:下面的例子显示象征RegExp对象的字符串 myExp = new RegExp("a+b+c"); alert(myExp.toString()) displays "/a+b+c/" 更多请看:Object.toString valueOf 返回一个RegExp对象的原始值 RegExp的方法 从JavaScript 1.1版本开始提供 ECMA版本:ECMA-262 语法:valueOf() 参数:无 描述:RegExp的valueOf方法以字符串形式返回RegExp对象的原始值,这个值与RegExp.toString相等。 该方法通常由JavaScript内部自动调用而不是显式调用 例子: myExp = new RegExp("a+b+c"); alert(myExp.valueOf()) displays "/a+b+c/"
正则表达式
在javascript
中
的几个实例1(转) ! 去除字符串两端空格的处理 如果采用传统的方式,就要可能就要采用下面的方式了 //清除左边空格 function js_ltrim(deststr) { if(deststr==null)return ""; var pos=0; var retStr=new String(deststr); if (retStr.lenght==0) return retStr; while (retStr.substring(pos,pos+1)==" ") pos++; retStr=retStr.substring(pos); return(retStr); } //清除右边空格 function js_rtrim(deststr) { if(deststr==null)return ""; var retStr=new String(deststr); var pos=retStr.length; if (pos==0) return retStr; while (pos && retStr.substring(pos-1,pos)==" " ) pos--; retStr=retStr.substring(0,pos); return(retStr); } //清除左边和右边空格 function js_trim(deststr) { if(deststr==null)return ""; var retStr=new String(deststr); var pos=retStr.length; if (pos==0) return retStr; retStr=js_ltrim(retStr); retStr=js_rtrim(retStr); return retStr; } 采用
正则表达式
,来去除两边的空格,只需以下代码 String.prototype.trim = function() { return this.replace(/(^\s*)|(\s*$)/g, ""); } 一句就搞定了, 可见
正则表达式
为我们节省了相当的编写代码量 ! 移动手机号的校验 如果采用传统的校验方式至少就要完成下面三步的校验, (1). 是否是数字 (2).是否是11位 (3).数字的第三位是否是5,6,7,8,9 如果采用
正则表达式
校验,只需以下代码 function checkMobile1(form) { if (form.mobile.value > "") { var reg=/13[5,6,7,8,9]\d{8}/; if ( form.mobile.value.match(reg)== null) { alert("请输入正确的移动手机号码!"); form.mobile.focus(); return false; } } return true; } 从上面的代码可以看出校验移动手机号只需定义一个var reg=/13[5,6,7,8,9]\d{8}/;模式匹配串就可以完成合法性校验了 ! URL的校验, 条件:必须以http:// 或 https:// 开头, 端口号必须为在1-65535 之间, 以下代码完成了合法性校验 //obj:数据对象 //dispStr :失败提示
内容
显示字符串 function checkUrlValid( obj, dispStr) { if(obj == null) { alert("传入对象为空"); return false; } var str = obj.value; var urlpatern0 = /^https?:\/\/.+$/i; if(!urlpatern0.test(str)) { alert(dispStr+"不合法:必须以'http:\/\/'或'https:\/\/'开头!"); obj.focus(); return false; } var urlpatern2= /^https?:\/\/(([a-zA-Z0-9_-])+(\.)?)*(:\d+)?.+$/i; if(!urlpatern2.test(str)) { alert(dispStr+"端口号必须为数字且应在1-65535之间!"); obj.focus(); return false; } var urlpatern1 =/^https?:\/\/(([a-zA-Z0-9_-])+(\.)?)*(:\d+)?(\/((\.)?(\?)?=?&?[a-zA-Z0-9_-](\?)?)*)*$/i; if(!urlpatern1.test(str)) { alert(dispStr+"不合法,请检查!"); obj.focus(); return false; } var s = "0"; var t =0; var re = new RegExp(":\\d+","ig"); while((arr = re.exec(str))!=null) { s = str.substring(RegExp.index+1,RegExp.lastIndex); if(s.substring(0,1)=="0") { alert(dispStr+"端口号不能以0开头!"); obj.focus(); return false; } t = parseInt(s); if(t65535) { alert(dispStr+"端口号必须为数字且应在1-65535之间!"); obj.focus(); return false; } } return true; } 对url的校验,看上去有很多的代码,这是因为要给予出错提示, 否则只需var urlpatern1 =/^https?:\/\/(([a-zA-Z0-9_-])+(\.)?)*(:\d+)?(\/((\.)?(\?)?=?&?[a-zA-Z0-9_-](\?)?)*)*$/i; 一句就可以校验出url合法性了
正则表达式
在JavaScript应用 时间戳: 2004-11-30 15:29:30 人气: 23 作者: AnyRock 来源:www.mending.cn -------------------------------------------------------------- 去掉字符串头尾多余的空格 /g是全文查找所有匹配 function String.prototype.Trim(){return this.replace(/(^\s*)|(\s*$)/g, "");} function String.prototype.LTrim(){return this.replace(/(^\s*)/g, "");} function String.prototype.RTrim(){return this.replace(/(\s*$)/g, "");} -------------------------------------------------------------- 应用:计算字符串的长度(一个双字节字符长度计2,ASCII字符计1) String.prototype.len=function(){return this.replace([^\x00-\xff]/g,"aa").length;} -------------------------------------------------------------- 应用:javascript
中
没有像vbscript那样的trim函数,我们就可以利用这个表达式来实现,如下: String.prototype.trim = function() { return this.replace(/(^\s*)|(\s*$)/g, ""); } 得用
正则表达式
从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,'))" 用
正则表达式
和javascript对表单进行全面验证 代码: function getStringLength(str){ var endvalue=0; var sourcestr=new String(str); var tempstr; for (var strposition = 0; strposition 255 || tempstr.charCodeAt(0)<0) { endvalue=endvalue+2; } else { endvalue=endvalue+1; } } return(endvalue); } function trim(str){ if(str==null) return ""; if(str.length==0) return ""; var i=0,j=str.length-1,c; for(;i-1;j--){ c=str.charAt(j); if(c!=' ') break; } if(i>j) return ""; return str.substring(i,j+1); } function validateDate(date,format,alt){ var time=trim(date.value); if(time=="") return; var reg=format; var reg=reg.replace(/yyyy/,"[0-9]{4}"); var reg=reg.replace(/yy/,"[0-9]{2}"); var reg=reg.replace(/MM/,"((0[1-9])|1[0-2])"); var reg=reg.replace(/M/,"(([1-9])|1[0-2])"); var reg=reg.replace(/dd/,"((0[1-9])|([1-2][0-9])|30|31)"); var reg=reg.replace(/d/,"([1-9]|[1-2][0-9]|30|31))"); var reg=reg.replace(/HH/,"(([0-1][0-9])|20|21|22|23)"); var reg=reg.replace(/H/,"([0-9]|1[0-9]|20|21|22|23)"); var reg=reg.replace(/mm/,"([0-5][0-9])"); var reg=reg.replace(/m/,"([0-9]|([1-5][0-9]))"); var reg=reg.replace(/ss/,"([0-5][0-9])"); var reg=reg.replace(/s/,"([0-9]|([1-5][0-9]))"); reg=new RegExp("^"+reg+"$"); if(reg.test(time)==false){//验证格式是否合法 alert(alt); date.focus(); return false; } return true; } function validateDateGroup(year,month,day,alt){ var array=new Array(31,28,31,30,31,30,31,31,30,31,30,31); var y=parseInt(year.value); var m=parseInt(month.value); var d=parseInt(day.value); var maxday=array[m-1]; if(m==2){ if((y%4==0&&y0!=0)||y%400==0){ maxday=29; } } if(d>maxday){ alert(alt); return false; } return true; } function validateCheckbox(obj,alt){ var rs=false; if(obj!=null){ if(obj.length==null){ return obj.checked; } for(i=0;i
中的所有元素放入数组 for(var i = 0; i field[i].maxLength){ alert(lengthInfo); field[i].focus(); return false; } var validatorType=field[i].validatorType; if(validatorType!=null){//其它javascript var rs=true; if(validatorType=="javascript"){ eval("rs="+field[i].functionName+"()"); if(rs==false){ return false; } else{ continue; } } else if(validatorType=="disable"){//提交表单前disable的按钮 disableList.length++; disableList[disableList.length-1]=field[i]; continue; } else if(validatorType=="Date"){ rs=validateDate(theForm.elements(field[i].fieldName),field[i].format,field[i].errorInfo); } else if(validatorType=="DateGroup"){ rs=validateDateGroup(theForm.elements(field[i].year),theForm.elements(field[i].month),theForm.elements(field[i].day),field[i].errorInfo); } else if(validatorType=="Checkbox"){ rs=validateCheckbox(theForm.elements(field[i].fieldName),field[i].errorInfo); } else if(validatorType=="Radio"){ rs=validateRadio(theForm.elements(field[i].fieldName),field[i].errorInfo); } else if(validatorType=="Select"){ rs=validateSelect(theForm.elements(field[i].fieldName),field[i].errorInfo); } else if(validatorType=="Email"){ rs=validateEmail(theForm.elements(field[i].fieldName),field[i].errorInfo); } else{ alert("验证类型不被支持, fieldName: "+field[i].name); return false; } if(rs==false){ return false; } } else{//一般验证 if(empty==false){ var v = field[i].validator; // 获取其validator属性 if(!v) continue; // 如果该属性不存在,忽略当前元素 var reg=new RegExp(v); if(reg.test(field[i].value)==false){ alert(field[i].errorInfo); field[i].focus(); return false; } } } } for(i=0;i
ASP
.NET使用
正则表达式
屏蔽垃圾信息
Regex 类 表示不可变的
正则表达式
。 命名空间:System.Text.RegularExpressions Regex 类包含若干 static(在 Visual Basic
中
为 Shared)方法,使您无需显式创建 Regex 对象即可使用正 则表达式。在 .NET Framework 2.0 版
中
,将缓存通过调用静态方法而编译的
正则表达式
,而不会缓存通过调 用实例方法而编译的
正则表达式
。默认情况下,
正则表达式
引擎将缓存 15 个最近使用的静态
正则表达式
。因 此,在过度地依赖一组固定的
正则表达式
来
提取
、修改或验证
文本
的应用程序
中
,您可能更愿意调用这些静态 方法,而不是其相应的实例方法
ASP
28,390
社区成员
357,068
社区内容
发帖
与我相关
我的任务
ASP
ASP即Active Server Pages,是Microsoft公司开发的服务器端脚本环境。
复制链接
扫一扫
分享
社区描述
ASP即Active Server Pages,是Microsoft公司开发的服务器端脚本环境。
社区管理员
加入社区
获取链接或二维码
近7日
近30日
至今
加载中
查看更多榜单
社区公告
暂无公告
试试用AI创作助手写篇文章吧
+ 用AI写文章