正则表达式使用,js正则表达式如何应用
正则表达式使用,js正则表达式如何应用详细介绍
本文目录一览： 正则表达式的使用有什么技巧吗？
正则表达式（regular expression)是根据字符串集合内每个字符串共享的共同特性来描述字符串集合的一种途径。
正则表达式是繁琐的，但它是强大的，学会之后的应用会让你除了提高效率外，会给你带来绝对的成就感。只要认真阅读本教程，加上应用的时候进行一定的参考，掌握正则表达式不是问题。
许多程序设计语言都支持利用正则表达式进行字符串操作。
Java.util.regex主要包含以下三类：
①pattern类：＜font color=red>pattern对象是一个正则表达式的编译表示。Pattern类没有公共构造方法。要创建一个Pattern对象，你必须首先调用其公共静态编译方法，它返回一个Pattern对象。该方法接受一个正则表达式作为它的第一个参数。
②Matcher类：Matcher对象是对输入字符串进行解释和匹配操作的引擎。与Pattern类一样，Matcher也没有公共构造方法。你需要调用Pattern对象的matcher方法来获得一个Matcher对象。
③PatternSyntaxException：PatternSyntaxException是一个非强制异常类，它表示一个正则表达式模式中的语法错误。
正则表达式主要应用在哪些地方……
匹配字符串，一般用来做规则验证。比如你想验证人输入的邮箱格式是否正确就写个正则，跟用户输入匹配下。
正则,首先可以用来做验证,这个大家都知道的.像表达验证之类的.其实后台也会用到验证.然后就是匹配 替换 主要用在String吧
给你一个地址，你上去看看
http://www.cnblogs.com/natianyihou/archive/2010/03/14/Yang_Wei.html
总体来说，正则表达式有三类主要应用：
（1）测试字符串的某个模式。例如，可以输入一个字符串进行测试看该字符串中是否存在一个电话号码模式或者一个信用卡模式，这成为数据的有效性检验。
（2）替换文本。可以再文档中使用一个正则表达式来表示特定文字，然后可以将其全部删除或者替换成别的文字。
（3）根据模式匹配从字符串中提取一个子字符串。可以用来在文本或者输入字段中查找特定的文字。
一个正则表达式就是由普通字符（例如字符 a 到 z）以及特殊字符（称为元字符）组成的文字模式。该模式描述在查找文字主体时待匹配的一个或多个字符串。正则表达式作为一个模板，将某个字符模式与所搜索的字符串进行匹配。
js中的正则表达式如何使用(附代码)
这次给大家带来js中的正则表达式如何使用(附代码)，使用js中正则表达式注意事项有哪些，下面就是实战案例，一起来看一下。阅读目录正则表达式的创建正则表达式中的特殊字符\ (反斜杠)^$*, +, .(小数点)? (问号)(x)(?:x)x(?=y), x(?!y), x|y{n}, {n,m}:[xyz], [^xyz]其他正则表达式标志正则表达式使用很多时候多会被正则表达式搞的晕头转向，最近抽出时间对正则表达式进行了系统的学习，整理如下：正则表达式的创建两种方法，一种是直接写，由包含在斜杠之间的模式组成；另一种是调用RegExp对象的构造函数。两种方法的创建代码如下：// 直接创建const regex1 = /ab+c/;const regex2 = /^[a-zA-Z]+[0-9]*\W?_$/gi;// 调用构造函数const regex3 = new RegExp('ab+c');const regex4 = new RegExp(/^[a-zA-Z]+[0-9]*\W?_$/, "gi");const regex5 = new RegExp('^[a-zA-Z]+[0-9]*\W?_$', 'gi');可以看出，调用RegExp构造函数创建正则表达式时，第一个参数可以是字符串，也可以是直接创建的正则表达式。需要注意的是：RegExp实例继承的toLocaleString()和toString)()方法都会返回正则表达式的字面量，与创建正则表达式的方式无关例如：const ncname = '[a-zA-Z_][\\w\\-\\.]*';const qnameCapture = '((?:' + ncname + '\\:)?' + ncname + ')';const startTagOpen = new RegExp('^<' + qnameCapture);startTagOpen.toString(); // '/^<((?:[a-zA-Z_][\w\-\.]*\:)?[a-zA-Z_][\w\-\.]*)/'正则表达式中的特殊字符\ (反斜杠)1.在非特殊字符前加反斜杠表示下一个字符是特殊的；2.将其后的特殊字符转译为字面量；注意：在使用RegExp构造函数时要将\转译，因为\在字符串里也是转译字符^ 1.匹配输入的开始；2.在[]中的第一位时表示反向字符集；例子：/^A/.exec('an A') // null/^A/.exec('An E') // ["A", index: 0, input: "An E"]$ 匹配输入的结束/t$/.exec('eater') // null/t$/.exec('eat') // ["t", index: 2, input: "eat"]*, +, .(小数点)*：匹配前一个表达式0次或多次。等价于 {0,}；+：匹配前面一个表达式1次或者多次。等价于 {1,}；.：匹配除换行符之外的任何单个字符；? (问号)1.匹配前面一个表达式0次或者1次。等价于 {0,1}；2.如果紧跟在任何量词 * + ? {} 的后面，将会使量词变为非贪婪的（匹配尽量少的字符），和缺省使用的贪婪模式正好相反；3.运用于先行断言例子：/\d+/.exec('123abc') // ["123", index: 0, input: "123abc"]/\d+?/.exec('123abc') // ["1", index: 0, input: "123abc"](x)匹配 'x' 并且记住匹配项，括号表示捕获括号；例子：/(foo) (bar) \1 \2/.test('bar foo bar foo'); // false/(bar) (foo) \1 \2/.test('bar foo bar foo'); // true/(bar) (foo) \1 \2/.test('bar foo'); // false/(bar) (foo) \1 \2/.test('bar foo foo bar'); // false/(bar) (foo) \2 \1/.test('bar foo foo bar'); // true'bar foo bar foo'.replace( /(bar) (foo)/, '$2 $1' ); // "foo bar bar foo"模式 /(foo) (bar) \1 \2/ 中的 '(foo)' 和 '(bar)' 匹配并记住字符串 "foo bar foo bar" 中前两个单词。模式中的 \1 和 \2 匹配字符串的后两个单词。注意：\1、\2、\n 是用在正则表达式的匹配环节，在正则表达式的替换环节，则要使用像 $1、$2、$n 这样的语法。例如，'bar foo'.replace( /(...) (...)/, '$2 $1' )。(?:x) 匹配 'x' 但是不记住匹配项，这种叫作非捕获括号；例子：'foo'.match(/foo{1,2}/) // ["foo", index: 0, input: "foo"]'foo'.match(/(?:foo){1,2}/) // ["foo", index: 0, input: "foo"]'foofoo'.match(/(?:foo){1,2}/) // ["foofoo", index: 0, input: "foofoo"]'foofoo'.match(/foo{1,2}/) // ["foo", index: 0, input: "foofoo"]使用场景：示例表达式 /(?:foo){1,2}/。如果表达式是 /foo{1,2}/，{1,2}将只对 ‘foo' 的最后一个字符 'o‘ 生效。如果使用非捕获括号，则{1,2}会匹配整个 ‘foo' 单词。x(?=y), x(?!y), x|y x(?=y)：匹配'x'仅仅当'x'后面跟着'y'；x(?!y)：匹配'x'仅仅当'x'后面不跟着'y'；x|y: 匹配x或y这两种匹配的结果都不包含y例子：'JackSprat'.match(/Jack(?=Sprat)/) // ["Jack", index: 0, input: "JackSprat"]'JackWprat'.match(/Jack(?=Sprat)/) // null'JackWprat'.match(/Jack(?=Sprat|Wprat)/) // ["Jack", index: 0, input: "JackWprat"]/\d+(?!\.)/.exec("3.141") // ["141", index: 2, input: "3.141"]{n}, {n,m}:{n}：匹配了前面一个字符刚好发生了n次；{n,m}：匹配前面的字符至少n次，最多m次。如果 n 或者 m 的值是0， 这个值被忽略；例子： /a{2}/.exec('candy') // null /a{2}/.exec('caandy') // ["aa", index: 1, input: "caandy"] /a{2}/.exec('caaandy') // ["aa", index: 1, input: "caaandy"] /a{1,3}/.exec('candy') // ["a", index: 1, input: "candy"] /a{1,3}/.exec('caandy') // ["aa", index: 1, input: "caandy"] /a{1,3}/.exec('caaandy') // ["aaa", index: 1, input: "caaandy"] /a{1,3}/.exec('caaaandy') // ["aaa", index: 1, input: "caaaandy"][xyz], [^xyz] [xyz]：一个字符集合。匹配方括号的中任意字符;[^xyz]：一个反向字符集。匹配任何没有包含在方括号中的字符；这两种匹配都可以使用破折号（-）来指定一个字符范围，特殊符号在字符集中没有了特殊意义。例：function escapeRegExp(string){ return string.replace(/([.*+?^=!:${}()|[\]\/\\])/g, "\\$&"); //$&表示整个被匹配的字符串}例子中的.*+?^=!:${}()都表示字面量，并没有特殊意义。其他\b：匹配一个词的边界。一个匹配的词的边界并不包含在匹配的内容中。换句话说，一个匹配的词的边界的内容的长度是0；\B： 匹配一个非单词边界；例子： /\bm/.exec('moon')// ["m", index: 0, input: "moon"] /\bm/.exec('san moon')// ["m", index: 4, input: "san moon"] /oo\b/.exec('moon')// null /\B../.exec('noonday') // ["oo", index: 1, input: "noonday"] /y\B../.exec('possibly yesterday') // /y\B../.exec('possibly yesterday')\d：匹配一个数字，等价于[0-9]；\D：匹配一个非数字字符，等价于[^0-9]；\f：匹配一个换页符 (U+000C)；\n：匹配一个换行符 (U+000A)；\r：匹配一个回车符 (U+000D)；\s：匹配一个空白字符，包括空格、制表符、换页符和换行符，等价于[ \f\n\r\t\v\u00a0\u1680\u180e\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]；\S：匹配一个非空白字符，等价于[^ \f\n\r\t\v\u00a0\u1680\u180e\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]；\w：匹配一个单字字符（字母、数字或者下划线），等价于[A-Za-z0-9_]；\W：匹配一个非单字字符，等价于[^A-Za-z0-9_]；正则表达式标志g：全局搜索；i：不区分大小写；m：多行搜索；正则表达式使用RegExp有exec()和test()方法；exec匹配的结果为：匹配结果、捕获结果，index和input。test匹配的结果为true或false，效率比exec要高。String有match()，replace()，search()，split()方法；match匹配的结果同RegExp的exec，replace根据正则表达式替换，search查找所以位置，split根据正则表达式分割字符串。其中，当replace有function时，参数说明如下：* 匹配项* 记忆项（括号里面的项）* ...* 匹配的index* input输入项相信看了本文案例你已经掌握了方法，更多精彩请关注Gxl网其它相关文章！推荐阅读：在JS里编写简单的正则方式正则与Linux三大文本处理工具的使用详解
正则表达式语法和使用（全宇宙最全）
1.正则表达式基本语法
-->
function regx(r,s)
{
if (r == null || r == ""){
return false;
}
var patrn= new RegExp(r);
if (patrn.exec(s))
return true
return false
}
-->
规则表达式?：? (填写/ /之间的表达式)
校验字符串?：?
4.正则表达式应用
"^\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地址
^([0-9A-F]{2})(-[0-9A-F]{2}){5}$?? //MAC地址的正则表达式
^[-+]?\d+(\.\d+)?$? //值类型正则表达式
5.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
}
/*********************************************************************************
* FUNCTION: isBetween
* PARAMETERS: val AS any value
* lo AS Lower limit to check
* hi AS Higher limit to check
* CALLS: NOTHING
* RETURNS: TRUE if val is between lo and hi both inclusive, otherwise false.
**********************************************************************************/
function isBetween (val, lo, hi) {
if ((val < lo) || (val > hi)) { return(false); }
else { return(true); }
}
/*********************************************************************************
* FUNCTION: isDate checks a valid date
* PARAMETERS: theStr AS String
* CALLS: isBetween, isInt
* RETURNS: TRUE if theStr is a valid date otherwise false.
**********************************************************************************/
function isDate (theStr) {
var the1st = theStr.indexOf('-');
var the2nd = theStr.lastIndexOf('-');
if (the1st == the2nd) { return(false); }
else {
var y = theStr.substring(0,the1st);
var m = theStr.substring(the1st+1,the2nd);
var d = theStr.substring(the2nd+1,theStr.length);
var maxDays = 31;
if (isInt(m)==false || isInt(d)==false || isInt(y)==false) {
return(false); }
else if (y.length < 4) { return(false); }
else if (!isBetween (m, 1, 12)) { return(false); }
else if (m==4 || m==6 || m==9 || m==11) maxDays = 30;
else if (m==2) {
if (y % 4 > 0) maxDays = 28;
else if (y % 100 == 0 && y % 400 > 0) maxDays = 28;
else maxDays = 29;
}
if (isBetween(d, 1, maxDays) == false) { return(false); }
else { return(true); }
}
}
/*********************************************************************************
* FUNCTION: isEuDate checks a valid date in British format
* PARAMETERS: theStr AS String
* CALLS: isBetween, isInt
* RETURNS: TRUE if theStr is a valid date otherwise false.
**********************************************************************************/
function isEuDate (theStr) {
if (isBetween(theStr.length, 8, 10) == false) { return(false); }
else {
var the1st = theStr.indexOf('/');
var the2nd = theStr.lastIndexOf('/');
if (the1st == the2nd) { return(false); }
else {
var m = theStr.substring(the1st+1,the2nd);
var d = theStr.substring(0,the1st);
var y = theStr.substring(the2nd+1,theStr.length);
var maxDays = 31;
if (isInt(m)==false || isInt(d)==false || isInt(y)==false) {
return(false); }
else if (y.length < 4) { return(false); }
else if (isBetween (m, 1, 12) == false) { return(false); }
else if (m==4 || m==6 || m==9 || m==11) maxDays = 30;
else if (m==2) {
if (y % 4 > 0) maxDays = 28;
else if (y % 100 == 0 && y % 400 > 0) maxDays = 28;
else maxDays = 29;
}
if (isBetween(d, 1, maxDays) == false) { return(false); }
else { return(true); }
}
}
}
/********************************************************************************
* FUNCTION: Compare Date! Which is the latest!
* PARAMETERS: lessDate,moreDate AS String
* CALLS: isDate,isBetween
* RETURNS: TRUE if lessDate
*********************************************************************************/
function isComdate (lessDate , moreDate)
{
if (!isDate(lessDate)) { return(false);}
if (!isDate(moreDate)) { return(false);}
var less1st = lessDate.indexOf('-');
var less2nd = lessDate.lastIndexOf('-');
var more1st = moreDate.indexOf('-');
var more2nd = moreDate.lastIndexOf('-');
var lessy = lessDate.substring(0,less1st);
var lessm = lessDate.substring(less1st+1,less2nd);
var lessd = lessDate.substring(less2nd+1,lessDate.length);
var morey = moreDate.substring(0,more1st);
var morem = moreDate.substring(more1st+1,more2nd);
var mored = moreDate.substring(more2nd+1,moreDate.length);
var Date1 = new Date(lessy,lessm,lessd);
var Date2 = new Date(morey,morem,mored);
if (Date1>Date2) { return(false);}
return(true);
}
/*********************************************************************************
* FUNCTION isEmpty checks if the parameter is empty or null
* PARAMETER str AS String
**********************************************************************************/
function isEmpty (str) {
if ((str==null)||(str.length==0)) return true;
else return(false);
}
/*********************************************************************************
* FUNCTION: isInt
* PARAMETER: theStr AS String
* RETURNS: TRUE if the passed parameter is an integer, otherwise FALSE
* CALLS: isDigit
**********************************************************************************/
function isInt (theStr) {
var flag = true;
if (isEmpty(theStr)) { flag=false; }
else
{ for (var i=0; i
if (isDigit(theStr.substring(i,i+1)) == false) {
flag = false; break;
}
}
}
return(flag);
}
/*********************************************************************************
* FUNCTION: isReal
* PARAMETER: heStr AS String
decLen AS Integer (how many digits after period)
* RETURNS: TRUE if theStr is a float, otherwise FALSE
* CALLS: isInt
**********************************************************************************/
function isReal (theStr, decLen) {
var dot1st = theStr.indexOf('.');
var dot2nd = theStr.lastIndexOf('.');
var OK = true;
if (isEmpty(theStr)) return false;
if (dot1st == -1) {
if (!isInt(theStr)) return(false);
else return(true);
}
else if (dot1st != dot2nd) return (false);
else if (dot1st==0) return (false);
else {
var intPart = theStr.substring(0, dot1st);
var decPart = theStr.substring(dot2nd+1);
if (decPart.length > decLen) return(false);
else if (!isInt(intPart) || !isInt(decPart)) return (false);
else if (isEmpty(decPart)) return (false);
else return(true);
}
}
/*********************************************************************************
* FUNCTION: isEmail
* PARAMETER: String (Email Address)
* RETURNS: TRUE if the String is a valid Email address
* FALSE if the passed string is not a valid Email Address
* EMAIL FORMAT: AnyName@EmailServer e.g; webmaster@hotmail.com
* @ sign can appear only once in the email address.
*********************************************************************************/
function isEmail (theStr) {
var atIndex = theStr.indexOf( '@' );
var dotIndex = theStr.indexOf('.', atIndex);
var flag = true;
theSub = theStr.substring(0, dotIndex+1)
if ((atIndex < 1)||(atIndex != theStr.lastIndexOf( '@'))||(dotIndex < atIndex + 2)||(theStr.length <= theSub.length))
{ return(false); }
else { return(true); }
}
/*********************************************************************************
* FUNCTION: newWindow
* PARAMETERS: doc -> Document to open in the new window
hite -> Height of the new window
wide -> Width of the new window
bars -> 1-Scroll bars = YES 0-Scroll Bars = NO
resize -> 1-Resizable = YES 0-Resizable = NO
* CALLS: NONE
* RETURNS: New window instance
**********************************************************************************/
function newWindow (doc, hite, wide, bars, resize) {
var winNew="_blank";
var opt="toolbar=0,location=0,directories=0,status=0,menubar=0,";
opt+=("scrollbars="+bars+",");
opt+=("resizable="+resize+",");
opt+=("width="+wide+",");
opt+=("height="+hite);
winHandle=window.open(doc,winNew,opt);
return;
}
/*********************************************************************************
* FUNCTION: DecimalFormat
* PARAMETERS: paramValue -> Field value
* CALLS: NONE
* RETURNS: Formated string
**********************************************************************************/
function DecimalFormat (paramValue) {
var intPart = parseInt(paramValue);
var decPart =parseFloat(paramValue) - intPart;
str = "";
if ((decPart == 0) || (decPart == null)) str += (intPart + ".00");
else str += (intPart + decPart);
return (str);
}
"^\\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
python正则表达式使用实例有哪些？
具体如下：
1、测试正则表达式是否匹配字符串的全部或部分regex=ur"" #正则表达式：if re.search(regex, subject): do_something()else: do_anotherthing() 。
2、测试正则表达式是否匹配整个字符串 regex=ur"/Z" #正则表达式末尾以/Z结束：if re.match(regex, subject): do_something()else: do_anotherthing() 。
3、创建一个匹配对象，然后通过该对象获得匹配细节(Create an object with details about how the regex matches (part of) a string) regex=ur"" #正则表达式：
match = re.search(regex, subject)if match: # match start: match.start() # match end (exclusive): atch.end() # matched text: match.group() do_something()else: do_anotherthing()。
4、获取正则表达式所匹配的子串(Get the part of a string matched by the regex) regex=ur"" #正则表达式：match = re.search(regex, subject)if match: result = match.group()else: result ="" 。
5、获取捕获组所匹配的子串(Get the part of a string matched by a capturing group) regex=ur"" #正则表达式：match = re.search(regex, subject)if match: result = match.group(1)else: result ="" 。
正则表达式“或“的使用
正则表达式，又称规则表达式。（英语：Regular Expression，在代码中常简写为regex、regexp或RE），计算机科学的一个概念。正则表达式通常被用来检索、替换那些符合某个模式(规则)的文本。
许多程序设计语言都支持利用正则表达式进行字符串操作。例如，在Perl中就内建了一个功能强大的正则表达式引擎。
正则表达式这个概念最初是由Unix中的工具软件（例如sed和grep）普及开的。正则表达式通常缩写成“regex”，单数有regexp、regex，复数有regexps、regexes、regexen。
扩展资料
正则表达式应用——实例应用
1.验证用户名和密码：（"^[a-zA-Z]\w{5,15}$"）正确格式："[A-Z][a-z]_[0-9]"组成,并且第一个字必须为字母6~16位；
2.验证电话号码：（"^(\d{3,4}-)\d{7,8}$"）正确格式：xxx/xxxx-xxxxxxx/xxxxxxxx；
3.验证手机号码："^1[3|4|5|7|8][0-9]{9}$"；
4.验证身份证号（15位）："\d{14}[[0-9],0-9xX]"，（18位）："\d{17}(\d|X|x)"；
5.验证Email地址：("^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$")；
6.只能输入由数字和26个英文字母组成的字符串：("^[A-Za-z0-9]+$")；
7.整数或者小数：^[0-9]+([.][0-9]+){0,1}$
8.只能输入数字："^[0-9]*$"。
9.只能输入n位的数字："^\d{n}$"。
参考资料：
百度百科-正则表达式
正则表达式（regular expression）描述了一种字符串匹配的模式，可以用来检查一个串是否含有某种子串、将匹配的子串做替换或者从某个串中取出符合某个条件的子串等。
正则表达式是一种可以用于模式匹配和替换的规范,一个正则表达式就是由普通的字符(例如字符a到z)以及特殊字符(元字符)组成的文字模式，它用以描述在查找文字主体时待匹配的一个或多个字符串。
正则表达式作为一个模板，将某个字符模式与所搜索的字符串进行匹配。每一门计算机编程语言，都支持正则表达式。正则表达式能够进行数据隐藏，数据采集，数据过滤和数据验证。
扩展资料：
使用正则表达式创建正则对象方法如下：
1.字面量写法-以斜杠表示开始和结束； var regex = /xyz/。
2.内置构造函数生成-通过实例化得到对象；var regex = new RegExp('xyz')。
正则表达式里面字符串含义：
test(str) ：判断字符串中是否具有指定模式的子串，返回结果是一个布尔类型的值;exec(str) ：返回字符串中指定模式的子串，一次只能获取一个与之匹配的结果。
search(reg) ：与indexOf非常类似，返回指定模式的子串在字符串首次出现的位置。
match(reg)： 以数组的形式返回指定模式的字符串，可以返回所有匹配的结果。
replace(reg，'替换后的字符') ：把指定模式的子串进行替换操作。
split(reg) ：以指定模式分割字符串，返回结果为数组。
参考资料来源：百度百科—正则表达式
正则表达式（英文：Regular Expression），在计算机科学中，是指一个用来描述或者匹配一系列符合某个句法规则的字符串的单个字符串。在很多文本编辑器或其他工具里，正则表达式通常被用来检索和/或替换那些符合某个模式的文本内容。许多程序设计语言都支持利用正则表达式进行字符串操作。例如，在Perl中就内建了一个功能强大的正则表达式引擎。正则表达式这个概念最初是由Unix中的工具软件（例如sed和grep）普及开的。“正则表达式”通常缩写成“regex”，单数有regexp、regex，复数有regexps、regexes、regexen。
基本概念 一个正则表达式通常被称为一个模式 (pattern)，为用来描述或者匹配一系列符合某个句法规则的字符串。例如：Handel、H??ndel 和 Haendel 这三个字符串，都可以由 "H(a|??|ae)ndel" 这个模式来描述。大部分正则表达式的形式都有如下的结构：替换 | 竖直分隔符代表替换。例如"gray|grey"可以匹配grey或gray。数量限定 某个字符后的数量限定符用来限定前面这个字符允许出现的个数。最常见的数量限定符包括“+”，“?”和“*”（不加数量限定则代表出现一次且仅出现一次）：+ 加号代表前面的字符必须至少出现一次。(1次，或多次)。例如，"goo+gle"可以匹配google，gooogle，goooogle等;? 问号代表前面的字符最多只可以出现一次。(0次，或1次)。例如，"colou?r"可以匹配colour或者color;* 星号代表前面的字符可以不出现，也可以出现一次或者多次。(0次，或1次，或多次)。例如，"0*42"可以匹配42，042，0042，00042等。匹配 圆括号可以用来定义操作符的范围和优先度。例如，"gr(a|e)y"等价于"gray|grey"，"(grand)?father"匹配father和grandfather。上述这些构造子都可以自由组合，因此，"H(ae?|??)ndel"和"H(a|ae|??)ndel"是相同的。精确的语法可能因不同的工具或程序而异。历史 最初的正则表达式出现于理论计算机科学的自动控制理论和形式语言理论中。在这些领域中有对计算（自动控制）的模型和对形式语言描述与分类的研究。1940年代，Warren McCulloch与Walter Pitts将神经系统中的神经元描述成小而简单的自动控制元。在1950年代，数学家斯蒂芬·科尔·克莱尼利用称之为正则集合的数学符号来描述此模型。肯·汤普逊将此符号系统引入编辑器QED，然后是Unix上的编辑器ed，并最终引入grep。自此，正则表达式被广泛地使用于各种Unix或者类似Unix的工具，例如Perl。Perl正则表达式源自于Henry Spencer写的regex，它已经演化成了pcre（Perl兼容正则表达式Perl Compatible Regular Expressions），一个由Philip Hazel开发的，为很多现代工具所使用的库。各计算机语言之间的正则表达式的整合目前开展的很差。未来的Perl6的子项目Apocalypse的设计中已考虑到了这点。形式语言理论 正则表达式可以用形式语言理论的方式来表达。正则表达式由常量和算子组成，它们分别指示字符串的集合和在这些集合上的运算。给定有限字母表 Σ 定义了下列常量:(“空集”) ?? 指示集合 ?? (“空串”) ε 指示集合 {ε} (“文字字符”) 在 Σ 中的 a 指示集合 {a} 定义了下列运算:(“串接”) RS 指示集合 { αβ | α ∈ R ∧ β ∈ S }。例如 {"ab"|"c"}{"d"|"ef"} = {"abd", "abef", "cd", "cef"}。 (“选择”) R|S 指示 R 和 S 的并集。 (“Kleene星号”) R* 指示包含 ε 并且闭合在字符串串接下的 R 的最小超集。这是可以通过 R 中的零或多个字符串的串接得到所有字符串的集合。例如，{"ab", "c"}* = {ε, "ab", "c", "abab", "abc", "cab", "cc", "ababab", ... }。 上述常量和算子形成了克莱尼代数。很多课本使用对选择使用符号 ∪, + 或 ∨ 替代竖杠。为了避免括号，假定 Kleene 星号有最高优先级，接着是串接，接着是并集。如果没有歧义则可以省略括号。例如，(ab)c 可以写为 abc 而 a|(b(c*)) 可以写为 a|bc*。例子:a|b* 指示 {ε, a, b, bb, bbb, ...}。 (a|b)* 指示由包括空串、任意数目个 a 和 b 字符组成的所有字符串的集合。 ab*(c|ε) 指示开始于一个 a 接着零或多个 b 和最终可选的一个 c 的字符串的集合。 正则表达式的形式定义故意非常精简，避免定义多余的量词 ? 和 +，它们可以被表达为: a+ = aa* 和 a? = (a|ε)。有时增加补算子 ~ ；~R 指示在 Σ* 上的不在 R 中的所有字符串的集合。补算子是多余的，因为它使用其他算子来表达(尽管计算这种表示的过程是复杂的，而结果可能指数性的增大)。这种意义上的正则表达式可以表达正则语言，精确的是可被有限状态自动机接受的语言类。但是在简洁性上有重要区别。某类正则语言只能用大小指数增长的自动机来描述，而要求的正则表达式的长度只线性的增长。正则表达式对应于乔姆斯基层级的类型-3文法。在另一方面，在正则表达式和不导致这种大小上的爆炸的非确定有限状态自动机(NFA)之间有简单的映射；为此 NFA 经常被用作正则表达式的替代表示。我们还要在这种形式化中研究表达力。如下面例子所展示的，不同的正则表达式可以表达同样的语言: 这种形式化中存在着冗余。有可能对两个给定正则表达式写一个算法来判定它们所描述的语言是否本质上相等，简约每个表达式到极小确定有限自动机，确定它们是否同构（等价）。这种冗余可以消减到什么程度? 我们可以找到仍有完全表达力的正则表达式的有趣的子集吗? Kleene 星号和并集明显是需要的，但是我们或许可以限制它们的使用。这提出了一个令人惊奇的困难问题。因为正则表达式如此简单，没有办法在语法上把它重写成某种规 范形式。过去公理化的缺乏导致了星号高度问题。最近 Dexter Kozen 用克莱尼代数公理化了正则表达式。很多现实世界的“正则表达式”引擎实现了不能用正则表达式代数表达的特征。表达式全集 正则表达式有多种不同的风格。下表是在PCRE中元字符及其在正则表达式上下文中的行为的一个完整列表：字符描述\将下一个字符标记为一个特殊字符、或一个原义字符、或一个向后引用、或一个八进制转义符。例如，“n”匹配字符“n”。“\n”匹配一个换行符。序列“\\”匹配“\”而“\(”则匹配“(”。^匹配输入字符串的开始位置。如果设置了RegExp对象的Multiline属性，^也匹配“\n”或“\r”之后的位置。$匹配输入字符串的结束位置。如果设置了RegExp对象的Multiline属性，$也匹配“\n”或“\r”之前的位置。*匹配前面的子表达式零次或多次。例如，zo*能匹配“z”以及“zoo”。*等价于{0,}。+匹配前面的子表达式一次或多次。例如，“zo+”能匹配“zo”以及“zoo”，但不能匹配“z”。+等价于{1,}。?匹配前面的子表达式零次或一次。例如，“do(es)?”可以匹配“do”或“does”中的“do”。?等价于{0,1}。{n}n是一个非负整数。匹配确定的n次。例如，“o{2}”不能匹配“Bob”中的“o”，但是能匹配“food”中的两个o。{n,}n是一个非负整数。至少匹配n次。例如，“o{2,}”不能匹配“Bob”中的“o”，但能匹配“foooood”中的所有o。“o{1,}”等价于“o+”。“o{0,}”则等价于“o*”。{n,m}m和n均为非负整数，其中n<=m。最少匹配n次且最多匹配m次。例如，“o{1,3}”将匹配“fooooood”中的前三个o。“o{0,1}”等价于“o?”。请注意在逗号和两个数之间不能有空格。?当该字符紧跟在任何一个其他限制符(*,+,?,{n},{n,},{n,m})后面时，匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如，对于字符串“oooo”，“o+?”将匹配单个“o”，而“o+”将匹配所有“o”。.匹配除“\n”之外的任何单个字符。要匹配包括“\n”在内的任何字符，请使用像“[.\n]”的模式。(pattern)匹配pattern并获取这一匹配。所获取的匹配可以从产生的Matches集合得到，在VBScript中使用SubMatches集合，在JScript中则使用$0…$9属性。要匹配圆括号字符，请使用“\(”或“\)”。(?:pattern)匹配pattern但不获取匹配结果，也就是说这是一个非获取匹配，不进行存储供以后使用。这在使用“或”字符(|)来组合一个模式的各个部分是很有用。例如，“industr(?:y|ies)就是一个比”industry|industries'更简略的表达式。(?=pattern)正向预查，在任何匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如， “Windows(?=95|98|NT|2000)”能匹配“Windows2000”中的“Windows”，但不能匹配“Windows3.1”中 的“Windows”。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。(?!pattern)负向预查，在任何不匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如 “Windows(?!95|98|NT|2000)”能匹配“Windows3.1”中的“Windows”，但不能匹配“Windows2000”中 的“Windows”。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始x|y匹配x或y。例如，“z|food”能匹配“z”或“food”。“(z|f)ood”则匹配“zood”或“food”。[xyz]字符集合。匹配所包含的任意一个字符。例如，“[abc]”可以匹配“plain”中的“a”。[^xyz]负值字符集合。匹配未包含的任意字符。例如，“[^abc]”可以匹配“plain”中的“p”。[a-z]字符范围。匹配指定范围内的任意字符。例如，“[a-z]”可以匹配“a”到“z”范围内的任意小写字母字符。[^a-z]负值字符范围。匹配任何不在指定范围内的任意字符。例如，“[^a-z]”可以匹配任何不在“a”到“z”范围内的任意字符。\b匹配一个单词边界，也就是指单词和空格间的位置。例如，“er\b”可以匹配“never”中的“er”，但不能匹配“verb”中的“er”。\B匹配非单词边界。“er\B”能匹配“verb”中的“er”，但不能匹配“never”中的“er”。\cx匹配由x指明的控制字符。例如，\cM匹配一个Control-M或回车符。x的值必须为A-Z或a-z之一。否则，将c视为一个原义的“c”字符。\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为十六进制转义值。十六进制转义值必须为确定的两个数字长。例如，“\x41”匹配“A”。“\x041”则等价于“\x04”&“1”。正则表达式中可以使用ASCII编码。.\num匹配num，其中num是一个正整数。对所获取的匹配的引用。例如，“(.)\1”匹配两个连续的相同字符。\n标识一个八进制转义值或一个向后引用。如果\n之前至少n个获取的子表达式，则n为向后引用。否则，如果n为八进制数字(0-7)，则n为一个八进制转义值。\nm标识一个八进制转义值或一个向后引用。如果\nm之前至少有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字符。例如，\u00A9匹配版权符号（??）。范例 以下以PHP的语法所写的范例验证字串是否只含数字与英文, 字串长度并在4~16个字符之间
<!--?php$str = 'a1234';
if (preg_match("^[a-zA-Z0-9]{4,16}$", $str)) {
echo "验证成功";
} else {
echo "验证失败";
}
?> 简易的台湾身份证字号验证
<!--?php$str = 'a1234';
if (preg_match("^[A-Z]{1}[1-2]{1}[0-9]{8}$", $str)) {
echo "验证成功";
} else {
echo "验证失败";
}
?>
在正则表达式中，有一种意义特殊的构造，即元字符。目前已知的元字符有很多，如 *、?、+ 和 {} 字符。其他字符在正则表达式语言中都有特殊的含义。这些字符包括：$ ^ . [ ( | ) ] 和 \。
.（句点或点）元字符是最简单但最常用的一个字符。它可匹配任何单字符。如果要指定某些模式可包含任意组合的字符，使用句点非常有用，但一定要在特定长度范围内。此外，我们知道表达式将对包含在较长字符串中的所有模式进行匹配，假如只需要精确匹配模式，又该怎么办？这在验证方案中经常出现，例如，要确保用户输入的邮政编码或电话号码的格式正确。使用 ^ 元字符可指定字符串（或行）的开始，使用 $ 元字符可指定字符串（或行）的结束。通过将这些字符添加到模式的开始和结束处，可强制模式仅匹配精确匹配的输入字符串。如果 ^ 元字符用在方括号 [ ] 指定的字符类的开头，也有特殊的含义。具体内容见下。
\ （反斜杠）元字符既可根据特殊含义“转义”字符，也可指定预定义集合元字符的实例。同样，具体内容见下。为了在正则表达式中包括文字样式的元字符，必须使用反斜杠进行“转义”。例如，如果要匹配以“c:\”开始的字符串，可使用：^c:\\。注意，要使用 ^ 元字符指出字符串必须以此模式作为开始，然后用反斜杠元字符转义文字反斜杠。
|（管道）元字符用于交替指定，特别用于在模式中指定“此或彼”。例如，a|b 将匹配包含“a”或“b”的任何输入内容，这与字符类 [ab] 非常类似。
最后，括号 ( ) 用于给模式分组。它允许使用限定符让一个完整模式出现多次。为了便于阅读，或分开匹配特定的输入部分，可能允许分析或重新设置格式。
使用目前提供的工具可以完成很多工作。但是，要使用 [0-9] 表示模式中的每个数值数字，或（更糟）使用 [0-9a-zA-Z]表示任何字母数字字符，还有一段相当漫长的过程。为了减轻处理这些常用但冗长模式的痛苦，事先定义了预定义元字符集合。正则表达式的不同实现定义了不同的预定义元字符集合。这些预定义元字符的标准语法是，在反斜杠 \ 后跟一个或多个字符。多数预定义元字符只有一个字符，它们的使用很容易，是冗长字符类的理想替代字符。以下是两个示例：\d 匹配所有数值数字，\w 匹配所有单词字符（字母数字加下划线）。例外情况是一些特定字符代码匹配，此时必须指定所匹配字符的地址，如 \u000D 将匹配 Unicode 回车符。下面列出一些最常用的字符类及其等效的元字符。（以上内容取自.net正则表达式）
元字符 说明与等效字符类
\a 匹配铃声（警报）；\u0007
\b 匹配字符类外的字边界，它匹配退格字符，\u0008
\t 匹配制表符，\u0009
\r 匹配回车符，\u000D
\w 匹配垂直制表符，\u000B
\f 匹配换页符，\u000C
\n 匹配新行，\u000A
\e 匹配转义符，\u001B
\040 匹配 3 位 8 进制 ASCII 字符。\040 表示空格（十进制数 32）。
\x20 使用 2 位 16 进制数匹配 ASCII 字符。此例中，\x2- 表示空格。
\cC 匹配 ASCII 控制字符，此例中是 ctrl-C。
\u0020 使用 4 位 16 进制数匹配 Unicode 字符。此例中 \u0020 是空格。
\* 不代表预定义字符类的任意字符都只作为该字符本身对待。因此，\* 等同于 \x2A（是文字 *，不是 * 元字符）。
\p{name} 匹配已命名字符类“name”中的任意字符。支持名称是 Unicode 组和块范围。例如，Ll、Nd、Z、IsGreek、IsBoxDrawing 和 Sc（货币）。
\p{name} 匹配已命名字符类“name”中不包括的文本。
\w 匹配任意单词字符。对于非 Unicode 和 ECMAScript 实现，这等同于 [a-zA-Z_0-9]。在 Unicode 类别中，这等同于 [\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}]。
\W \w 的否定，等效于 ECMAScript 兼容集合 [^a-zA-Z_0-9] 或 Unicode 字符类别 [^\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}]。
\s 匹配任意空白区域字符。等效于 Unicode 字符类 [\f\n\r\t\v\x85\p{Z}]。如果使用 ECMAScript 选项指定 ECMAScript 兼容方式，\s 等效于 [ \f\n\r\t\v] （请注意前导空格）。
\S 匹配任意非空白区域字符。等效于 Unicode 字符类别 [^\f\n\r\t\v\x85\p{Z}]。如果使用 ECMAScript 选项指定 ECMAScript 兼容方式，\S 等效于 [^ \f\n\r\t\v] （请注意 ^ 后的空格）。
\d 匹配任意十进制数字。在 ECMAScript 方式下，等效于 Unicode 的 [\p{Nd}]、非 Unicode 的 [0-9]。
\D 匹配任意非十进制数字。在 ECMAScript 方式下，等效于 Unicode 的 [\p{Nd}]、非 Unicode 的 [^0-9]。
正则表达式是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑。
它是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑。正则表达式是一种文本模式，模式描述在搜索文本时要匹配的一个或多个字符串。
扩展资料：
正则表达式的特点是：
1. 灵活性、逻辑性和功能性非常强；
2. 可以迅速地用极简单的方式达到字符串的复杂控制。
3. 对于刚接触的人来说，比较晦涩难懂。
由于正则表达式主要应用对象是文本，因此它在各种文本编辑器场合都有应用，小到著名编辑器EditPlus，大到Microsoft Word、Visual Studio等大型编辑器，都可以使用正则表达式来处理文本内容。
参考资料：正则表达式-百度百科
正则表达式，又称规则表达式。是计算机科学的一个概念。
正则表达式通常被用来检索、替换那些符合某个模式(规则)的文本。许多程序设计语言都支持利用正则表达式进行字符串操作。例如，在Perl中就内建了一个功能强大的正则表达式引擎。正则表达式这个概念最初是由Unix中的工具软件（例如sed和grep）普及开的。
正则表达式通常缩写成“regex”，单数有regexp、regex，复数有regexps、regexes、regexen。
扩展资料
正则表达式的作用：
1、匹配
检查字符串是否符合正则表达式中的规则，有一次不匹配，则返回false。如：
String str="abc";
String reg="[a-zA-Z]\\d?";//次表达式表示字符串的第一位只能是字母，第二位只能是数字或没有boolean flag=str.matches(reg);//返回结果为true。
2、切割
所谓切割，即是按一定的规则将字符串分割成多个子字符串，如：
String str="zhangsan,lishi,wangwu"。
String reg=",";//表示以逗号作为切割符。
String[] arr=str.split(reg);//返回结果为{“zhangsan”,"lisi","wangwu}。
3、替换
即将字符串中符合规则的字符替换成指定字符，如：
String str="sfhjhfh136hjasdf73466247fsjha8437482jfjsfh746376"。
str.replaceAll("\\d{3,}","#");//表示将连续出现三个或三个以上的数字替换成“#”。
参考资料来源：百度百科-正则表达式
js正则表达式如何应用
本文主要和大家js中正则表达式的应用实例（包括面试题）,希望能帮助到大家，能让大家正确使用js正则表达式。1、找重复项最多的字符和个数3、判断是否为邮箱email验证规则： 电子邮箱的正确写法一般为: 用户名@邮箱网站.com(.cn) 第一部分：由字母、数字、下划线、短线“-”、点号“.”组成第二部分：为一个域名，域名由字母、数字、短线“-”、域名后缀组成（域名后缀一般为两位到三位。例如：com cn net现在域名有的也会大于四位） function isEmail(str){ var reg =/^([a-zA-Z0-9_-])+@([a-zA-Z0-9_-])+((\.[a-zA-Z0-9_-]{2,3}){1,2})$/; return reg.test(str); }4、验证手机号码验证规则： 11位数字，以1开头 function isEmail(str){ var reg =/^1([0-9]){10}$/; //也可以为 var reg= /^1\d{10}$/; return reg.test(str); }5、验证是否由数字和字母组成 function isEmail(str){ var reg =/^([0-9a-zA-Z])+$/; return reg.test(str); }6、如何获取一个字符串中的数字字符，并按数组形式输出例如：一串字符串：ddjsd234sdjs45sdda83ndas333sa9382ssd2var str ='dgfhfgh254bhku289fgdhdy67'; var arr = []; function arrFn(){ var re = /\d+/g ; arr.push(str.match(re)); return arr; }7、判断字符串是否存在连续重复的字母var re = /([a-zA-Z])\1+/;8、判断是否已元音字母结尾var re = /[aeiou]$/i; //不要忘了添加不区分大小写的字符i9、判断是否符合USD格式规则：给定字符串 str，检查其是否符合美元书写格式 1、以 $ 开始 2、整数部分，从个位起，满 3 个数字用 , 分隔 3、如果为小数，则小数部分长度为 2 4、正确的格式如：$1,023,032.03 或者 $2.03，错误的格式如：$3,432,12.12 或者 $34,344.3** var str ='$1,023,032.03'; var re = /^\$\d{1,3}((,\d{3}))*(\.\d{2})?$/; //需要注意的是特殊字符要加转义符号\10、获取URL参数规则：1. 指定参数名称，返回该参数的值 或者 空字符串 2. 不指定参数名称，返回全部的参数对象 或者 {} 3. 如果存在多个同名参数，则返回数组**// 获取 url 参数 function getUrlParam(sUrl, sKey) { var arr={}; sUrl.replace(/\??(\w+)=(\w+)&?/g,function(match,p1,p2){ //console.log(match,p1,p2); if(!arr[p1]){ arr[p1]=p2; } else { var p=arr[p1]; arr[p1]=[].concat(p,p2); } }) if(!sKey)return arr; else{ for(var ele in arr){ if(ele==sKey){return arr[ele];} } return ""; } }相关推荐：JS中正则表达式的理解总结js中正则表达式的创建与使用js中正则表达式是怎么使用的？
如何使用正则表达式
QTP使用正则表达式有2种方式，一种是在“常量值选项”对话框或“参数选项”对话框的“值”框中输入字符串的正则表达式语法，可以定义正则表达式。选中“正则表达式”复选框，以指示QuickTest将该值作为正则表达式处理。
另一种是使用描述性编程，所有编程描述属性值都均自动作为正则表达式处理。注意：您可以只将正则表达式应用于字符串类型的值。
默认情况下，除了句点(.)、连字符(-)、星号(*)、插字号(^)、方括号([ ])、圆括号(())、货币符号($)、垂直线(|)、加号(+)、问号(?)和反斜杠(\)以外，QuickTest将正则表达式中的所有字符作为文字处理。当一个特殊字符前面带有反斜杠(\)时，QuickTest将其作为文字字符处理。
如果在“常量值选项”或“参数选项”对话框的“值”框中输入一个特殊字符，QuickTest会询问您是否要在每个特殊字符前面添加一个反斜杠(\)。如果单击“是”，则相应的特殊字符前面就会加上一个反斜杠(\)，以指示QuickTest将该字符作为文字处理。如果单击“否”，QuickTest将该特殊字符作为正则表达式字符处理。
本节描述某些更常用的选项，可用于创建正则表达式：
? 使用反斜杠字符( \ )
? 匹配任意单个字符( . )
? 匹配列表中的任意单个字符( [xy] )
? 匹配不在列表中的任意单个字符( [^xy] )
? 匹配某个范围内的任意单个字符( [x-y] )
? 特定字符的零次或多次匹配( * )
? 特定字符的一次或多次匹配( + )
? 特定字符的零次或一次匹配( ? )
? 对正则表达式进行分组( ( ) )
? 匹配几个正则表达式中的一个表达式( | )
? 在一行的开始进行匹配( ^ )
? 在一行的结尾进行匹配( $ )
? 匹配包括下划线在内的任一字母数字字符( \w )
? 匹配任意非字母数字字符( \W )
? 组合正则表达式操作符
正则表达式的语法规则和标记
字符描述：
^符号匹配字符串的开头。例如：
^abc 与“abc xyz”匹配，而不与“xyz abc”匹配
$符号匹配字符串的结尾。例如：
abc$ 与“xyz abc”匹配，而不与“abc xyz”匹配。
注意：如果同时使用^符号和$符号，将进行精确匹配。例如：
^abc$ 只与“abc”匹配
*符号匹配0个或多个前面的字符。例如：
ab* 可以匹配“ab”、“abb”、“abbb”等
+符号匹配至少一个前面的字符。例如：
ab+ 可以匹配“abb”、“abbb”等，但不匹配“ab”。
?符号匹配0个或1个前面的字符。例如：
ab?c? 可以且只能匹配“abc”、“abbc”、“abcc”和“abbcc”
.符号匹配除换行符以外的任何字符。例如：
(.)+ 匹配除换行符以外的所有字符串
x|y匹配“x”或“y”。例如：
abc|xyz 可匹配“abc”或“xyz”，而“ab(c|x)yz”匹配“abcyz”和“abxyz”
{n}匹配恰好n次（n为非负整数）前面的字符。例如：
a{2} 可以匹配“aa“，但不匹配“a”
{n,}匹配至少n次（n为非负整数）前面的字符。例如：
a{3,} 匹配“aaa”、“aaaa”等，但不匹配“a”和“aa”。
注意：a{1,}等价于a+
a{0,}等价于a*
{m,n}匹配至少m个，至多n个前面的字符。例如：
a{1,3} 只匹配“a”、“aa”和“aaa”。
注意：a{0,1}等价于a?
[xyz]表示一个字符集，匹配括号中字符的其中之一。
正则表达式高级用法
上一章分享了正式表达式的入门知识，以及单字符、多字符常用的匹配方法，对于工作维护过程中已经够用，但是有时候只使用基础知识来实现就会比较麻烦，如果使用高级用法就会比较方便很多。 例如：匹配一个HTML文件中两个 标签中的文件。 文本内容：
从上一章内容的知识可以想到的表达式可能如下：
但是这个表达式配置的结果是 AK and HI ，而不是我们想要的 AK 和 HI 。
实现很简单，就是在原有“贪婪型”元字符后面加上一个 ? 号，如下表格
前面的元字符都是对紧挨着前面的一个字符有效，例如表达式 the{3} 匹配 theee 字符串，假如我们想匹配连续三个 the 字符串怎么办呢，这就涉及到子表达式的概念。
把一个表达式匹配的内容做为一个单独的元素嵌入到另外一个表达式中，那这个做为独立元素的表达式就是子表达式，需要使用 () 括起来。这个跟数学的表达式概念很类似。 并且子表达与数学表达式还有一个类似的地方就是，正则表达式的子表达式也可以嵌套使用
假如我们再加个条件：我们想匹配连续三个 the 或者连续三个 you ，怎么实现？这就是正则表达式的选择操作符，也叫或操作符了
上面的问题就可以使用正则表达式 (the|you){3} 来表示
当一个模式的全部或者部分内容由 一对括号括起来 时，就对表达式进行了分组（其实就是放在 () 中的子表达式），并且把分组匹配到内容捕获并且临时存放在内存中。这就是捕获分组，可以在后面表达式中使用就叫后向引用，或者叫回溯引用。 默认情况下，分组是从左到右依次排序从1编号，第一个分组就是1，第二个分组就是2等等。
后向引用很简单就是一个 \ 或者 $ 后面跟相应编号即可。例如 \1 或者 $1 就表示引用第一个捕获分组。
前面讲捕获分组都是通过位置编号来访问，在perl和python、.NET等语言中还支持对捕获分组命名。这样就比较容易理解
顾名思义，与捕获分组相反，就是不会将分组匹配的内容放在内存中。主要是为了提高性能。 使用方法：在分组的开头加上 ?: ，例如 (?:the)
环视是一种非捕获分组，它根据某个模式之前或者之后的内容要求匹配其他模式。环视也称为零宽度断言。
(?(id/name)yes-pattern|no-pattern) 如果给定的 id 或 name 存在，将会尝试匹配 yes-pattern ；否则就尝试匹配 no-pattern ， no-pattern 可选； 例如：email样式匹配 (<)?(\w+@\w+(?:\.\w+)+)(?(1)>|$) ，当 < 存在时，则最后要匹配 > ；否则匹配结束符 $
《学习正则表达式》 《正则表达式必知必会》