精华内容
下载资源
问答
  • 前面几节讲解了如何在JavaScript中使用正则表达式,以及如何执行匹配,本节就来讲一下正则表达式的具体语法。正则表达式是一种通用的工具,在JavaScript、PHP...本节讲到的正则表达式语法适用于 JavaScript。正则表...

    前面几节讲解了如何在 JavaScript 中使用正则表达式,以及如何执行匹配,本节就来讲一下正则表达式的具体语法。

    正则表达式是一种通用的工具,在 JavaScript、PHP、Java、Python、C++ 等几乎所有的编程语言中都能使用;但是,不同编程语言对正则表达式语法的支持不尽相同,有的编程语言支持所有的语法,有的仅支持一个子集。本节讲到的正则表达式语法适用于 JavaScript。

    正则表达式的语法体现在字符模式上。字符模式是一组特殊格式的字符串,它由一系列特殊字符和普通字符构成,其中每个特殊字符都包含一定的语义和功能。

    描述字符

    根据正则表达式语法规则,大部分字符仅能够描述自身,这些字符被称为普通字符,如所有的字母、数字等。

    元字符就是拥有特动功能的特殊字符,大部分需要加反斜杠进行标识,以便于普通字符进行区别,而少数元字符,需要加反斜杠,以便转译为普通字符使用。JavaScript 正则表达式支持的元字符如表所示。

    元字符

    元字符描述

    .

    查找单个字符,除了换行和行结束符

    \w

    查找单词字符

    \W

    查找非单词字符

    \d

    查找数字

    \D

    查找非数字字符

    \s

    查找空白字符

    \S

    查找非空白字符

    \b

    匹配单词边界

    \B

    匹配非单词边界

    \0

    查找 NUL字符

    \n

    查找换行符

    \f

    查找换页符

    \r

    查找回车符

    \t

    查找制表符

    \v

    查找垂直制表符

    \xxx

    查找以八进制数 xxxx 规定的字符

    \xdd

    查找以十六进制数 dd 规定的字符

    \uxxxx

    查找以十六进制 xxxx规定的 Unicode 字符

    表示字符的方法有多种,除了可以直接使用字符本身外,还可以使用 ASCII 编码或者 Unicode 编码来表示。

    示例1

    下面使用 ASCII 编码定义正则表达式直接量。

    var r = /\x61/;

    var s = "JavaScript";

    var a = s.match(s);

    由于字母 a 的 ASCII 编码为 97,被转换为十六进制数值后为 61,因此如果要匹配字符 a,就应该在前面添加“\x”前缀,以提示它为 ASCII 编码。

    示例2

    除了十六进制外,还可以直接使用八进制数值表示字符。

    var r = /\141/;

    var s = "JavaScript";

    var a = s.match(r);

    使用十六进制需要添加“\x”前缀,主要是为了避免语义混淆,而八进制则不需要添加前缀。

    示例3

    ASCII 编码只能够匹配有限的单字节字符,使用 Unicode 编码可以表示双字节字符。Unicode 编码方式:“\u”前缀加上 4 位十六进制值。

    var r = "/\u0061/";

    var s = "JavaScript";

    var a = s.match(s);

    在 RegExp() 构造函数中使用元字符时,应使用双斜杠。

    var r = new RegExp("\\u0061");

    RegExp() 构造函数的参数只接受字符串,而不是字符模式。在字符串中,任何字符加反斜杠还表示字符本身,如字符串“\u”就被解释为 u 本身,所以对于“\u0061”字符串来说,在转换为字符模式时,就被解释为“u0061”,而不是“\u0061”,此时反斜杠就失去转义功能。解决方法:在字符 u 前面加双反斜杠。

    描述字符范围

    在正则表达式语法中,放括号表示字符范围。在方括号中可以包含多个字符,表示匹配其中任意一个字符。如果多个字符的编码顺序是连续的,可以仅指定开头和结尾字符,省略中间字符,仅使用连字符~表示。如果在方括号内添加脱字符^前缀,还可以表示范围之外的字符。例如:

    [abc]:查找方括号内任意一个字符。

    [^abc]:查找不在方括号内的字符。

    [0-9]:查找从 0 至 9 范围内的数字,即查找数字。

    [a-z]:查找从小写 a 到小写 z 范围内的字符,即查找小写字母。

    [A-Z]:查找从大写 A 到大写 Z 范围内的字符,即查找大写字母。

    [A-z]:查找从大写 A 到小写 z 范围内的字符,即所有大小写的字母。

    示例1

    字符范围遵循字符编码的顺序进行匹配。如果将要匹配的字符恰好在字符编码表中特定区域内,就可以使用这种方式表示。

    如果匹配任意 ASCII 字符:

    var r = /[\u0000-\u00ff]/g;

    如果匹配任意双字节的汉字:

    var r = /[^\u0000-\u00ff]/g;

    如果匹配任意大小写字母和数字:

    var r = /[a-zA-Z0-9]/g;

    使用 Unicode 编码设计,匹配数字:

    var r = /[\u0030-\u0039]/g;

    使用下面字符模式可以匹配任意大写字母:

    var r = /[\u0041-\u004A]/g;

    使用下面字符模式可以匹配任意小写字母:

    var r = /[\u0061-\u007A]/g;

    示例2

    在字符范围内可以混用各种字符模式。

    var s = "abcdez"; //字符串直接量

    var r = /[abce-z]/g; //字符a、b、c,以及从e~z之间的任意字符

    var a = s.match(r); //返回数组["a","b","c","e","z"]

    示例3

    在中括号内不要有空格,否则会误解为还要匹配空格。

    var r = /[0-9]/g;

    示例4

    字符范围可以组合使用,以便设计更灵活的匹配模式。

    var s = "abc4 abd6 abe3 abf1 abg7"; //字符串直接量

    var r = /ab[c-g][1-7]/g; //前两个字符为ab,第三个字符为从c到g,第四个字符为1~7的任意数字

    var a = s.match(r); //返回数组["abc4","abd6","abe3","abf1","abg7"]

    示例5

    使用反义字符范围可以匹配很多无法直接描述的字符,达到以少应多的目的。

    var r = /[^0123456789]/g;

    在这个正则表达式中,将会匹配除了数字以外任意的字符。反义字符类比简单字符类的功能更强大和实用。

    选择匹配

    选择匹配类似于 JavaScript 的逻辑与运算,使用竖线|描述,表示在两个子模式的匹配结果中任选一个。例如:

    1) 匹配任意数字或字母

    var r = /\w+|\d+/;

    2) 可以定义多重选择模式。设计方法:在多个子模式之间加入选择操作符。

    var r = /(abc)|(efg)|(123)|(456)/;

    为了避免歧义,应该为选择操作的多个子模式加上小括号。

    示例

    设计对提交的表单字符串进行敏感词过滤。先设计一个敏感词列表,然后使用竖线把它们连接在一起,定义选择匹配模式,最后使用字符串的 replace() 方法把所有敏感字符替换为可以显示的编码格式。代码如下:

    var s = ''; //待过滤的表单提交信息

    var r = /\'|\"|\/gi; //过滤敏感字符的正则表达式

    function f() { //替换函数

    把敏感字符替换为对应的网页显示的编码格式

    return "" + arguments[0].charCodeAt(0) + ";";

    }

    var a =s.replace(r,f); //执行过滤替换

    document.write(a); //在网页中显示正常的字符信息

    console.log(a);

    显示结果如下:

    d319371eb34d6ba8b08218ee24b4f90c.png

    重复匹配

    在正则表达式语法中,定义了一组重复类量词,如表所示。它们定义了重复匹配字符的确数或约数。

    重复类量词列表

    量词描述

    n+

    匹配任何包含至少一个 n 的字符串

    n*

    匹配任何包含零个或多个 n 的字符串

    n?

    匹配任何包含零个或一个 n 的字符串

    n{x}

    匹配包含 x 个 n 的序列的字符串

    n{x,y}

    匹配包含最少 x 个、最多 y 个 n 的序列的字符串

    n{x,}

    匹配包含至少 x 个 n 的序列的字符串

    示例

    下面结合示例进行演示说明,先设计一个字符串:

    var s = "ggle gogle google gooogle goooogle gooooogle goooooogle gooooooogle goooooooogle";

    1) 如果仅匹配单词 ggle 和 gogle,可以设计:

    var r = /go?gle/g;

    var a = s.match(r);

    量词?表示前面字符或子表达式为可有可无,等效于:

    var r = /go{0,1}gle/g;

    var a = s.match(r);

    2) 如果匹配第 4 个单词 gooogle,可以设计:

    var r = /go{3}gle/g;

    var a = s.match(r);

    等效于:

    var r = /gooogle/g;

    var a = s.match(r);

    3) 如果匹配第 4 个到第 6 个之间的单词,可以设计:

    var r = /go{3,5}gle/g;

    var a = s.match(r);

    4) 如果匹配所有单词,可以设计:

    var r = /go*gle/g;

    var a = s.match(r);

    量词*表示前面字符或表达式可以不出现,或者重复出现任意多次。等效于:

    var r = /go(0,)gle/g;

    var a = s.match(r);

    5) 如果匹配包含字符“o”的所有词,可以设计:

    var r = /go+gle/g;

    var a = s.match(r);

    量词+表示前面字符或子表达式至少出现 1 次,最多重复次数不限。等效于:

    var r = /go{1,}gle/g;

    var a = s.match(r);

    重复类量词总是出现在它们所作用的字符或子表达式后面。如果想作用于多个字符,需要使用小括号把它们包裹在一起形成一个子表达式。

    惰性匹配

    重复类量词都具有贪婪性,在条件允许的前提下,会匹配尽可能多的字符。

    ?、{n} 和 {n,m} 重复类具有弱贪婪性,表现为贪婪的有限性。

    *、+ 和 {n,} 重复类具有强贪婪性,表现为贪婪的无限性。

    示例1

    越是排在左侧的重复类量词匹配优先级越高。下面示例显示当多个重复类量词同时满足条件时,会在保证右侧重复类量词最低匹配次数基础上,使最左侧的重复类量词尽可能占有所有字符。

    var s = "

    ";

    var r = /(<.>)(<.>)/

    var a = s.match(r);

    //左侧表达式匹配"

    "

    console.log(a[1]);

    console.log(a[2]); //右侧表达式匹配“

    展开全文
  • 腾讯云活动聚集了最新的...因为对js中的正则不太了解,可以参考一下js 中正则表达式必知必会1. 字符串操作消除字符串两边的括号 trimstring.prototype.trim = function(){ return this.replace((^s+)|(s+$)g, )}h...

    fff0d68b9efd2ee8684033b2d7e2877d.png

    1ifzakkah5.jpg

    腾讯云活动聚集了最新的降价打折、特惠折扣等资料,你在这里可以寻找云服务器、域名、、小流程等等多种不同产品的促销活动,还有这些品牌的免费试用哦。

    因为对js中的正则不太了解,可以参考一下js 中正则表达式必知必会1. 字符串操作消除字符串两边的括号 trimstring.prototype.trim = function(){ return this.replace((^s+)|(s+$)g, )}html编码,对< > & 等符号转义,防止xss攻击function htmlencode(str) { return str.replace(g, function(rs){ switch (rs) { case ...

    var obj = document.getelementbyid(name); if(!reg.test(obj.value)){ alert(请输入数字!); } if(!^*$.test(obj.value)){ alert(请输入数字!); } } javascript正则表达式集 : 验证数字:^*$ 验证n位的数字:^d{n}$ 验证至少n位数字:^d{n,}$ 验证m-n位的数字:^d{m,n}$ 验证零和非零开头的数字:^(|*)$ 验证有两位...

    217jy2iu0q.png

    c0988b06f091b99128cd93481ff1a639.gif

    转自: js正则表达式讲解,从方法和英语到js正则、es6正则扩展,最终再到正则实践策略温馨提示:标题很长很长,维持耐心,必要时可以跳着看,其实用于查应该不错的。 正则啊,好像一座航标,当你在字符串的大海不知所措的时候,总能给你一点思路; 正则啊,好像一台验钞机,在你不知道用户填写的票子真假的时候...

    url 六,js的正则表达式rge.test(str) 检验目标对象中是否包括匹配模式,并相应的返回true或false rge.sourcestr.search(rge) 将离开一个整数值...^w+((-w+)|(.w+))*@w+((.|-)w+)*.w+$ 三,匹配英文符号的正则表达式: 评注:匹配英文还真是个头痛的事,有了这个解释器就好办了 匹配双字符字符(包含汉字...

    ejszsnba3i.png

    1.正则表达式概述正则表达式, 又称正规表示式、正规表示法、正规表达式、规则表达式、常规认为法(语文:regularexpression,在源码中常简写为regex、regexp或re),是计算机科学的一个概念。 正则表达式使用单个字符串来描述、匹配一系列匹配某个句子规则的字符串。 在众多文本编辑器里,正则表达式通常被用于检索...

    本文不讨论正则表达式入门,即怎么使用正则匹配。 讨论的是两种创建正则表达式的好坏和一些细节,最终给出一些常见正则匹配表达式。 javascript中的正则表达式作为对象,我们可以使用两种方式创建正则表达式:使用new regexp()构造函数使用正则表达字面量 先说结果,使用正则表达字面量的效能更高。 下面的实例源码...

    09bac8c0981888b1cff978eb19d1aaa4.jpg

    wdyuzyrjtc.png

    我们发现,正则匹配并没有得到正确的匹配结果。? 图(3)有一种方式是把正则表达式,换成汉字对应的unicode编码。 但是js正则表达式 非中文,在fme2016中,对以下的市、区换成...本文作者从另一个角度写了怎么在fme中使用正则,就如之前所说fme是一个开放的平台,可以容纳很多,还是你是讨厌使用py还是js,都可以以自己善于的方法扩大...

    恰好有一栏的数据全部是英文汉字,所以仅仅对于汉字函数使用默认的sort排序,所以是针对汉字的unicode值进行比较排序js正则表达式 非中文,结果肯定与我们习惯的按照汉字的读音排序大不相似。 但是对于一个简单易用的流程而言,没有必要写个繁杂的硬件来将汉字转化为生字,然后在进行ascii码值比较,代价有些大,还好,js中有一个函数...

    仅仅可以匹配是否含有非ascll字符 而汉字只是其中一个比较小的区域 不太精确由于我的界面编码是utf-8的 于是把js的解释器搬到php中来 提示pcre不支持”u”和其它乱七八糟的一大堆东西 后来查信息了解到 php的正则有一种叫做字节组的东西用x{... 表示 于是把解释器改成”^+$” 又提示”x”表达式后的数字太大 又查了...

    } } }2 正则表达式去括号str.replace(^(s|u00a0)+|(s|u00a0)+$g,); 3 利用正则过滤中文str.replace(g,); 4 禁止用户的拷贝和复制xxx.oncopy =function(){ return false;}xxx.onpaste = function(){ return false;}5限制字符串长度(划分中英文) 主要精神: 需要3个数据:1 限制输入的宽度; 2 已经输入了多长...

    32e3ff4384d3a908061f6ea214a4b6cc.png

    pynlpir提供了nlpirictclas汉语词性的python接口,而且zhon提供了常见汉字常量,如cjk符号和韵母,英文标点,读音,和小篆正则表达式(如寻找文本中的简体...可以让你在浏览器中,跑起深度学习作用的超酷开源项目convnetjs作者karpathy告诉你,绝佳技巧是,当你开始写代码,所有将显得清晰。 他刚发布了一本图书...

    pynlpir 提供了 nlpirictclas 汉语词性的 python 接口,而且 zhon 提供了常见汉字常量,如 cjk 字符和韵母,英文标点,读音,和小篆正则表达式(如寻找...跑起深度学习作用的超酷开源项目 convnetjs 作者 karpathy 告诉你,绝佳技巧是,当你开始写代码,所有将显得清晰。 他刚发布了一本图书,不断更新...

    pynlpir提供了nlpirictclas汉语词性的python接口,而且zhon提供了常见汉字常量,如cjk符号和韵母,英文标点,读音,和小篆正则表达式(如寻找文本中的简体...可以让你在浏览器中,跑起深度学习作用的超酷开源项目convnetjs作者karpathy告诉你,绝佳技巧是,当你开始写代码,所有将显得清晰。 他刚发布了一本图书...

    pynlpir提供了nlpirictclas汉语词性的python接口,而且zhon提供了常见汉字常量,如cjk符号和韵母,英文标点,读音,和小篆正则表达式(如寻找文本中的简体...可以让你在浏览器中,跑起深度学习作用的超酷开源项目convnetjs作者karpathy告诉你,绝佳技巧是,当你开始写代码,所有将显得清晰。 他刚发布了一本图书...

    pynlpir提供了nlpirictclas汉语词性的python接口,而且zhon提供了常见汉字常量,如cjk符号和韵母,英文标点,读音,和小篆正则表达式(如寻找文本中的简体...可以让你在浏览器中,跑起深度学习作用的超酷开源项目convnetjs作者karpathy告诉你,绝佳技巧是,当你开始写代码,所有将显得清晰。 他刚发布了一本图书...

    20140307110913497.jpg

    匹配英文符号的正则表达式: 19。 匹配双字符字符(包含汉字在内): 20。 应用:计算字符串的宽度(一个双字符字符宽度计2,ascii字符计1)string.prototype.len=function(){return this.replace(g,aa).length; 21。匹配空行的正则表达式:n*r 22。 匹配html标记的正则表达式:. *| 23。 匹配首尾空格的正则表达式...

    5piiu87jtf.jpg

    一般来讲主要是要寻找包含内容的js源码串,然后通过正则表达式获得相应的内容,而不是解析html标签。 另一种情况是在和用户交互时,javascript可能会动态...交互问题有些网页通常需要和用户进行一些交互,从而才能走到下一步,譬如输入一个验证码,拖拽一个滑块,选几个汉字。 网站之所以如此做,好多时候都是...

    一般来讲主要是要寻找包含内容的js源码串,然后通过正则表达式获得相应的内容,而不是解析html标签。 另一种情况是在和用户交互时,javascript可能会动态...交互问题有些网页通常需要和用户进行一些交互,从而才能走到下一步,譬如输入一个验证码,拖拽一个滑块,选几个汉字。 网站之所以如此做,好多时候都是...

    x3kjvwlsq3.png

    一般来讲主要是要寻找包含内容的js源码串,然后通过正则表达式获得相应的内容,而不是解析html标签。 另一种情况是在和用户交互时,javascript可能会动态...交互问题有些网页通常需要和用户进行一些交互,从而才能走到下一步,譬如输入一个验证码,拖拽一个滑块,选几个汉字。 网站之所以如此做,好多时候都是...

    wmpe8lrwa1.jpg

    网站中存在诸多与文本内容无关的资料,譬如广告,导航栏,html、js源码,注释等等。 文本清洗,就是通过正则匹配去掉那些破坏信息,抽取出洁净的文本内容...指的是将一个汉字序列切分成一个一个单独的词。 分词就是将连续的字序列按照一定的规范重新组合成词序列的过程。 一篇文本中不是所有词都很重要...

    本文来自电脑杂谈,转载请注明本文网址:

    http://www.pc-fly.com/a/jisuanjixue/article-118918-1.html

    展开全文
  • 本节讲到的正则表达式语法适用于 JavaScript。 正则表达式的语法体现在字符模式上。字符模式是一组特殊格式的字符串,它由一系列特殊字符和普通字符构成,其中每个特殊字符都包含一定的语义和功能。 描述字符 根据...

    正则表达式是一种通用的工具,在 JavaScript、PHP、Java、PythonC++ 等几乎所有的编程语言中都能使用;但是,不同编程语言对正则表达式语法的支持不尽相同,有的编程语言支持所有的语法,有的仅支持一个子集。本节讲到的正则表达式语法适用于 JavaScript。

    正则表达式的语法体现在字符模式上。字符模式是一组特殊格式的字符串,它由一系列特殊字符和普通字符构成,其中每个特殊字符都包含一定的语义和功能。

    描述字符

    根据正则表达式语法规则,大部分字符仅能够描述自身,这些字符被称为普通字符,如所有的字母、数字等。

    元字符就是拥有特动功能的特殊字符,大部分需要加反斜杠进行标识,以便于普通字符进行区别,而少数元字符,需要加反斜杠,以便转译为普通字符使用。JavaScript 正则表达式支持的元字符如表所示。
     

    元字符
    元字符描述
    .查找单个字符,除了换行和行结束符
    \w查找单词字符
    \W查找非单词字符
    \d查找数字
    \D查找非数字字符
    \s查找空白字符
    \S查找非空白字符
    \b匹配单词边界
    \B匹配非单词边界
    \0查找 NUL字符
    \n查找换行符
    \f查找换页符
    \r查找回车符
    \t查找制表符
    \v查找垂直制表符
    \xxx查找以八进制数 xxxx 规定的字符
    \xdd查找以十六进制数 dd 规定的字符
    \uxxxx查找以十六进制 xxxx规定的 Unicode 字符


    表示字符的方法有多种,除了可以直接使用字符本身外,还可以使用 ASCII 编码或者 Unicode 编码来表示。

    示例1

    下面使用 ASCII 编码定义正则表达式直接量。

     
    1. var r = /\x61/;
    2. var s = "JavaScript";
    3. var a = s.match(s);

    由于字母 a 的 ASCII 编码为 97,被转换为十六进制数值后为 61,因此如果要匹配字符 a,就应该在前面添加“\x”前缀,以提示它为 ASCII 编码。

    示例2

    除了十六进制外,还可以直接使用八进制数值表示字符。

     
    1. var r = /\141/;
    2. var s = "JavaScript";
    3. var a = s.match(r);

    使用十六进制需要添加“\x”前缀,主要是为了避免语义混淆,而八进制则不需要添加前缀。

    示例3

    ASCII 编码只能够匹配有限的单字节字符,使用 Unicode 编码可以表示双字节字符。Unicode 编码方式:“\u”前缀加上 4 位十六进制值。

     
    1. var r = "/\u0061/";
    2. var s = "JavaScript";
    3. var a = s.match(s);


    在 RegExp() 构造函数中使用元字符时,应使用双斜杠。

     
    1. var r = new RegExp("\\u0061");

    RegExp() 构造函数的参数只接受字符串,而不是字符模式。在字符串中,任何字符加反斜杠还表示字符本身,如字符串“\u”就被解释为 u 本身,所以对于“\u0061”字符串来说,在转换为字符模式时,就被解释为“u0061”,而不是“\u0061”,此时反斜杠就失去转义功能。解决方法:在字符 u 前面加双反斜杠。

    描述字符范围

    在正则表达式语法中,放括号表示字符范围。在方括号中可以包含多个字符,表示匹配其中任意一个字符。如果多个字符的编码顺序是连续的,可以仅指定开头和结尾字符,省略中间字符,仅使用连字符~表示。如果在方括号内添加脱字符^前缀,还可以表示范围之外的字符。例如:

    • [abc]:查找方括号内任意一个字符。
    • [^abc]:查找不在方括号内的字符。
    • [0-9]:查找从 0 至 9 范围内的数字,即查找数字。
    • [a-z]:查找从小写 a 到小写 z 范围内的字符,即查找小写字母。
    • [A-Z]:查找从大写 A 到大写 Z 范围内的字符,即查找大写字母。
    • [A-z]:查找从大写 A 到小写 z 范围内的字符,即所有大小写的字母。

    示例1

    字符范围遵循字符编码的顺序进行匹配。如果将要匹配的字符恰好在字符编码表中特定区域内,就可以使用这种方式表示。

    如果匹配任意 ASCII 字符:

     
    1. var r = /[\u0000-\u00ff]/g;

    如果匹配任意双字节的汉字:

     
    1. var r = /[^\u0000-\u00ff]/g;

    如果匹配任意大小写字母和数字:

     
    1. var r = /[a-zA-Z0-9]/g;

    使用 Unicode 编码设计,匹配数字:

     
    1. var r = /[\u0030-\u0039]/g;

    使用下面字符模式可以匹配任意大写字母:

     
    1. var r = /[\u0041-\u004A]/g;

    使用下面字符模式可以匹配任意小写字母:

     
    1. var r = /[\u0061-\u007A]/g;

    示例2

    在字符范围内可以混用各种字符模式。

     
    1. var s = "abcdez"; //字符串直接量
    2. var r = /[abce-z]/g; //字符a、b、c,以及从e~z之间的任意字符
    3. var a = s.match(r); //返回数组["a","b","c","e","z"]

    示例3

    在中括号内不要有空格,否则会误解为还要匹配空格。

     
    1. var r = /[0-9]/g;

    示例4

    字符范围可以组合使用,以便设计更灵活的匹配模式。

     
    1. var s = "abc4 abd6 abe3 abf1 abg7"; //字符串直接量
    2. var r = /ab[c-g][1-7]/g; //前两个字符为ab,第三个字符为从c到g,第四个字符为1~7的任意数字
    3. var a = s.match(r); //返回数组["abc4","abd6","abe3","abf1","abg7"]

    示例5

    使用反义字符范围可以匹配很多无法直接描述的字符,达到以少应多的目的。

     
    1. var r = /[^0123456789]/g;

    在这个正则表达式中,将会匹配除了数字以外任意的字符。反义字符类比简单字符类的功能更强大和实用。

    选择匹配

    选择匹配类似于 JavaScript 的逻辑与运算,使用竖线|描述,表示在两个子模式的匹配结果中任选一个。例如:
    1) 匹配任意数字或字母

     
    1. var r = /\w+|\d+/;

    2) 可以定义多重选择模式。设计方法:在多个子模式之间加入选择操作符。

     
    1. var r = /(abc)|(efg)|(123)|(456)/;

    为了避免歧义,应该为选择操作的多个子模式加上小括号。

    示例

    设计对提交的表单字符串进行敏感词过滤。先设计一个敏感词列表,然后使用竖线把它们连接在一起,定义选择匹配模式,最后使用字符串的 replace() 方法把所有敏感字符替换为可以显示的编码格式。代码如下:

     
    1. var s = '<meta charset="utf-8">'; //待过滤的表单提交信息
    2. var r = /\'|\"|\<|\>/gi; //过滤敏感字符的正则表达式
    3. function f() { //替换函数
    4. 把敏感字符替换为对应的网页显示的编码格式
    5. return "&#" + arguments[0].charCodeAt(0) + ";";
    6. }
    7. var a =s.replace(r,f); //执行过滤替换
    8. document.write(a); //在网页中显示正常的字符信息
    9. console.log(a);

    显示结果如下:
     

    重复匹配

    在正则表达式语法中,定义了一组重复类量词,如表所示。它们定义了重复匹配字符的确数或约数。
     

    重复类量词列表
    量词描述
    n+匹配任何包含至少一个 n 的字符串
    n*匹配任何包含零个或多个 n 的字符串
    n?匹配任何包含零个或一个 n 的字符串
    n{x}匹配包含 x 个 n 的序列的字符串
    n{x,y}匹配包含最少 x 个、最多 y 个 n 的序列的字符串
    n{x,}匹配包含至少 x 个 n 的序列的字符串

    示例

    下面结合示例进行演示说明,先设计一个字符串:

     
    1. var s = "ggle gogle google gooogle goooogle gooooogle goooooogle gooooooogle goooooooogle";


    1) 如果仅匹配单词 ggle 和 gogle,可以设计:

     
    1. var r = /go?gle/g;
    2. var a = s.match(r);

    量词?表示前面字符或子表达式为可有可无,等效于:

     
    1. var r = /go{0,1}gle/g;
    2. var a = s.match(r);


    2) 如果匹配第 4 个单词 gooogle,可以设计:

     
    1. var r = /go{3}gle/g;
    2. var a = s.match(r);

    等效于:

     
    1. var r = /gooogle/g;
    2. var a = s.match(r);


    3) 如果匹配第 4 个到第 6 个之间的单词,可以设计:

     
    1. var r = /go{3,5}gle/g;
    2. var a = s.match(r);


    4) 如果匹配所有单词,可以设计:

     
    1. var r = /go*gle/g;
    2. var a = s.match(r);

    量词*表示前面字符或表达式可以不出现,或者重复出现任意多次。等效于:

     
    1. var r = /go(0,)gle/g;
    2. var a = s.match(r);


    5) 如果匹配包含字符“o”的所有词,可以设计:

     
    1. var r = /go+gle/g;
    2. var a = s.match(r);

    量词+表示前面字符或子表达式至少出现 1 次,最多重复次数不限。等效于:

     
    1. var r = /go{1,}gle/g;
    2. var a = s.match(r);


    重复类量词总是出现在它们所作用的字符或子表达式后面。如果想作用于多个字符,需要使用小括号把它们包裹在一起形成一个子表达式。

    惰性匹配

    重复类量词都具有贪婪性,在条件允许的前提下,会匹配尽可能多的字符。

    • ?、{n} 和 {n,m} 重复类具有弱贪婪性,表现为贪婪的有限性。
    • *、+ 和 {n,} 重复类具有强贪婪性,表现为贪婪的无限性。

    示例1

    越是排在左侧的重复类量词匹配优先级越高。下面示例显示当多个重复类量词同时满足条件时,会在保证右侧重复类量词最低匹配次数基础上,使最左侧的重复类量词尽可能占有所有字符。

     
    1. var s = "<html><head><title></title></head><body></body></html>";
    2. var r = /(<.*>)(<.*>)/
    3. var a = s.match(r);
    4. //左侧表达式匹配"<html><head><title></title></head><body></body></html>"
    5. console.log(a[1]);
    6. console.log(a[2]); //右侧表达式匹配“</html>”

    与贪婪匹配相反,惰性匹配将遵循另一种算法:在满足条件的前提下,尽可能少的匹配字符。定义惰性匹配的方法:在重复类量词后面添加问号?限制词。贪婪匹配体现了最大化匹配原则,惰性匹配则体现最小化匹配原则。

    示例2

    下面示例演示了如何定义匹配模式。

     
    1. var s = "<html><head><title></title></head><body></body></html>";
    2. var r = /<.*?>/
    3. var a = s.match(r); //返回单个元素数组["<html>"]

    在上面示例中,对于正则表达式 /<.*?>/ 来说,它可以返回匹配字符串 "<>",但是为了能够确保匹配条件成立,在执行中还是匹配了带有 4 个字符的字符串“html”。惰性取值不能够以违反模式限定的条件而返回,除非没有找到符合条件的字符串,否则必须满足它。

    针对 6 种重复类惰性匹配的简单描述如下:

    • {n,m}?:尽量匹配 n 次,但是为了满足限定条件也可能最多重复 m 次。
    • {n}?:尽量匹配 n 次。
    • {n,}?:尽量匹配 n 次,但是为了满足限定条件也可能匹配任意次。
    • ??:尽量匹配,但是为了满足限定条件也可能最多匹配 1 次,相当于 {0,1}?。
    • +?:尽量匹配 1 次,但是为了满足限定条件也可能匹配任意次,相当于 {1,}?。
    • *? :尽量不匹配,但是为了满足限定条件也可能匹配任意次,相当于 {0,}?。

    边界量词

    边界就是确定匹配模式的位置,如字符串的头部或尾部,具体说明如表所示。

    JavaScript 正则表达式支持的边界量词
    量词说明
    ^匹配开头,在多行检测中,会匹配一行的开头
    $匹配结尾,在多行检测中,会匹配一行的结尾


    下面代码演示如何使用边界量词。先定义字符串:

     
    1. var s = "how are you"

    1) 匹配最后一个单词

     
    1. var r = /\w+$/;
    2. var a = s.match(r); //返回数组["you"]

    2) 匹配第一个单词

     
    1. var r = /^\w+/;
    2. var a = s.match(r); //返回数组["how"]

    3) 匹配每一个单词

     
    1. var r = /\w+/g;
    2. var a = s.match(r); //返回数组["how","are","you"]

    声明词量

    声明表示条件的意思。声明词量包括正向声明和反向声明两种模式。

    正向声明

    指定匹配模式后面的字符必须被匹配,但又不返回这些字符。语法格式如下:

    匹配模式 (?= 匹配条件)

    声明包含在小括号内,它不是分组,因此作为子表达式。

    下面代码定义一个正前向生命的匹配模式。

     
    1. var s = "one : 1; two : 2";
    2. var r = /\w*(?==)/; //使用正前向声明,指定执行匹配必须满足的条件
    3. var a = s.match(r); //返回数组["two"]

    在上面示例中,通过?==锚定条件,指定只有在 \w* 所能够匹配的字符后面跟随一个等号字符,才能够执行 \w* 匹配。所以,最后匹配的字符串“two”,而不是字符串“one”。

    反向声明

    与正向声明匹配相反,指定接下来的字符都不必被匹配。语法格式如下:

    匹配模式(?! 匹配条件)


    下面代码定义一个反前向生命的匹配模式。

     
    1. var s = "one : 1; two : 2";
    2. var r = /\w*(?!=)/; //使用正前向声明,指定执行匹配不必满足的条件
    3. var a = s.match(r); //返回数组["one"]

    在上面示例中,通过?!=锚定条件,指定只有在“\w*”所能够匹配的字符后面不跟随一个等号字符,才能够执行 \w*匹配。所以,最后匹配的是字符串“one”,而不是字符串“two”。

    子表达式

    使用小括号可以对字符模式进行任意分组,在小括号内的字符串表示子表达式,也称为子模式。子表达式具有独立的匹配功能,保存独立的匹配结果;同时,小括号后的量词将会作用于整个子表达式。

    通过分组可以在一个完整的字符模式中定义一个或多个子模式。当正则表达式成功地匹配目标字符串后,也可以从目标字符串中抽出与子模式相匹配的子内容。

    示例

    在下面代码中,不仅能匹配出每个变量声明,同时还抽出每个变量及其值。

     
    1. var s = "ab=21, bc=45, cd=43";
    2. var r = /(\w+)=(\d*)/g;
    3. while (a = r.exec(s)) {
    4. console.log(a); //返回类似["ab=21","bc=45","cd=43"]三个数组
    5. }

    反向引用

    在字符模式中,后面的字符可以引用前面的子表达式。实现方法如下:

    \+ 数字

    数字指定了子表达式在字符模式中的顺序。如“\1”引用的是第 1 个子表达式,“\2”引用的是第 2 个子表达式。

    示例1

    在下面代码中,通过引用前面子表达式匹配的文本,实现成组匹配字符串。

     
    1. var s = "<h1>title<h1><p>text<p>";
    2. var r = /(<\/?\w+>)\1/g;
    3. var a = s.match(r); //返回数组["<h1>title<h1>","<p>text<p>"]


    由于子表达式可以相互嵌套,它们的顺序将根据左括号的顺序来确定。例如,下面示例定义匹配模式包含多个子表达式。

     
    1. var s = "abc";
    2. var r = /(a(b(c)))/;
    3. var a = s.match(r); //返回数组["abc","abc","bc","c"]

    在这个模式中,共产生了 3 个反向引用,第一个是“(a(b(c)))”,第二个是“(b(c))”,第三个是“(C)”。它们引用的匹配文本分别是字符串“abc”、“bc”和“c”。

    对子表达式的引用,是指引用前面子表达式所匹配的文本,而不是子表达式的匹配模式。如果要引用前面子表达式的匹配模式,则必须使用下面方式,只有这样才能够达到匹配目的。

     
    1. var s = "<h1>title</h1><p>text</p>";
    2. var r = /((<\/?\w+>).*(<\/?\w+>))/g;
    3. var a = s.match(r); //返回数组["<h1>title</h1>","<p>text</p>"]


    反向引用在开发中主要有以下几种常规用法。

    示例2

    在正则表达式对象的 test() 方法中,以及字符串对象的 match() 和 search() 等方法中使用。在这些方法中,反向引用的值可以从 RegExp() 构造函数中获得。

     
    1. var s = "abcdefghijklmn";
    2. var r = /(\w)(\w)(\w)/;
    3. r.test(s);
    4. console.log(RegExp.$1); //返回第1个子表达式匹配的字符a
    5. console.log(RegExp.$2); //返回第2个子表达式匹配的字符b
    6. console.log(RegExp.$3); //返回第3个子表达式匹配的字符c

    通过上面示例可以看到,正则表达式执行匹配检测后,所有子表达式匹配的文本都被分组存储在 RegExp() 构造函数的属性内,通过前缀符号$与正则表达式中子表达式的编号来引用这些临时属性。其中属性 $1 标识符指向第 1 个值引用,属性 $2 标识符指向第 2 个值引用。

    示例3

    可以直接在定义的字符模式中包含反向引用。这可以通过使用特殊转义序列(如 \1、\2 等)来实现。

     
    1. var s = "abcbcacba";
    2. var r = /(\w)(\w)(\w)\2\3\1\3\2\1/;
    3. var b = r.test(s); //验证正则表达式是否匹配该字符串
    4. console.log(b); //返回true

    在上面示例的正则表达式中,“\1”表示对第 1 个反向引用 (\w) 所匹配的字符 a 进行引用,“\2”表示对第 2 个反向引用 (\w) 所匹配的字符串 b 进行引用,“\3”表示对第 3 个反向引用 (\w) 所匹配的字符 c 进行引用。

    示例4

    可以在字符串对象的 replace() 方法中使用。通过使用特殊字符序列$1、$2、$3 等来实现。例如,在下面的示例中将颠倒相邻字母和数字的位置。

     
    1. var s = "aa11bb22c3d4e5f6";
    2. var r = /(\w+?)(\d+)/g;
    3. var b = s.replace(r,"$2$1");
    4. console.log(b); //返回字符串“aa11bb22c3 d4e5f6”

    在上面例子中,正则表达式包括两个分组,第 1 个分组匹配任意连续的字母,第 2 个分组匹配任意连续的数字。在 replace() 方法的第 2 个参数中,$1 表示对正则表达式中第 1 个子表达式匹配文本的引用,而 $2 表示对正则表达式中第 2 个子表达式匹配文本的引用,通过颠倒 $1 和 $2 标识符的位置,即可实现字符串的颠倒来替换原字符串。

    禁止引用

    反向引用会占用一定的系统资源,在较长的正则表达式中,反向引用会降低匹配速度。如果分组仅仅是为了方便操作,可以禁止反向引用。

    实现方法:在左括号的后面加上一个问号和冒号。

     
    1. var s1 = "abc";
    2. var r = /(?:\w*?)|(?:\d*?)/;
    3. var a = r.test(si);

    非引用型分组必须使用子表达式,但是又不希望存储无用的匹配信息,或者希望提高匹配速度来说,是非常重用的方法。

    展开全文
  • 本文介绍了js正则表达式,具体如下:1. 正则表达式规则1.1 普通字符字母、数字、汉字、下划线、以及后边章节中没有特殊定义的标点符号,都是"普通字符"。表达式中的普通字符,在匹配一个字符串的时候,匹配与之相同...

    本文介绍了js正则表达式,具体如下:

    1. 正则表达式规则

    1.1 普通字符

    字母、数字、汉字、下划线、以及后边章节中没有特殊定义的标点符号,都是"普通字符"。表达式中的普通字符,在匹配一个字符串的时候,匹配与之相同的一个字符。

    举例1:表达式 "c",在匹配字符串 "abcde" 时,匹配结果是:成功;匹配到的内容是:"c";匹配到的位置是:开始于2,结束于3。(注:下标从0开始还是从1开始,因当前编程语言的不同而可能不同)

    举例2:表达式 "bcd",在匹配字符串 "abcde" 时,匹配结果是:成功;匹配到的内容是:"bcd";匹配到的位置是:开始于1,结束于4。

    --------------------------------------------------------------------------------

    1.2 简单的转义字符

    一些不便书写的字符,采用在前面加 "/" 的方法。这些字符其实我们都已经熟知了。

    表达式

    可匹配

    /r, /n

    代表回车和换行符

    /t

    制表符

    //

    代表 "/" 本身

    还有其他一些在后边章节中有特殊用处的标点符号,在前面加 "/" 后,就代表该符号本身。比如:^, $ 都有特殊意义,如果要想匹配字符串中 "^" 和 "$" 字符,则表达式就需要写成 "/^" 和 "/$"。

    表达式

    可匹配

    /^

    匹配 ^ 符号本身

    /$

    匹配 $ 符号本身

    /.

    匹配小数点(.)本身

    这些转义字符的匹配方法与 "普通字符" 是类似的。也是匹配与之相同的一个字符。

    举例1:表达式 "/$d",在匹配字符串 "abc$de" 时,匹配结果是:成功;匹配到的内容是:"$d";匹配到的位置是:开始于3,结束于5。

    1.3 能够与 '多种字符' 匹配的表达式

    正则表达式中的一些表示方法,可以匹配 '多种字符' 其中的任意一个字符。比如,表达式 "/d" 可以匹配任意一个数字。虽然可以匹配其中任意字符,但是只能是一个,不是多个。这就好比玩扑克牌时候,大小王可以代替任意一张牌,但是只能代替一张牌。

    表达式

    可匹配

    /d

    任意一个数字,0~9 中的任意一个

    /w

    任意一个字母或数字或下划线,也就是 A~Z,a~z,0~9,_ 中任意一个

    /s

    包括空格、制表符、换页符等空白字符的其中任意一个

    .

    小数点可以匹配除了换行符(/n)以外的任意一个字符

    举例1:表达式 "/d/d",在匹配 "abc123" 时,匹配的结果是:成功;匹配到的内容是:"12";匹配到的位置是:开始于3,结束于5。

    举例2:表达式 "a./d",在匹配 "aaa100" 时,匹配的结果是:成功;匹配到的内容是:"aa1";匹配到的位置是:开始于1,结束于4。

    --------------------------------------------------------------------------------

    1.4 自定义能够匹配 '多种字符' 的表达式

    使用方括号 [ ] 包含一系列字符,能够匹配其中任意一个字符。用 [^ ] 包含一系列字符,则能够匹配其中字符之外的任意一个字符。同样的道理,虽然可以匹配其中任意一个,但是只能是一个,不是多个。

    表达式

    可匹配

    [ab5@]

    匹配 "a" 或 "b" 或 "5" 或 "@"

    [^abc]

    匹配 "a","b","c" 之外的任意一个字符

    [f-k]

    匹配 "f"~"k" 之间的任意一个字母

    [^A-F0-3]

    匹配 "A"~"F","0"~"3" 之外的任意一个字符

    举例1:表达式 "[bcd][bcd]" 匹配 "abc123" 时,匹配的结果是:成功;匹配到的内容是:"bc";匹配到的位置是:开始于1,结束于3。

    举例2:表达式 "[^abc]" 匹配 "abc123" 时,匹配的结果是:成功;匹配到的内容是:"1";匹配到的位置是:开始于3,结束于4。

    --------------------------------------------------------------------------------

    1.5 修饰匹配次数的特殊符号

    前面章节中讲到的表达式,无论是只能匹配一种字符的表达式,还是可以匹配多种字符其中任意一个的表达式,都只能匹配一次。如果使用表达式再加上修饰匹配次数的特殊符号,那么不用重复书写表达式就可以重复匹配。

    使用方法是:"次数修饰"放在"被修饰的表达式"后边。比如:"[bcd][bcd]" 可以写成 "[bcd]{2}"。

    举例1:表达式 "/d+/.?/d*" 在匹配 "It costs $12.5" 时,匹配的结果是:成功;匹配到的内容是:"12.5";匹配到的位置是:开始于10,结束于14。

    举例2:表达式 "Go{2,8}gle" 在匹配 "Ads by goooooogle" 时,匹配的结果是:成功;匹配到的内容是:"goooooogle";匹配到的位置是:开始于7,结束于17。

    --------------------------------------------------------------------------------

    1.6 其他一些代表抽象意义的特殊符号

    一些符号在表达式中代表抽象的特殊意义:

    表达式

    作用

    ^

    与字符串开始的地方匹配,不匹配任何字符

    $

    与字符串结束的地方匹配,不匹配任何字符

    /b

    匹配一个单词边界,也就是单词和空格之间的位置,不匹配任何字符

    进一步的文字说明仍然比较抽象,因此,举例帮助大家理解。

    举例1:表达式 "^aaa" 在匹配 "xxx aaa xxx" 时,匹配结果是:失败。因为 "^" 要求与字符串开始的地方匹配,因此,只有当 "aaa" 位于字符串的开头的时候,"^aaa" 才能匹配,比如:"aaa xxx xxx"。

    举例2:表达式 "aaa$" 在匹配 "xxx aaa xxx" 时,匹配结果是:失败。因为 "$" 要求与字符串结束的地方匹配,因此,只有当 "aaa" 位于字符串的结尾的时候,"aaa$" 才能匹配,比如:"xxx xxx aaa"。

    举例3:表达式 "./b." 在匹配 "@@@abc" 时,匹配结果是:成功;匹配到的内容是:"@a";匹配到的位置是:开始于2,结束于4。

    进一步说明:"/b" 与 "^" 和 "$" 类似,本身不匹配任何字符,但是它要求它在匹配结果中所处位置的左右两边,其中一边是 "/w" 范围,另一边是 非"/w" 的范围。

    举例4:表达式 "/bend/b" 在匹配 "weekend,endfor,end" 时,匹配结果是:成功;匹配到的内容是:"end";匹配到的位置是:开始于15,结束于18。

    一些符号可以影响表达式内部的子表达式之间的关系:

    表达式

    作用

    |

    左右两边表达式之间 "或" 关系,匹配左边或者右边

    ( )

    (1). 在被修饰匹配次数的时候,括号中的表达式可以作为整体被修饰

    (2). 取匹配结果的时候,括号中的表达式匹配到的内容可以被单独得到

    举例5:表达式 "Tom|Jack" 在匹配字符串 "I'm Tom, he is Jack" 时,匹配结果是:成功;匹配到的内容是:"Tom";匹配到的位置是:开始于4,结束于7。匹配下一个时,匹配结果是:成功;匹配到的内容是:"Jack";匹配到的位置时:开始于15,结束于19。

    举例6:表达式 "(go/s*)+" 在匹配 "Let's go go go!" 时,匹配结果是:成功;匹配到内容是:"go go go";匹配到的位置是:开始于6,结束于14。

    举例7:表达式 "¥(/d+/.?/d*)" 在匹配 "$10.9,¥20.5" 时,匹配的结果是:成功;匹配到的内容是:"¥20.5";匹配到的位置是:开始于6,结束于10。单独获取括号范围匹配到的内容是:"20.5"。

    --------------------------------------------------------------------------------

    2. 正则表达式中的一些高级规则

    2.1 匹配次数中的贪婪与非贪婪

    在使用修饰匹配次数的特殊符号时,有几种表示方法可以使同一个表达式能够匹配不同的次数,比如:"{m,n}", "{m,}", "?", "*", "+",具体匹配的次数随被匹配的字符串而定。这种重复匹配不定次数的表达式在匹配过程中,总是尽可能多的匹配。比如,针对文本 "dxxxdxxxd",举例如下:

    表达式

    匹配结果

    "/w+" 将匹配第一个 "d" 之后的所有字符 "xxxdxxxd"

    "/w+" 将匹配第一个 "d" 和最后一个 "d" 之间的所有字符 "xxxdxxx"。虽然 "/w+" 也能够匹配上最后一个 "d",但是为了使整个表达式匹配成功,"/w+" 可以 "让出" 它本来能够匹配的最后一个 "d"

    由此可见,"/w+" 在匹配的时候,总是尽可能多的匹配符合它规则的字符。虽然第二个举例中,它没有匹配最后一个 "d",但那也是为了让整个表达式能够匹配成功。同理,带 "*" 和 "{m,n}" 的表达式都是尽可能地多匹配,带 "?" 的表达式在可匹配可不匹配的时候,也是尽可能的 "要匹配"。这 种匹配原则就叫作 "贪婪" 模式 。

    非贪婪模式:

    在修饰匹配次数的特殊符号后再加上一个 "?" 号,则可以使匹配次数不定的表达式尽可能少的匹配,使可匹配可不匹配的表达式,尽可能的 "不匹配"。这种匹配原则叫作 "非贪婪" 模式,也叫作 "勉强" 模式。如果少匹配就会导致整个表达式匹配失败的时候,与贪婪模式类似,非贪婪模式会最小限度的再匹配一些,以使整个表达式匹配成功。举例如下,针对文本 "dxxxdxxxd" 举例:

    表达式

    匹配结果

    "/w+?" 将尽可能少的匹配第一个 "d" 之后的字符,结果是:"/w+?" 只匹配了一个 "x"

    为了让整个表达式匹配成功,"/w+?" 不得不匹配 "xxx" 才可以让后边的 "d" 匹配,从而使整个表达式匹配成功。因此,结果是:"/w+?" 匹配 "xxx"

    更多的情况,举例如下:

    举例1:表达式 "

    (.*)" 与字符串 "

    aa

    bb

    " 匹配时,匹配的结果是:成功;匹配到的内容是 "

    aa

    bb

    " 整个字符串, 表达式中的 "" 将与字符串中最后一个 "" 匹配。

    举例2:相比之下,表达式 "

    (.*?)" 匹配举例1中同样的字符串时,将只得到 "

    aa

    ", 再次匹配下一个时,可以得到第二个 "

    bb

    "。

    --------------------------------------------------------------------------------

    2.2 反向引用 /1, /2...

    表达式在匹配时,表达式引擎会将小括号 "( )" 包含的表达式所匹配到的字符串记录下来。在获取匹配结果的时候,小括号包含的表达式所匹配到的字符串可以单独获取。这一点,在前面的举例中,已经多次展示了。在实际应用场合中,当用某种边界来查找,而所要获取的内容又不包含边界时,必须使用小括号来指定所要的范围。比如前面的 "

    (.*?)"。

    其实,"小括号包含的表达式所匹配到的字符串" 不仅是在匹配结束后才可以使用,在匹配过程中也可以使用。表达式后边的部分,可以引用前面 "括号内的子匹配已经匹配到的字符串"。引用方法是 "/" 加上一个数字。"/1" 引用第1对括号内匹配到的字符串,"/2" 引用第2对括号内匹配到的字符串……以此类推,如果一对括号内包含另一对括号,则外层的括号先排序号。换句话说,哪一对的左括号 "(" 在前,那这一对就先排序号。

    举例如下:

    举例1:表达式 "('|")(.*?)(/1)" 在匹配 " 'Hello', "World" " 时,匹配结果是:成功;匹配到的内容是:" 'Hello' "。再次匹配下一个时,可以匹配到 " "World" "。

    举例2:表达式 "(/w)/1{4,}" 在匹配 "aa bbbb abcdefg ccccc 111121111 999999999" 时,匹配结果是:成功;匹配到的内容是 "ccccc"。再次匹配下一个时,将得到 999999999。这个表达式要求 "/w" 范围的字符至少重复5次,注意与 "/w{5,}" 之间的区别。

    举例3:表达式 ".*?/1>" 在匹配 "

    " 时,匹配结果是成功。如果 "" 与 "" 不配对,则会匹配失败;如果改成其他配对,也可以匹配成功。

    --------------------------------------------------------------------------------

    2.3 预搜索,不匹配;反向预搜索,不匹配

    前面的章节中,我讲到了几个代表抽象意义的特殊符号:"^","$","/b"。它们都有一个共同点,那就是:它们本身不匹配任何字符,只是对 "字符串的两头" 或者 "字符之间的缝隙" 附加了一个条件。理解到这个概念以后,本节将继续介绍另外一种对 "两头" 或者 "缝隙" 附加条件的,更加灵活的表示方法。

    正向预搜索:"(?=xxxxx)","(?!xxxxx)"

    格式:"(?=xxxxx)",在被匹配的字符串中,它对所处的 "缝隙" 或者 "两头" 附加的条件是:所在缝隙的右侧,必须能够匹配上 xxxxx 这部分的表达式。因为它只是在此作为这个缝隙上附加的条件,所以它并不影响后边的表达式去真正匹配这个缝隙之后的字符。这就类似 "/b",本身不匹配任何字符。"/b" 只是将所在缝隙之前、之后的字符取来进行了一下判断,不会影响后边的表达式来真正的匹配。

    举例1:表达式 "Windows (?=NT|XP)" 在匹配 "Windows 98, Windows NT, Windows 2000" 时,将只匹配 "Windows NT" 中的 "Windows ",其他的 "Windows " 字样则不被匹配。

    举例2:表达式 "(/w)((?=/1/1/1)(/1))+" 在匹配字符串 "aaa ffffff 999999999" 时,将可以匹配6个"f"的前4个,可以匹配9个"9"的前7个。这个表达式可以读解成:重复4次以上的字母数字,则匹配其剩下最后2位之前的部分。当然,这个表达式可以不这样写,在此的目的是作为演示之用。

    格式:"(?!xxxxx)",所在缝隙的右侧,必须不能匹配 xxxxx 这部分表达式。

    举例3:表达式 "((?!/bstop/b).)+" 在匹配 "fdjka ljfdl stop fjdsla fdj" 时,将从头一直匹配到 "stop" 之前的位置,如果字符串中没有 "stop",则匹配整个字符串。

    举例4:表达式 "do(?!/w)" 在匹配字符串 "done, do, dog" 时,只能匹配 "do"。在本条举例中,"do" 后边使用 "(?!/w)" 和使用 "/b" 效果是一样的。

    反向预搜索:"(?<=xxxxx)","(?

    这两种格式的概念和正向预搜索是类似的,反向预搜索要求的条件是:所在缝隙的 "左侧",两种格式分别要求必须能够匹配和必须不能够匹配指定表达式,而不是去判断右侧。与 "正向预搜索" 一样的是:它们都是对所在缝隙的一种附加条件,本身都不匹配任何字符。

    举例5:表达式 "(?<=/d{4})/d+(?=/d{4})" 在匹配 "1234567890123456" 时,将匹配除了前4个数字和后4个数字之外的中间8个数字。由于 JScript.RegExp 不支持反向预搜索,因此,本条举例不能够进行演示。很多其他的引擎可以支持反向预搜索,比如:Java 1.4 以上的 Java.util.regex 包,.NET 中System.Text.RegularExpressions 命名空间,以及本站推荐的最简单易用的 DEELX 正则引擎。

    --------------------------------------------------------------------------------

    3. 其他通用规则

    还有一些在各个正则表达式引擎之间比较通用的规则,在前面的讲解过程中没有提到。

    3.1 表达式中,可以使用 "/xXX" 和 "/uXXXX" 表示一个字符("X" 表示一个十六进制数)

    形式

    字符范围

    /xXX

    编号在 0 ~ 255 范围的字符,比如:空格可以使用 "/x20" 表示

    /uXXXX

    任何字符可以使用 "/u" 再加上其编号的4位十六进制数表示,比如:"/中"

    3.2 在表达式 "/s","/d","/w","/b" 表示特殊意义的同时,对应的大写字母表示相反的意义

    3.3 在表达式中有特殊意义,需要添加 "/" 才能匹配该字符本身的字符汇总

    字符

    说明

    ^

    匹配输入字符串的开始位置。要匹配 "^" 字符本身,请使用 "/^"

    $

    匹配输入字符串的结尾位置。要匹配 "$" 字符本身,请使用 "/$"

    ( )

    标记一个子表达式的开始和结束位置。要匹配小括号,请使用 "/(" 和 "/)"

    [ ]

    用来自定义能够匹配 '多种字符' 的表达式。要匹配中括号,请使用 "/[" 和 "/]"

    { }

    修饰匹配次数的符号。要匹配大括号,请使用 "/{" 和 "/}"

    .

    匹配除了换行符(/n)以外的任意一个字符。要匹配小数点本身,请使用 "/."

    ?

    修饰匹配次数为 0 次或 1 次。要匹配 "?" 字符本身,请使用 "/?"

    +

    修饰匹配次数为至少 1 次。要匹配 "+" 字符本身,请使用 "/+"

    *

    修饰匹配次数为 0 次或任意次。要匹配 "*" 字符本身,请使用 "/*"

    |

    左右两边表达式之间 "或" 关系。匹配 "|" 本身,请使用 "/|"

    3.4 括号 "( )" 内的子表达式,如果希望匹配结果不进行记录供以后使用,可以使用 "(?:xxxxx)" 格式

    举例1:表达式 "(?:(/w)/1)+" 匹配 "a bbccdd efg" 时,结果是 "bbccdd"。括号 "(?:)" 范围的匹配结果不进行记录,因此 "(/w)" 使用 "/1" 来引用。

    3.5 常用的表达式属性设置简介:Ignorecase,Singleline,Multiline,Global

    表达式属性

    说明

    Ignorecase

    默认情况下,表达式中的字母是要区分大小写的。配置为 Ignorecase 可使匹配时不区分大小写。有的表达式引擎,把 "大小写" 概念延伸至 UNICODE 范围的大小写。

    Singleline

    默认情况下,小数点 "." 匹配除了换行符(/n)以外的字符。配置为 Singleline 可使小数点可匹配包括换行符在内的所有字符。

    Multiline

    默认情况下,表达式 "^" 和 "$" 只匹配字符串的开始 ① 和结尾 ④ 位置。如:

    ①xxxxxxxxx②/n

    ③xxxxxxxxx④

    配置为 Multiline 可以使 "^" 匹配 ① 外,还可以匹配换行符之后,下一行开始前 ③ 的位置,使 "$" 匹配 ④ 外,还可以匹配换行符之前,一行结束 ② 的位置。

    Global

    主要在将表达式用来替换时起作用,配置为 Global 表示替换所有的匹配。

    --------------------------------------------------------------------------------

    4. 其他提示

    4.1 如果想要了解高级的正则引擎还支持那些复杂的正则语法,可参见本站 DEELX 正则引擎的说明文档。

    4.2 如果要要求表达式所匹配的内容是整个字符串,而不是从字符串中找一部分,那么可以在表达式的首尾使用 "^" 和 "$",比如:"^/d+$" 要求整个字符串只有数字。

    4.3 如果要求匹配的内容是一个完整的单词,而不会是单词的一部分,那么在表达式首尾使用 "/b",比如:使用 "/b(if|while|else|void|int……)/b" 来匹配程序中的关键字。

    4.4 表达式不要匹配空字符串。否则会一直得到匹配成功,而结果什么都没有匹配到。比如:准备写一个匹配 "123"、"123."、"123.5"、".5" 这几种形式的表达式时,整数、小数点、小数数字都可以省略,但是不要将表达式写成:"/d*/.?/d*",因为如果什么都没有,这个表达式也可以匹配成功。更好的写法是:"/d+/.?/d*|/./d+"。

    4.5 能匹配空字符串的子匹配不要循环无限次。如果括号内的子表达式中的每一部分都可以匹配 0 次,而这个括号整体又可以匹配无限次,那么情况可能比上一条所说的更严重,匹配过程中可能死循环。虽然现在有些正则表达式引擎已经通过办法避免了这种情况出现死循环了,比如 .NET 的正则表达式,但是我们仍然应该尽量避免出现这种情况。如果我们在写表达式时遇到了死循环,也可以从这一点入手,查找一下是否是本条所说的原因。

    4.6 合理选择贪婪模式与非贪婪模式,参见话题讨论。

    4.7 或 "|" 的左右两边,对某个字符最好只有一边可以匹配,这样,不会因为 "|" 两边的表达式因为交换位置而有所不同。

    ------------------------------------------------------------------------------------------

    1,定义正则表达式

    1)定义正则表达式有两种形式,一种是普通方式,一种是构造函数方式。

    2)普通方式:var reg=/表达式/附加参数

    表达式:一个字符串,代表了某种规则,其中可以使用某些特殊字符,来代表特殊的规则,后面会详细说明。

    附加参数:用来扩展表达式的含义,目前主要有三个参数:

    g:代表可以进行全局匹配。

    i:代表不区分大小写匹配。

    m:代表可以进行多行匹配。

    上面三个参数,可以任意组合,代表复合含义,当然也可以不加参数。

    例子:

    var reg=/a*b/;

    var reg=/abc+f/g;

    3)构造函数方式:var reg=new RegExp(“表达式”,”附加参数”);

    其中“表达式”与“附加参数”的含义与上面那种定义方式中的含义相同。

    例子:

    var reg=new RegExp(“a*b”);

    var reg=new RegExp(“abc+f”,”g”);

    4)普通方式与构造函数方式的区别

    普通方式中的表达式必须是一个常量字符串,而构造函数中的表达式可以是常量字符串,也可以是一个js变量,例如根据用户的输入来作为表达式参数等等:

    var reg=new RegExp(document.forms[0].exprfiled.value,”g”);

    2,表达式模式

    1)表达式模式,是指表达式的表达方式与样式, 即 var reg=/表达式/附加参数 中的“表达式”怎样去描述?

    2)从规范上讲,表达式模式分为简单模式和复合模式。

    3)简单模式:是指通过普通字符的组合来表达的模式,例如

    var reg=/abc0d/;

    可见简单模式只能表示具体的匹配。

    4)复合模式:是指含有通配符来表达的模式,例如:

    var reg=/a+b?/w/;

    其中的+、?和/w都属于通配符,代表着特殊的含义。因此复合模式可以表达更为抽象化的逻辑。

    下面我们着重说一下复合模式中各个通配符的含义及其使用。

    5)复合模式中特殊字符的讲解:

    1>/:在许多编程语言里面被用作转义符,一般来说

    /符号后面如果跟的是普通字符c,那么/c就代表特殊的含义,例如n本来代表字符n,但/n就代表换行。

    /符号后面如果跟的是特殊字符c,那么/c就代表普通字符c,例如/一般用作转义符,但//则调表普通字符/。

    JavaScript的正则表达式中/的用法与上面相同,只是不同的编程语言,特殊字符表可能不太一样罢了。

    2>^:匹配输入字符串的起始端,如果是多行匹配,即表达式的附加参数中含有m,则也在一个换行符后匹配。

    例子:/^B/匹配 “Bab Bc ”中的第一个B

    例子2:/^B/gm匹配

    “Badd B

    cdaf

    B dsfB”

    中的第一行第一个B,第三行中的第一个B

    3>$:匹配输入字符创的尾端,如果是多行匹配,即表达式的附加参数中含有m,则也在一个换行符前匹配。

    与^的用法相反。

    例子:/t$/匹配“bat”中的t,但是不匹配“hate”中的t

    例子2:/t$/匹配

    “tag at

    bat”

    中第一行的最后一个t和第二行的t。

    4>*:匹配前一个字符0次或多次。

    例子:/ab*/匹配“dddabbbbc”中的“abbbb”,也匹配“ddda”中的“a”

    5>+:匹配前一个字符1次或多次。

    例子:/ab+/匹配“dddabbbbc”中的“abbbb”,但不匹配“ddda”

    与后面的{1,}(原型:{n,})的用法类似

    6>?:?的用法比较特殊,一般来说它用来对前一个字符做0次或1次匹配,但是它有另外两种特殊的用法:

    如果紧跟在*、+、?和{ }之后,则表示原始匹配的最小次数匹配,例如:

    /ba*/本来匹配“bbbaaaa”中的“baaaa”,但是/ba*?/则匹配“bbbaaaa”中的“b”(因为*表示0次或多次匹配,而加?应该表示最少次数匹配,即0次匹配)。

    同理:/ba+?/则匹配“baaaa”中的“ba”。

    作为语法结构符号,使用于前置断言中,即后面要说到的x(?=y)和x(?!=y)

    7>.:小数点中的“.”号,匹配任何一个单独的字符,但是换行符除外。

    标准中总共有哪些字符?请参考:字符集

    例如:/a.b/匹配“acbaa”中的“acb”,但是不匹配“abbb”。

    8>(x):表示匹配x(并非特指字符x或者特指一个字符,x表示一个字符串),而且匹配会被记住,在语法中这种()被称为“capturing parentheses ”,即捕捉用的小括号。

    匹配会被记住,是因为在表达式提供的函数中,有些函数返回一个数组,该数组会保存所匹配的所有字符串,例如exec()函数。

    另外还要注意()中的x被记住的前提是匹配x。

    例子1:

    var regx=/a(b)c/;

    var rs=regx.exec(“abcddd”);

    从上面可以看出,/a(b)c/匹配“abcddd”中的“abc”,因为()的原因,b也会记录下来,因此rs返回的数字内容为:{abc,b}

    例子2:

    var regx=/a(b)c/;

    var rs=regx.exec(“acbcddd”);

    rs返回null,因为/a(b)c/不匹配“acbcddd”,所以()中的b不会被记录下来(尽管字符串中含有b)

    9>(?:x):匹配x,但不会记住x,这种格式中的()被称为“non-capturing parentheses ”,即非捕捉用的小括号。

    例子:

    var regx=/a(?:b)c/;

    var rs=regx.exec(“abcddd”);

    从上面可以看出,/a(?:b)c/匹配“abcddd”中的“abc”,因为(?:)的原因,b不会记录下来,因此rs返回的数字内容为:

    {abc}

    10>X(?=y):匹配x,仅当后面紧跟着y时。如果符合匹配,则只有x会被记住,y不会被记住。

    例子:

    var regx=/user(?=name)/;

    var rs=regx.exec(“The username is Mary”);

    结果:匹配成功,而且rs的值为{user}

    11>X(?!y):匹配x,仅当后面不紧跟着y时。如果符合匹配,则只有x会被记住,y不会被记住。

    例子:

    var regx=/user(?!name)/;

    var rs=regx.exec(“The user name is Mary”);

    结果:匹配成功,而且rs的值为{user}

    例子2:

    var regx=//d+(?!/.)/;

    var rs=regx.exec(“54.235”);

    结果:匹配成果,rs的值为{5},不匹配54是因为54后面跟着“.”号,当然235也匹配,但是由于exec方法的行为,235不会被返回

    12>x|y:匹配x或y。注意如果x和y都匹配上了,那么只记住x。

    例子:

    var regx=/beijing|shanghai/;

    var rs=regx.exec(“I love beijing and shanghai”);

    结果:匹配成功,rs的值为{beijing},虽然shanghai也匹配,但不会被记住。

    13>{n}:匹配前一个字符的n次出现。

    n必须是一个非负数,当然如果是一个负数或小数也不会报语法错误。

    例子:

    var regx=/ab{2}c/;

    var rs=regx.exec(“abbcd”);

    结果:匹配成功,rs的值为:{abbc}。

    14>{n,}:匹配前一个字符的至少n次出现。

    例子:

    var regx=/ab{2,}c/;

    var rs=regx.exec(“abbcdabbbc”);

    结果:匹配成功,rs的值为:{abbc}。注意为什么abbbc也符合条件为什么没有被记住,这与exec方法的行为有关,后面会统一讲解。

    15>{n,m}:匹配前一个字符的至少n次最多m次的出现。

    只要n与m为数字,而且m>=n就不会报语法错误。

    例子:

    var regx=/ab{2,5}c/;

    var rs=regx.exec(“abbbcd”);

    结果:匹配成功,rs的值为:{abbbc}。

    例子2:

    var regx=/ab{2,2}c/;

    var rs=regx.exec(“abbcd”);

    结果:匹配成功,rs的值为:{abbc}。

    例子3:

    var regx=/ab(2,5)/;

    var rs=regx.exec(“abbbbbbbbbb”);

    结果:匹配成功,rs的值为:{abbbbb},这说明,如果前一个字符出现多于m次,则只匹配m次。另外:

    var regx=/ab(2,5)c/;

    var rs=regx.exec(“abbbbbbbbbbc”);

    结果:匹配失败,rs的值为:null,为什么匹配失败,因为b多于5个则b(2,5)会匹配前5个b,,而表达式/ab(2,5)c/中b后面是c,但字符串中5个b之后还是b所以会报错。

    16>[xyz]:xyz表示一个字符串,该模式表示匹配[]中的一个字符,形式上[xyz]等同于[x-z]。

    例子:

    var regx=/a[bc]d/;

    var rs=regx.exec(“abddgg”);

    结果:匹配成功,rs的值为:{abd}

    例子2:

    var regx=/a[bc]d/;

    var rs=regx.exec(“abcd”);

    结果:匹配失败,rs的值为:null,之所以失败,是因为[bc]表示匹配b或c中的一个,但不会同时匹配。

    17>[^xyz]:该模式表示匹配非[]中的一个字符,形式上[^xyz]等同于[^x-z]。

    例子:

    var regx=/a[^bc]d/;

    var rs=regx.exec(“afddgg”);

    结果:匹配成功,rs的值为:{afd}

    例子2:

    var regx=/a[^bc]d/;

    var rs=regx.exec(“abd”);

    结果:匹配失败,rs的值为:。

    18>[/b]:匹配退格键。

    19>/b:匹配一个词的边界符,例如空格和换行符等等,当然匹配换行符时,表达式应该附加参数m。

    例子:

    var regx=//bc./;

    var rs=regx.exec(“Beijing is a beautiful city”);

    结果:匹配成功,rs的值为:{ci},注意c前边的空格不会匹配到结果中,即{ ci}是不正确的。

    20>/B:代表一个非单词边界。

    例子:

    var regx=//Bi./;

    var rs=regx.exec(“Beijing is a beautiful city”);

    结果:匹配成功,rs的值为:{ij},即匹配了Beijing中的ij。

    21>/cX,匹配一个控制字符。例如, /cM 匹配一个 Control-M 或 回车符。 x 的值必须为 A-Z 或 a-z 之一。否则,将 c 视为一 个原义的 'c' 字符。(实际的例子还需补充)

    21>/d:匹配一个数字字符,等同于[0-9]。

    例子:

    var regx=/user/d/;

    var rs=regx.exec(“user1”);

    结果:匹配成功,rs的值为:{user1}

    22>/D:匹配一个非数字字符,等同于[^0-9]。

    例子:

    var regx=/user/D/;

    var rs=regx.exec(“userA”);

    结果:匹配成功,rs的值为:{userA}

    23>/f:匹配一个换页符。

    24>/n:匹配一个换行符。因为是换行符,所以在表达式中要加入m参数。

    例子:

    var regx=/a/nbc/m;

    var str=“a

    bc”;

    var rs=regx.exec(str);

    结果:匹配成功,rs的值为:{ },如果表达式为/a/n/rbc/,则不会被匹配,因此在一般的编辑器中一个”Enter”键代表着“回车换行”,而非“换行回车”,至少在textarea域中是这样的。

    25>/r:匹配一个回车符

    26>/s:匹配一个空格符,等同于[ /f/n/r/t/v/u00A0/u2028/u2029].

    例子:

    var regx=//si/;

    var rs=regx.exec(“Beijing is a city”);

    结果:匹配成功,rs的值为:{ i}

    27>/S:匹配一个非空格符,等同于[ ^/f/n/r/t/v/u00A0/u2028/u2029].

    例子:

    var regx=//Si/;

    var rs=regx.exec(“Beijing is a city”);

    结果:匹配成功,rs的值为:{ei}

    28>/t:匹配一个tab

    例子:

    var regx=/a/tb/;

    var rs=regx.exec(“a bc”);

    结果:匹配成功,rs的值为: {a       bc}

    29>/v:匹配一个竖向的tab

    30>/w:匹配一个数字、_或字母表字符,即[A-Za-z0-9_ ]。

    例子:

    var regx=//w/;

    var rs=regx.exec(“$25.23”);

    结果:匹配成功,rs的值为:{2}

    31>/W:匹配一个非数字、_或字母表字符,即[^A-Za-z0-9_ ]。

    例子:

    var regx=//w/;

    var rs=regx.exec(“$25.23”);

    结果:匹配成功,rs的值为:{$}

    32>/n:注意不是/n,这里n是一个正整数,表示匹配第n个()中的字符。

    例子:

    var regx=/user([,-])group/1role/;

    var rs=regx.exec(“user-group-role”);

    结果:匹配成功,rs的值为:{user-group-role,-},同样对user,group,role的匹配也是成功的,但像user-group,role等就不对了。

    33>/0:匹配一个NUL字符。

    34>/xhh:匹配一个由两位16进制数字所表达的字符。

    35>/uhhhh:匹配一个由四位16进制数字所表达的字符。

    3,表达式操作

    1)表达式操作,在这里是指和表达式相关的方法,我们将介绍六个方法。

    2)表达式对象(RegExp)方法:

    1>exec(str),返回str中与表达式相匹配的第一个字符串,而且以数组的形式表现,当然如果表达式中含有捕捉用的小括号,则返回的数组中也可能含有()中的匹配字符串,例如:

    var regx=//d+/;

    var rs=regx.exec(“3432ddf53”);

    返回的rs值为:{3432}

    var regx2=new RegExp(“ab(/d+)c”);

    var rs2=regx2.exec(“ab234c44”);

    返回的rs值为:{ab234c,234}

    另外,如果有多个合适的匹配,则第一次执行exec返回一个第一个匹配,此时继续执行exec,则依次返回第二个第三个匹配。例如:

    var regx=/user/d/g;

    var rs=regx.exec(“ddduser1dsfuser2dd”);

    var rs1=regx.exec(“ddduser1dsfuser2dd”);

    则rs的值为{user1},rs的值为{rs2},当然注意regx中的g参数是必须的,否则无论exec执行多少次,都返回第一个匹配。后面还有相关内容涉及到对此想象的解释。

    2>test(str),判断字符串str是否匹配表达式,返回一个布尔值。例如:

    var regx=/user/d+/g;

    var flag=regx.test(“user12dd”);

    flag的值为true。

    3)String对象方法

    1>match(expr),返回与expr相匹配的一个字符串数组,如果没有加参数g,则返回第一个匹配,加入参数g则返回所有的匹配

    例子:

    var regx=/user/d/g;

    var str=“user13userddduser345”;

    var rs=str.match(regx);

    rs的值为:{user1,user3}

    2>search(expr),返回字符串中与expr相匹配的第一个匹配的index值。

    例子:

    var regx=/user/d/g;

    var str=“user13userddduser345”;

    var rs=str.search(regx);

    rs的值为:0

    3>replace(expr,str),将字符串中匹配expr的部分替换为str。另外在replace方法中,str中可以含有一种变量符号$,格式为$n,代表匹配中被记住的第n的匹配字符串(注意小括号可以记忆匹配)。

    例子:

    var regx=/user/d/g;

    var str=“user13userddduser345”;

    var rs=str.replace(regx,”00”);

    rs的值为:003userddd0045

    例子2:

    var regx=/u(se)r/d/g;

    var str=“user13userddduser345”;

    var rs=str.replace(regx,”$1”);

    rs的值为:se3userdddse45

    对于replace(expr,str)方法还要特别注意一点,如果expr是一个表达式对象则会进行全局替换(此时表达式必须附加参数g,否则也只是替换第一个匹配),如果expr是一个字符串对象,则只会替换第一个匹配的部分,例如:

    var regx=“user”

    var str=“user13userddduser345”;

    var rs=str.replace(regx,”00”);

    rs的值为: 0013userddduser345

    4>split(expr),将字符串以匹配expr的部分做分割,返回一个数组,而且表达式是否附加参数g都没有关系,结果是一样的。

    例子:

    var regx=/user/d/g;

    var str=“user13userddduser345”;

    var rs=str.split(regx);

    rs的值为:{3userddd,45}

    4,表达式相关属性

    1)表达式相关属性,是指和表达式相关的属性,如下面的形式:

    var regx=/myexpr/;

    var rs=regx.exec(str);

    其中,和表达式自身regx相关的属性有两个,和表达式匹配结果rs相关的属性有三个,下面将逐一介绍。

    2)和表达式自身相关的两个属性:

    1>lastIndex,返回开始下一个匹配的位置,注意必须是全局匹配(表达式中带有g参数)时,lastIndex才会有不断返回下一个匹配值,否则该值为总是返回第一个下一个匹配位置,例如:

    var regx=/user/d/;

    var rs=regx.exec(“sdsfuser1dfsfuser2”);

    var lastIndex1=regx.lastIndex;

    rs=regx.exec(“sdsfuser1dfsfuser2”);

    var lastIndex2=regx.lastIndex;

    rs=regx.exec(“sdsfuser1dfsfuser2”);

    var lastIndex3=regx.lastIndex;

    上面lastIndex1为9,第二个lastIndex2也为9,第三个也是9;如果regx=/user/d/g,则第一个为9,第二个为18,第三个为0。

    2>source,返回表达式字符串自身。例如:

    var regx=/user/d/;

    var rs=regx.exec(“sdsfuser1dfsfuser2”);

    var source=regx.source;

    source的值为user/d

    3)和匹配结果相关的三个属性:

    1>index,返回当前匹配的位置。例如:

    var regx=/user/d/;

    var rs=regx.exec(“sdsfuser1dfsfuser2”);

    var index1=rs.index;

    rs=regx.exec(“sdsfuser1dfsfuser2”);

    var index2=rs.index;

    rs=regx.exec(“sdsfuser1dfsfuser2”);

    var index3=rs.index;

    index1为4,index2为4,index3为4,如果表达式加入参数g,则index1为4,index2为13,index3会报错(index为空或不是对象)。

    2>input,用于匹配的字符串。例如:

    var regx=/user/d/;

    var rs=regx.exec(“sdsfuser1dfsfuser2”);

    var input=rs.input;

    input的值为sdsfuser1dfsfuser2。

    3>[0],返回匹配结果中的第一个匹配值,对于match而言可能返回一个多值的数字,则除了[0]外,还可以取[1]、[2]等等。例如:

    var regx=/user/d/;

    var rs=regx.exec(“sdsfuser1dfsfuser2”);

    var value1=rs[0];

    rs=regx.exec(“sdsfuser1dfsfuser2”);

    var value2=rs[0];

    value1的值为user1,value2的值为user2

    5,实际应用

    1)实际应用一

    描述:有一表单,其中有一个“用户名”input域

    要求:汉字,而且不能少于2个汉字,不能多于4个汉字。

    实现:

    function checkForm(obj){

    var username=obj.username.value;

    var regx=/^[/u4e00-/u9fa5]{2,4}$/g

    if(!regx.test(username)){

    alert(“Invalid username!”);

    return false;

    }

    return true;

    }

    2)实际应用二

    描述:给定一个含有html标记的字符串,要求将其中的html标记去掉。

    实现:

    function toPlainText(htmlStr){

    var regx=/]*>|/[^>]*>/gm;

    var str=htmlStr.replace(regx,"");

    return str;

    }

    三,小结

    1,Javascript正则表达式,我想在一般的程序员之中,使用者应该不是很多,因为我们处理的页面一般都不是很复杂,而复杂的逻辑一般我们都在后台处理完成了。但是目前趋势已经出现了扭转,富客户端已经被越来越多的人接受,而Javascript就是其中的关键技术,对于复杂的客户端逻辑而言,正则表达式的作用也是很关键的,同时它也是Javascript高手必须要掌握的重要技术之一。

    2,为了能够便于大家对前面讲述的内容有一个更为综合和深刻的认识,我将前面的一些关键点和容易犯糊涂的地方再系统总结一下,这部分很关键!

    总结1:附件参数g的用法

    表达式加上参数g之后,表明可以进行全局匹配,注意这里“可以”的含义。我们详细叙述:

    1)对于表达式对象的exec方法,不加入g,则只返回第一个匹配,无论执行多少次均是如此,如果加入g,则第一次执行也返回第一个匹配,再执行返回第二个匹配,依次类推。例如

    var regx=/user/d/;

    var str=“user18dsdfuser2dsfsd”;

    var rs=regx.exec(str);//此时rs的值为{user1}

    var rs2=regx.exec(str);//此时rs的值依然为{user1}

    如果regx=/user/d/g;则rs的值为{user1},rs2的值为{user2}

    通过这个例子说明:对于exec方法,表达式加入了g,并不是说执行exec方法就可以返回所有的匹配,而是说加入了g之后,我可以通过某种方式得到所有的匹配,这里的“方式”对于exec而言,就是依次执行这个方法即可。

    2)对于表达式对象的test方法,加入g于不加上g没有什么区别。

    3)对于String对象的match方法,不加入g,也只是返回第一个匹配,一直执行match方法也总是返回第一个匹配,加入g,则一次返回所有的匹配(注意这与表达式对象的exec方法不同,对于exec而言,表达式即使加上了g,也不会一次返回所有的匹配)。例如:

    var regx=/user/d/;

    var str=“user1sdfsffuser2dfsdf”;

    var rs=str.match(regx);//此时rs的值为{user1}

    var rs2=str.match(regx);//此时rs的值依然为{user1}

    如果regx=/user/d/g,则rs的值为{user1,user2},rs2的值也为{user1,user2}

    4)对于String对象的replace方法,表达式不加入g,则只替换第一个匹配,如果加入g,则替换所有匹配。(开头的三道测试题能很好的说明这一点)

    5)对于String对象的split方法,加上g与不加g是一样的,即:

    var sep=/user/d/;

    var array=“user1dfsfuser2dfsf”.split(sep);

    则array的值为{dfsf, dfsf}

    此时sep=/user/d/g,返回值是一样的。

    6)对于String对象的search方法,加不加g也是一样的。

    总结2:附加参数m的用法

    附加参数m,表明可以进行多行匹配,但是这个只有当使用^和$模式时才会起作用,在其他的模式中,加不加入m都可以进行多行匹配(其实说多行的字符串也是一个普通字符串),我们举例说明这一点

    1)使用^的例子

    var regx=/^b./g;

    var str=“bd76 dfsdf

    sdfsdfs dffs

    b76dsf sdfsdf”;

    var rs=str.match(regx);

    此时加入g和不加入g,都只返回第一个匹配{bd},如果regx=/^b./gm,则返回所有的匹配{bd,b7},注意如果regx=/^b./m,则也只返回第一个匹配。所以,加入m表明可以进行多行匹配,加入g表明可以进行全局匹配,综合到一起就是可以进行多行全局匹配

    2)使用其他模式的例子,例如

    var regx=/user/d/;

    var str=“sdfsfsdfsdf

    sdfsuser3 dffs

    b76dsf user6”;

    var rs=str.match(regx);

    此时不加参数g,则返回{user3},加入参数g返回{user3,user6},加不加入m对此没有影响。

    3)因此对于m我们要清楚它的使用,记住它只对^和$模式起作用,在这两种模式中,m的作用为:如果不加入m,则只能在第一行进行匹配,如果加入m则可以在所有的行进行匹配。我们再看一个^的例子

    var regx=/^b./;

    var str=“ret76 dfsdf

    bjfsdfs dffs

    b76dsf sdfsdf”;

    var rs=str.match(regx);

    此时rs的值为null,如果加入g,rs的值仍然为null,如果加入m,则rs的值为{bj}(也就是说,在第一行没有找到匹配,因为有参数m,所以可以继续去下面的行去找是否有匹配),如果m和g都加上,则返回{bj,b7}(只加m不加g说明,可以去多行进行匹配,但是找到一个匹配后就返回,加入g表明将多行中所有的匹配返回,当然对于match方法是如此,对于exec呢,则需要执行多次才能依次返回)

    总结3:在HTML的textarea输入域中,按一个Enter键,对应的控制字符为“/r/n”,即“回车换行”,而不是“/n/r”,即“换行回车”,我们看一个前面我们举过的例子:

    var regx=/a/r/nbc/;

    var str=“a

    bc”;

    var rs=regx.exec(str);

    结果:匹配成功,rs的值为:{      },如果表达式为/a/n/rbc/,则不会被匹配,因此在一般的编辑器中一个”Enter”键代表着“回车换行”,而非“换行回车”,至少在textarea域中是这样的。

    以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持脚本之家。

    展开全文
  • 1.正则表达式基本语法两个特殊的符号'^'和'$'。他们的作用是分别指出一个字符串的开始和结束。例子如下:"^The":表示所有以"The"开始的字符串("There","The cat"等);"of despair$":表示所以以"of despair"结尾的...
  • 正则啊,就像一座灯塔,当你在字符串的海洋...—— 节选自 Stinson 同学的语文排比句练习《正则》欣赏了一段文学节选后,我们正式来梳理一遍JS中的正则,本文的首要目的是,防止我经常忘记正则的一些用法,故梳理和...
  • 一、JavaScript正则表达式正则表达式(英语:Regular Expression,在代码中常简写为regex、regexp或RE)使用单个字符串来描述、匹配一系列符合某个句法规则的字符串搜索模式。搜索模式可用于文本搜索和文本替换。什么...
  • 允许的话要再加上A-Z,所以你可以改这样试试:"^[0-9]+[a-zA-Z]+[0-9]+$"如何用正则表达式表达以数字开头的字符串\b\d\S+用js正则表达式检测电话号码,要求,必须是1开头,只能是数字,并且是11位数字,这儿正则...
  • I am aware that regEx are common across languages...But I am having trouble in writing the Java syntax.I have a regular expression coded in JS as;if((/[a-zA-Z]/).test(str) && (/[0-9]|[\x21-\x2...
  • JS正则表达式语法

    2021-05-20 18:19:03
    JS正则表达式语法 元字符 就是拥有特动功能的特殊字符,大部分需要加反斜杠进行标识,以便于普通字符进行区别,而少数元字符,需要加反斜杠,以便转译为普通字符使用。 边界量词 例如: //下面代码演示如何使用...
  • 相关阅读:正则表达式语法一个正则表达式就是由普通字符(例如字符 a 到 z)以及特殊字符(称为元字符)组成的文字模式。该模式描述在查找文字主体时待匹配的一个或多个字符串。正则表达式作为一个模板,将某个字符模式...
  • JavaScript-正则表达式语法规则 一、正则表达式初识 1.什么是正则表达式 正则表达式是由一个字符序列形成的搜索模式,搜索模式可用于文本搜索和文本替换。 2.创建正则表达式 JS正则表达式的创建有两种方式: new ...
  • JavaScript正则表达式

    2021-08-08 15:58:43
    正则表达式:又称规则表达式 英文名为Regular Expression,在代码中常简写为regex、RegExp或RE 正则表达式用于定义一些字符串...语法: var 变量=new RegExp("正则表达式","匹配模式"); 使用typeof检查正则对象...
  • 判断数字的正则表达式:/^\d+$/ //非负整数(正整数 + 0)/^[0-9]*[1-9][0-9]*$/ //正整数/^((-\d+)|(0+))$/ //非正整数(负整数 + 0)/^-[0-9]*[1-9][0-9]*$/ //负整数/^-?\d+$/ //整数/^\d+(\.\d+)?$/ ...
  • /(^\$\{)([A-Za-z | _])+(\}$)/.test('${params_abc}');
  • 正则表达式 1. 什么是正则表达式? 百度百科提供的概念是这样的:正则表达式,又称规则表达式**。**(英语:Regular Expression,在代码中常简写为regex、regexp或RE),计算机科学的一个概念。其通常被用来检索、...
  • JavaScript正则表达式 什么是正则表达式? 正则表达式是构成搜索模式(search pattern)的字符序列。 当您搜索文本中的数据时,您可使用搜索模式来描述您搜索的内容。 正则表达式可以是单字符,或者更复杂的模式...
  • 1.什么是正则表达式 2.如何使用正则表达式 3.获取正则对象 4.字符类别 5.字符集合 6.字符限定 7.括号字符 8.正则运算优先级 什么是正则表达式? Regular Expression,简称RegExp,是一种描述字符串结构的...
  • 正则表达式是用于匹配字符串中字符组合的模式。在 JavaScript中,正则表达式也是...本章介绍 JavaScript正则表达式。1、验证帐号是否合法验证规则:字母、数字、下划线组成,字母开头,4-16位。function checkUser...
  • 1.正则表达式基本语法 两个特殊的符号’^‘和’$’。他们的作用是分别指出一个字符串的开始和结束。 例子如下: "^The":表示所有以"The"开始的字符串("There","The cat"等); "of despair$":表示所以以"of ...
  • var regular = new RegExp(/这里是正则表达式/);if (regular.test(str)) {console.log("符合条件");} else {console.log("不符合条件");}//或者var str = "待验证文本";if (/这里是正则表达式/.test(str)) {c...
  • public static boolean checkPassword(String input) { // 8-20 位,字母、数字、英文... } 还有一些好用的网站: 在线正则表达式测试 用户名和密码的正则表达式验证 java正则表达式匹配所有数字,包括带小数点的数字
  • 在前端开发过程中,通过使用JS正则表达式来校验输入的邮箱或者手机号是否正确,这也是一个非常常见的业务情景需求。尤其是在登录注册场景和有关提交邮箱和手机号相关的时候,一定需要做输入校验,这是正常开发所...
  • 文章目录一、参考资料二、语法介绍创建正则表达式没有标志的搜索有标志的高级搜索特殊字符RegExp API 介绍regexObj.test(str)regexObj.exec(str)三、分组匹配(正则表达式中有括号)规则说明分组匹配分组不匹配四、...
  • Java正则表达式详解

    2020-12-21 09:06:11
    如果你曾经用过Perl或任何其他内建正则表达式支持的语言,你一定知道用正则表达式...许多语言,包括Perl、PHP、Python、JavaScript和JScript,都支持用正则表达式处理文本,一些文本编辑器用正则表达式实现高级“搜...
  • JS正则表达式-语法

    2021-03-18 11:47:01
    正则表达式结构 正则表达式结构分为2大类:字符直接量和元字符 字符直接量: 字母和数字 == 自身(也就是说数字就是数字,字母就是字母),\n 换行符 ,\t 制表符,\r 回车符 , \f 换页符 元字符:正则表达式中有许多...
  • 此外,JavaScript这种客户端的脚本语言也提供了对正则表达式的支持,现在正则表达式已经成为了一个通用的概念和工具,被各类技术人员所广泛使用。 在某个Linux网站上面有这样的话:"如果你问一下Linux爱好者最喜欢...
  • 今天我们通过实现用户注册页面验证来学习js当中的正则表达式的构造1.题目:正则表达式实现用户注册页面验证 。在各文本框中输入信息,在文本框失去焦点时,验证信息,如果输入的信息部满足要求,则提示信息输入有误...
  • 3正则表达式3

    2021-03-17 17:40:27
    Java基础--常用正则匹配符号(必背,必须背,死都要背)1、字母:匹配单个字母(1)A:表示匹配字母A;(2)\\:匹配转义字符“\”;(3)\t:匹配转义字符“\t”;(4):匹配转义字符“”;2、一组字符:任意匹配里面的一个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 74,276
精华内容 29,710
关键字:

js正则表达式语法