各种工具之正则表达式语法比较

在各种常用的工具中,
正则表达式如此的相似却又不同。
下表列出了一些常用的正则表达式,以及其不同之处。
项目总多,遗漏必有不少,请各位看官不吝指出。
以perl的正则为基准,不同的用法以粉红色标出。

 

grep 2.5.1 egrep 2.5.1 sed 3.02
sed 4.07
awk 3.1.1 perl 5.8.0 vim 6.1 JavaScript   
转义 \ \ \ \ \ \ \
行头 ^ ^ ^ ^ ^ ^ ^
行尾 $ $ $ $ $ $ $
n个 {n} {m,n} {m,} {,n} \{n\} {n} \{n\} {n}或\{n\} 仅定义 –posix 或 –re-interval有效(要表达}和{,得用\\{和\\} 没有定义–posix或–re-interval时,不能用{n}的语法, \}\{和}{同义 {n} \{n\} {n}
{0,} * * * *或\*, (要表达*,得用\\*) * * *
{1,} \+ + \+ +或\+, (要表达+, 得用\\+) + \+ +
{0,1}    或\ , (要表达 , 得用\\ )    
任意字符 . . . . 含\n. . /s修饰后则含\n . 除\n . 除\n
(pat) 匹配并获结果 \(pat\) (pat) \(pat\) (pat)或\(pat\) (要表达括号,用\\( \\) ) (pat) \(pat\) (pat)
( :pat) 匹配但不获结果 不支持 不支持 不支持 不支持 ( :pat) 不支持 ( :pat)
( =pat) 等于预查 不支持 不支持 不支持 不支持 ( =pat) 不支持 ( =pat)
( !pat) 不等预查 不支持 不支持 不支持 不支持 ( !pat) 不支持 ( !pat)
| 或 \| | \| |或\| (要表达|,得用\\|) | \| |
其中任意字符 [xyz] [xyz] [xyz] [xyz] [xyz] [xyz] [xyz]
[.ch.] [=ch=] 不支持 不支持 [.ch.] 不支持 不支持 不支持 不支持
单词边界 \b \b \b \b 不支持 \b 不支持 \b
非单词边界 \B \B \B \B 不支持 \B 不支持 \B
单词左右边界 <> \< \> \< \> \< \> 不支持 (><和\>\<和\\>\\<同义 不支持(><和\>\<同义 \< \> 不支持(><和\>\<同义
控制字符 /cx 不支持 不支持 \cx 不支持 \cx 不支持 \cx
数字\d 不支持 不支持 不支持 不支持 \d \d \d
非数字\D 不支持 不支持 不支持 不支持 \D \D \D
换页 \f 不支持 不支持 高版本支持 \f \f 另义 \f表示文件名字符 \f
换行 \n 不支持 不支持 不支持 \n \n \n \n
回车 \r 不支持 不支持 \r \r \r \r \r
空白 \s 不支持 不支持 不支持 不支持 \s \s \s
非空白 \S 不支持 不支持 不支持 不支持 \S \S \S
制表符 \t 不支持 不支持 高版本支持 \t \t \t \t
垂直制表符 \v 不支持 不支持 高版本支持 \v \v 另义 \v表示very magic \v
单词字符 \w [A-Za-z0-9_] \w \w \w 不支持 \w \w \w
非单词字符 \W [^A-Za-z0-9] \W \W \W 不支持 \W \W \W
\xn 16进制 不支持 不支持 高版本支持 \xn \xn 另义 \x表示[0-9A-Za-z] \xn
\n 八进制 不支持 不支持 不支持 \n \n 不支持 \n
\n 后向引用 \n \n \n \n 仅取结果可用 \n \n 仅取结果可用 \n
[:alnum:] 字母和数字 [:alnum:] [:alnum:] [:alnum:] [:alnum:] [:alnum:] [:alnum:] 不支持
[:alpha:] 字母 [:alpha:] [:alpha:] [:alpha:] [:alpha:] [:alpha:] [:alpha:] 不支持
[:cntrl:] 控制字符 [:cntrl:] [:cntrl:] [:cntrl:] [:cntrl:] [:cntrl:] [:cntrl:] 不支持
[:digit:] 数字 [:digit:] [:digit:] [:digit:] [:digit:] [:digit:] [:digit:] 不支持
[:graph:] 可打印字符(不含空格) [:graph:] [:graph:] [:graph:] [:graph:] [:graph:] [:graph:] 不支持
[:lower:] 小写 [:lower:] [:lower:] [:lower:] [:lower:] [:lower:] [:lower:] 不支持
[:print:] 可打印字符(含空格) [:print:] [:print:] [:print:] [:print:] [:print:] [:print:] 不支持
[:punct:] 标点 [:punct:] [:punct:] [:punct:] [:punct:] [:punct:] [:punct:] 不支持
[:space:] 空格 [:space:] [:space:] [:space:] [:space:] [:space:] [:space:] 不支持
[:upper:] 大写字母 [:upper:] [:upper:] [:upper:] [:upper:] [:upper:] [:upper:] 不支持
[:xdigit:] 16进制数字 [:xdigit:] [:xdigit:] [:xdigit:] [:xdigit:] [:xdigit:] [:xdigit:] 不支持
[:return:] 不支持 不支持 不支持 不支持 不支持 [:return:] 不支持
[:tab:] 不支持 不支持 不支持 不支持 不支持 [:tab:] 不支持
[:escape:] 不支持 不支持 不支持 不支持 不支持 [:escape:] 不支持
[:backspace:] 不支持 不支持 不支持 不支持 不支持 [:backspace:] 不支持

 

 

转载自http://blog.chinaunix.net/u/634/showart.php id=2466

Ubuntu下的全文替换命令

Ubuntu 下的全文替换命令[这里介绍的是整个目录下的文件替换,如果是单个文件的替换可使用 vi 替换即可]

首先,从简单的需求说起。

1. 需求描述: (最简单的:源自网文)

  我们需要将 /home/pqcc/workspace/python 目录下所有包含 javascript 的字符替换为ssssssss

2. 解决方法:

(1).  > cd /home/pqcc/workspace/python (/home/pqcc/workspace/python 是你要替换的目录)

(2). >  perl -pi -e ‘s|javascript|ssssssss|g’ `find ./ -type f`

(*)  find ./ -type f 此命令是显示当前目录下所有的文件

(*)  如果不写最后的那个g,s|javascript|ssssssss|g 将只替换每一行开头的javascript

再次: (下文是较复杂的一个需求,如果你的问题已经解决了,可以到此为止).

1. 需求描述:(complex) :

  将 <a href=”javascript:jumpTo(‘contact’)”>CONTACT</a> 替换为: <a href=”contact”>CONTACT</a>

  > 看起来有点乱, 细化一下需求:  将  javascript:jumpTo(‘contact’) 替换为 contact.

2. 解决方法:

(1). 表达式:  perl -pi -e ‘s|javascript:jumpTo\(‘\”(\w+)’\”\)|$1|g’ `find ./ -type f`

    (2). 注意事项:

    > 需要对 ‘  和 ” 进行转义。使用 \

    > w+ 表示: 匹配字母或数字或下划线或汉字.

正则表达式共享问题

票务监控

的一个应用:高亮原页面关注城市名,原来做法为对每条记录的innerhtml都进行

 

var reg=/郑州/g;
el.innerHTML=el.innerHTML.replace(reg,"....");

 

想优化一下,避免不必要的DOM操作,同时共享一个正则实例:

 

var reg=/郑州/g;
if(reg.test(el.innerHTML))
el.innerHTML=el.innerHTML.replace(reg,"....");

 

结果出现了意想不到的结果,抽象如下:


例子:

 

猜猜下面代码内容:

 

var reg=/a/g;
console.log(reg.test('a'));
//console.log(reg.lastIndex); 
console.log(reg.test('a'));
//console.log(reg.lastIndex); 

 

吃惊的话看看下面:

 

var reg=/a/g;
console.log(reg.test('a'));
//console.log(reg.lastIndex); 
console.log(reg.test('ba'));
//console.log(reg.lastIndex); 

 

还是要看规范:


15.10.6.3 RegExp.prototype.test(string)

The following steps are taken:

1.  Let match be the result of evaluating the RegExp.prototype.exec (15.10.6.3) algorithm upon this

RegExp object using string as the argument.

2.  If match is not null, then return true; else return false.


我一直忽略了原来 test 实际上是 :


(r.exec(s) != null)


那么知道exec 对待 g 正则表达式,会记录 lastIndex 到这个正则表达式上,这样子的话 第二个 test 则会从第一个 test 的 lastIndex 开始匹配,出现了上述的结果。

 

总结原因:


1.test 等于 调用exec

2.lastIndex 存在于正则表达式中,而不是 java 一样有一个 matcher 对象存放 index,或者像 perl 一样 lastIndex 实际上和字符串关联,而javascript 这样子lastIndex和正则表达式关联,test还是最好不要设 g。

3.不成熟的优化等于魔鬼,实际上我可以再单独设一个检测正则表示式即可:


var reg=/郑州/g;
var reg2=/郑州/;
if(reg2.test(el.innerHTML))
  el.innerHTML=el.innerHTML.replace(reg,"....");

 

PS:共享带来的问题:

 

有时想为了一点内存,共享几个对象实例,而对于正则表达式则要特别小心,因为正则实例的一些状态比如lastIndex在不同的操作中(test,exec)常常会被影响的,例如:

 

    var script_re = /x/g;
    var m,x = "avbxz",loop = 1;

    while (m = script_re.exec(x)) {
        console.log(script_re.lastIndex + " : " + m[0]);
        //重置lastIndex要死循环喽
        //"y".replace(script_re, "");
        //console.log("after replace : "+script_re.lastIndex );
        //"y".match(script_re);
        //console.log("after match : "+script_re.lastIndex );

        loop++;
        if (loop == 100) {
            alert("die!");
            break;
        }
    }

 

 

updated : 2010-12-10

 

用 match 取代 test

 

最好还是不要用 test 来进行判断 :

 

var reg=/d/g;
console.log(reg.test("dd"));
console.log(reg.test("dg"));

 

因为 test 在 //g 会导致lastIndex 记载在该正则表达式中影响后续操作,如果不在乎性能的话,可用 match 取代:

 

var reg=/d/g;
console.log("dd".match(reg));
console.log("dg".match(reg));

 

 

 

 

JavaScript中的正则表达式解析

  正则表达式是一个描述字符模式的对象。

  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;

  正则表达式(regular expression)对象包含一个正则表达式模式(pattern)。它具有用正则表达式模式去匹配或代替一个串(string)中特定字符(或字符集合)的属性(properties)和方法(methods)。要为一个单独的正则表达式添加属性,可以使用正则表达式构造函数(constructor function),无论何时被调用的预设置的正则表达式拥有静态的属性(the predefined RegExp object has static properties that are set whenever any regular expression is used, 我不知道我翻得对不对,将原文列出,请自行翻译)。

创建:

一个文本格式或正则表达式构造函数

文本格式: /pattern/flags

正则表达式构造函数: new RegExp(“pattern”[,”flags”]);

参数说明:

pattern — 一个正则表达式文本

flags — 如果存在,将是以下值:

g: 全局匹配

i: 忽略大小写

gi: 以上组合

[注意] 文本格式的参数不用引号,而在用构造函数时的参数需要引号。如:/ab+c/i new RegExp(“ab+c”,”i”)是实现一样的功能。在构造函数中,一些特殊字符需要进行转意(在特殊字符前加”\”)。如:re = new RegExp(“\\w+”)

  正则表达式中的特殊字符

字符 含意

\ 做为转意,即通常在”\”后面的字符不按原来意义解释,如/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]。

  说了这么多了,我们来看一些正则表达式的实际应用的例子:

E-mail地址验证:

function test_email(strEmail) {

  var myReg = /^[_a-z0-9]+@([_a-z0-9]+\.)+[a-z0-9]{2,3}$/;

  if(myReg.test(strEmail)) return true;

  return false;

}

HTML代码的屏蔽

function mask_HTMLCode(strInput) {

   var myReg = /<(\w+)>/;

   return strInput.replace(myReg, “&lt;$1&gt;”);

}

正则表达式对象的属性及方法

  预定义的正则表达式拥有有以下静态属性: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方法得到

例子

<script language = “JavaScript”>

var myReg = /(\w+)\s(\w+)/;

var str  = “John Smith”;

var newstr = str.replace(myReg, “$2, $1”);

document.write(newstr);

</script>

将输出”Smith, John” [color=blue][/color]

javascript正则表达式

很长时间没看 正则表达式了,碰巧今天用到,温故知新了一把 看书学习吧
50% 的举一反三练习中的原创。
 
一 javascript正则表达式的基本知识

1     javascript 正则对象创建 和用法

    声明javascript 正则表达式
   
     var reCat = new RegExp(“cat”);
      你也可以 
     var reCat = /cat/;      //Perl 风格   (推荐)

2 学习最常用的 test exec match search  replace  split 6个方法

   1) test  检查指定的字符串是否存在

       var data = “123123”;
       var reCat = /123/gi;
       alert(reCat.test(data));  //true
     
       //检查字符是否存在  g 继续往下走  i 不区分大小写

   2) exec 返回查询值

       var data = “123123,213,12312,312,3,Cat,cat,dsfsdfs,”;
       var reCat = /cat/i;
       alert(reCat.exec(data));  //Cat

     3)match  得到查询数组

       var data = “123123,213,12312,312,3,Cat,cat,dsfsdfs,”;
       var reCat = /cat/gi;
       var arrMactches = data.match(reCat)

       for (var i=0;i < arrMactches.length ; i++)
       {
            alert(arrMactches[i]);   //Cat  cat
       }

     4) search  返回搜索位置  类似于indexof

       var data = “123123,213,12312,312,3,Cat,cat,dsfsdfs,”;
       var reCat = /cat/gi;
       alert(data.search(reCat));  //23

    5) replace  替换字符  利用正则替换

       var data = “123123,213,12312,312,3,Cat,cat,dsfsdfs,”;
       var reCat = /cat/gi;
       alert(data.replace(reCat,”libinqq”));

    6)split   利用正则分割数组

       var data = “123123,213,12312,312,3,Cat,cat,dsfsdfs,”;
       var reCat = /\,/;
       var arrdata = data.split(reCat);

       for (var i = 0; i < arrdata.length; i++)
       {
            alert(arrdata[i]);
       }

3  学习下  简单类   负向类  范围类  组合类

    //简单类
       var data = “1libinqq,2libinqq,3libinqq,4libinqq”;
       var reCat = /[123]libinqq/gi;
       var arrdata = data.match(reCat);

       for (var i = 0; i < arrdata.length; i++)
       {
            alert(arrdata[i]);  // 1libinqq 2libinqq  3libinqq
       }

       //负向类
       var data = “alibinqq,1libinqq,2libinqq,3libinqq,4libinqq”;  //\u0062cf
       var reCat = /[^a123]libinqq/gi;
       var arrdata = data.match(reCat);

       for (var i = 0; i < arrdata.length; i++)
       {
            alert(arrdata[i]);  //4libinqq
       }

       //范围类
       var data = “libinqq1,libinqq2,libinqq3,libinqq4,libinqq5”;  //\u0062cf
       var reCat = /libinqq[2-3]/gi;
       var arrdata = data.match(reCat);

       for (var i = 0; i < arrdata.length; i++)
       {
            alert(arrdata[i]);   // libinqq2  libinqq3
       }

       //组合类
      var data = “a,b,c,w,1,2,3,5”;  //\u0062cf
       var reCat = /[a-q1-4\n]/gi;
       var arrdata = data.match(reCat);

       for (var i = 0; i < arrdata.length; i++)
       {
            alert(arrdata[i]);  // a b c 1 2 3
       }

       这些都是 js正则 最基本的使用方法,看不会的请复制到笔记本练习下,看会了再往下面看。

 
二  javascript  正则表达式是分组知识
   
    1) 简单分组
    
<!–<br /><br />Code highlighting produced by Actipro CodeHighlighter (freeware)<br />http://www.CodeHighlighter.com/<br /><br />–><script language=”JavaScript”>
  
<!–
    
/*正则表达式  简单的分组
    举例 我们要查找字符串 MouseMouse

    var reCat = /MouseMouse/gi; 
    
    尽管这是可以的,但是有点浪费。如果不知道Mouse 在字符串中到底出现几次时该怎么办,如果重复多次呢。
    var reCat = /(mouse){2}/gi;    括号的意思列Mouse 将在一行连续出现2次。

    */  
    
    
var data = Ah-mousemouse;  
    
var reCat = /(mouse){2}/gi;   
    
var arrdata = data.match(reCat);

    for (var i = 0; i < arrdata.length; i++)
    {
        alert(arrdata[i]);
    }    
    

  //–>
  </script>

 
   2 复杂分组 
 


<!–<br /><br />Code highlighting produced by Actipro CodeHighlighter (freeware)<br />http://www.CodeHighlighter.com/<br /><br />–>  <script language=”JavaScript”>
  
<!–
    
/*正则表达式  复杂的分组
             零次 或 一次
    *   零次 或 多次
    +   最少一次 或 多次
    
*/  
    
    
var data = bb ba da bad dad aa ;  
    
var reCat = /([bd]ad )/gi;   // 匹配出 ba da bad  dad
    var arrdata = data.match(reCat);

    for (var i = 0; i < arrdata.length; i++)
    {
        alert(arrdata[i]);
    }    
    

    // 同时 也不介意将分组放在分组中间
    // var re = /(mom( and dad) )/;    匹配出 mom  或  mon and daa
  //–>
  </script>

 

3   反向引用

 
<!–<br /><br />Code highlighting produced by Actipro CodeHighlighter (freeware)<br />http://www.CodeHighlighter.com/<br /><br />–>  <script language=”JavaScript”>
  
<!–
    
/*正则表达式  反向引用*/

    var sToMatch = #123456789;
    
var reNumbers = /#(\d+)/;
    reNumbers.test(sToMatch);
    alert(RegExp.$
1);

    /* 
      这个例子尝试匹配后面跟着几个或多个数字的镑符合,并对数字进行分组
      以存储他们。在调用 test 方法后,所有的反向引用都保存到了 RegExp 构造函数中
      从 RegExp.$1(它保存了第一个反向引用)开始,如果还有第二个反向引用,就是
      RegExp.$2,如果还有第三个反向引用存在,就是 RegExp.$3.依此类推。因为该组
      匹配了 “123456780”,所以 RegExp.$1 中就存储了这个字符串。

    */

    var sToChange = 1234 5678;
    
var reMatch = /(\d{4}) (\d{4})/;
    
var sNew = sToChange.replace(reMatch,$2 $1);
    alert(sNew);

    /*
      在这个例子中,正则表达式有两个分组,每一个分组有四个数字。在 replace() 方法的第二个参数
      中,$2 等同于 “5678” ,而 $1 等同于 “1234”,对应于它们在表达式中的出现顺序。
    
*/

  //–>
  </script>

 

4 候选

 
<!–<br /><br />Code highlighting produced by Actipro CodeHighlighter (freeware)<br />http://www.CodeHighlighter.com/<br /><br />–> <script language=”JavaScript”>
  
<!–
    
/*正则表达式  候选 */
    
var sToMatch1 = red;
    
var sToMatch2 = black;
    
var reRed = /red/;
    
var reBlack = /black/;

    alert(reRed.test(sToMatch1) || reBlack.test(sToMatch1));
    alert(reRed.test(sToMatch2) 
|| reBlack.test(sToMatch2));

    /*
     这虽然能完成任务,但是十分沉长,还有另一种方式就是正则表达式的候选操作符。
    
*/

    var sToMatch1 = red;
    
var sToMatch2 = black;
    
var reRedOrBlack = /(red|black)/;
    alert(reRedOrBlack.test(sToMatch1));
    alert(reRedOrBlack.test(sToMatch2));

  //–>
  </script>

 

5  非捕获性分组

 
<!–<br /><br />Code highlighting produced by Actipro CodeHighlighter (freeware)<br />http://www.CodeHighlighter.com/<br /><br />–><script language=”JavaScript”>
  
<!–
    
/*正则表达式  非捕获性分组
    
    如果要创建一个非捕获性分组,只要在左括号的后面加上一个问号和一个紧跟的冒号:
    
*/

    var sToMatch = #123456789;
    
var reNumbers = /#( :\d+)/;
    reNumbers.test(sToMatch);
    alert(RegExp.$
1);

    /*
    这个例子的最后一行代码输出一个空字符串,因为该组是非捕获性的,
    
*/

    var sToMatch = #123456789;
    
var reNumbers = /#( :\d+)/;
    alert(sToMatch.replace(reNumbers,
abcd$1));

    /*
    正因如此,replace()方法就不能通过 RegExp.$x 变量来使用任何反向引用,这段代码
    输出的“abcd$1”而不是abcd123456789, 因为$1 在这里并不被看成是一个反向引用。
    
*/
  
//–>
  </script>

 

6 前瞻


<!–<br /><br />Code highlighting produced by Actipro CodeHighlighter (freeware)<br />http://www.CodeHighlighter.com/<br /><br />–> <script language=”JavaScript”>
  
<!–
    
/*正则表达式  前瞻
    前瞻 就和它名字一样,它告诉正则表达式运算器向前看一些字符而不是移动位置
    
*/

      var sToMatch1 = bedroom;
      
var sToMatch2 = bedding;
      
var reBed = /bed( =room)/
      alert(reBed.test(sToMatch1));  
//true
      alert(reBed.test(sToMatch2));  //false
   
    
//负向前瞻
    
      
var sToMatch1 = bedroom;
      
var sToMatch2 = bedding;
      
var reBed = /bed( !room)/
      alert(reBed.test(sToMatch1)); 
//false
      alert(reBed.test(sToMatch2)); //true
  //–>
  </script>

 

 

7 边界

 
<!–<br /><br />Code highlighting produced by Actipro CodeHighlighter (freeware)<br />http://www.CodeHighlighter.com/<br /><br />–>   <script language=”JavaScript”>
  
<!–
    
/*正则表达式  边界
    ^     行开头
    $     行结尾
    \b    单词的边界
    \B    非单词的边界
    
*/

      var sToMatch = Important word is the last one.;
      
var reLastWord = /(\w+)\.$/
      reLastWord.test(sToMatch);
      alert(RegExp.$
1);  //one

    
/*
    假如想查找一个单词,但要它只出现在行尾,则可以使用美元符号 ($)来表示它:
    
*/

      var sToMatch = Important word is the last one.;
      
var reLastWord = /^(\w+)/
      reLastWord.test(sToMatch);
      alert(RegExp.$
1);  //Important

    
/*
    在这个例子中,正则表达式查找行起始位置后的一个或多个单词字符。如果遇到非单词字符
    匹配停止,返回 Important。 这个例子也可以用单词边界实现。
    
*/
   
      
var sToMatch = Important word is the last one.;
      
var reLastWord = /^(.+ )\b/
      reLastWord.test(sToMatch);
      alert(RegExp.$
1);  //Important
    
    
/*
    这里,正则表达式用惰性量词来制定在单词边界之前可以出现任何字符,且可以出现一次或
    多次(如果使用贪婪性量词,表达式就匹配整个字符串)。
    
*/

    var data =  First second thind fourth fifth sixth ;  
    
var reCat = /\b(\S+ )\b/g;   
    
var arrdata = data.match(reCat);

    for (var i = 0; i < arrdata.length; i++)
    {
        alert(arrdata[i]);
    }   

    /*
    使用单词边界可以方便地从字符串中抽取单词。
    
*/
  
//–>
  </script>

 

8 多行模式

 


<!–<br /><br />Code highlighting produced by Actipro CodeHighlighter (freeware)<br />http://www.CodeHighlighter.com/<br /><br />–>    <script language=”JavaScript”>
  
<!–
    
/*正则表达式  多行模式
   
      要制定多行模式,只要在正则表达式想要匹配的行末的一个单词
    
*/  
    
    
var data =  First second\n thind fourth\n fifth sixth;  
    
var reCat = /(\w+)$/g;   
    
var arrdata = data.match(reCat);

    for (var i = 0; i < arrdata.length; i++)
    {
        alert(arrdata[i]);
    }  
    
    
/*
      上面只返回一个单词 sixth,因为换行符阻挡了匹配,只能匹配行末的一个单词,
    当然也可以使用 split() 方法将字符串分割成数组,但就得对每一行进行单独匹配。

    以前不好好看书经常半吊子,看一半就仍了,导致用了好多 split, 其实很简单如下面
    例子 只需要 m 参数进行多行匹配。

    */  
    
var data =  First second\n thind fourth\n fifth sixth;  
    
var reCat = /(\w+)$/gm;   
    
var arrdata = data.match(reCat);

    for (var i = 0; i < arrdata.length; i++)
    {
        alert(arrdata[i]);
    }  
    

  //–>
  </script>

 

  至此结束,这些都是 javascript 正则表达式的基本方法,如果你看会了看复杂的正则你会有豁然开朗的感觉。
另外 我知道有些人很懒(包括我),所以正则分组的例子的我特此打包欢迎下载学习  js正则分组

 

其实还有 断言 回逆 等 3~5种的正则,一看表12点了,又要举例子又要翻译,吐血,还是算了,我还是春梦了无痕吧。

javascript正则表达式知识点总结:(转并整理)

正则表达式是一个描述字符模式的对象。
JavaScript的RegExp对象和String对象定义了使用正则表达式来执行强大的模式匹配和文本检索与替换函数的方法.

在JavaScript中,正则表达式是由一个RegExp对象表示的.当然,可以使用一个RegExp()构造函数来创建RegExp对象,
也可以用JavaScript 1.2中的新添加的一个特殊语法来创建RegExp对象.就是定义为包含在一对斜杠(/)之间的字符.
例: 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 垂直制表符
\ / 一个 / 直接量
\ \ 一个 \ 直接量
\ . 一个 . 直接量
\ * 一个 * 直接量
\ + 一个 + 直接量
\   一个   直接量
\ |一个 | 直接量
\ (一个 ( 直接量
\ ) 一个 ) 直接量
\ [ 一个 [ 直接量
\ ] 一个 ] 直接量
\ { 一个 { 直接量
\ } 一个 } 直接量
\OOO 由八进制数OOO指定的ASCII码字符
\ xHH由十六进制数HH 指定的ASCII码字符
\uHHHH由十六进制HHHH代表的unicode代码
\ cX 控制字符^X. 例如, \ch代表Ctrl-h
_________________________________________________

如果想在正则表达式中使用特殊的标点符号,必须在它们之前加上一个 “\” .

2.字符类

将单独的直接量字符放进中括号[ ]内就可以组合成字符类.一个字符类和它所包含的任何一个字符都匹配,所以正则表达式 / [abc] / 和字母 “a” , “b” , “c” 中的任何一个都匹配.另外还可以定义否定字符类,这些类匹配的是除那些包含在中括号之内的字符外的所有字符.定义否定字符类时,要将一个 ^ 符号作为从左中括号算起的第一个字符.正则表达式的集合是 / [^a-zA-z0-9] / .

由于某些字符类非常常用,所以JavaScript的正则表达式语法包含一些特殊字符和转义序列来表示这些常用的类.

例如, \s 匹配的是空格符,制表符和其它空白符, \S匹配的则是空白符之外的任何字符.

正则表达式的字符类

字符 匹配
____________________________________________________
[chars]位于括号之内的任意字符
[^chars] 不在括号之中的任意字符
. 除了换行符之外的任意字符,等价于[^\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.属性(i g m)

有关正则表达式的语法还有最后一个元素,那就是正则表达式的属性,它说明的是高级模式匹配的规则.和其它正则表达式语法不同,属性是在 / 符号之外说明的.即它们不出现在两个斜杠之间,而是位于第二个斜杠之后.javascript 1.2支持两个属性.属性 i 说明模式匹配应该是大小写不敏感的.属性 g 说明模式匹配应该是全局的.也就是说,应该找出被检索的字符串中所有的匹配.这两种属性联合起来就可以执行一个全局的,大小写不敏感的匹配.

例如: 要执行一个大小不敏感的检索以找到词语 “java” (或者是 “java” 、”JAVA”等) 的第一个具体值,我们可以使用大小不敏感的正则表达式 /\b java\b/i .如果要在一个字符串中找到 “java” 所有的具体值,我们还可以添加属性 g, 即 /\b java \b/gi .

以下是正则表达式的属性:

字符 含义
_________________________________________
i 执行大小写不敏感的匹配
g执行一个全局的匹配,简而言之,
就是找到所有的匹配,而不是在找到第一个之后就停止了
m 多行匹配
_________________________________________

除属性 g 和 i 之外,正则表达式就没有其它像属性一样的特性了.如果将构造函数 RegExp 的静态属性 multiline 设置为 true ,那么模式匹配将以多行的模式进行.在多行模式下,锚字符 ^ 和 $ 匹配的不只是检索字符串的开头和结尾,还匹配检索字符串内部的一行的开头和结尾.例如: 模式 /Java$/ 匹配的是 “Java”,但是并不匹配”Java\nis fun” .如果我们设置了 multiline 属性,那么后者也将被匹配。

正则表达式中的特殊字符

字符 含意
\

做为转意,即通常在”\”后面的字符不按原来意义解释,如/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]。

正则表达式对象的属性及方法
  预定义的正则表达式拥有有以下静态属性: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方法得到

用到正则表达式的String 方法

String 的 search( ),split( ),replace( ),match( )

高级正则表达式:

 : 不可俘获(non – capturing) var pattern = /( :abc)(def)/ ; var text = “abcdef”,replace(pattern,”$1″); //返回 def
 = 肯定性先行表达式 var pattern = /\d( =\.\d+)/;
 ! 否定性先行表达式 var pattern = /\d( =\.\d+)/;

防止贪婪匹配
在(* +   {m,n} {m,} {m} ) 后面 加上 ? “aaaa”.match(/a+ /) //只匹配一个 a

《JavaScript语言精粹》

1、JavaScript的简单类型包括数字、字符串、布尔值、null值和undefined值。其他所有的值都是对象。

2、原型连接只有在检索值的时候才被用到。如果我们尝试去获取某个对象的某个属性值,且该对象没有此属性名,那么JavaScript会试着从原型对象中获取属性值。如果那个原型对象也没有该属性,那么再从它的原型中寻找,依此类推,直到该过程最后到达终点object.prototype。如果想要的属性完全不存在于原型链中,那么结果就是undefined值。这个过程称为委托。

3、使用hasOwnProperty方法,如果对象拥有独有的属性,它将返回true。hasOwnProperty方法不会检查原型链。

4、一般来说,所谓编程就是将一组需求分解成一组函数与数据结构的技能。

5、当一个函数被保存为对象的一个属性时,我们称它为一个方法。[方法调用模式]

   当一个函数并非一个对象的属性时,那么它被当做一个函数来调用。[函数调用模式]

   结合new前缀调用的函数被称为构造器函数。[构造器调用模式]

   apply方法让我们构建一个参数数组并用其去调用函数。apply方法接收两个参数,第一个是将被绑定给this的值,第二个就是参数数组。[Apply调用模式]

6、一个try语句只会有一个将捕获所有异常的catch代码块。

7、函数可以访问它被创建时所处的上下文环境,这被称为闭包。

8、JavaScript允许数组包含任意混合类型的值。

9、JavaScript的许多特性都借鉴自其他语言。语法借鉴自Java,函数借鉴自Scheme,原型继承借鉴自Self,而JavaScript的正则表达式则借鉴自Perl。

10、JavaScript中处理正则表达式的方法有regexp.exec、regexp.test、string.match、string.replace、string.search和string.split。

11、^表示字符串的开始,$表示字符串的结束。( :…)表示一个非捕获型分组,后缀 表示这个分组是可选的,对:后的内容进行匹配。正则表达式因子:\ / [ ] ( )   + * | . ^ $

12、正则表达式量词。 等同于{0,1}。*等同于{0,}。+等同于{1,}。

13、Array对象常用方法:concat、join、pop、push、reverse、shift、slice、sort、splice和unshift。

14、JavaScript没有块级作用域,提倡在每个函数的开头部分声明所有变量。

15、JavaScript有一个机制,它试图通过自动插入分号来修正有缺损的程序。

16、不要使用==运算符、with语句、eval函数、类型的包装对象(如new Object可用{}代替)、void。

javascript+css+dhtml经典实用效果强站–树型菜单,选项卡,可排序表格均出自这里!

http://webfx.eae.net/dhtml/

Index of /dhtml

Icon Name                    Last modified      Size  Description
[DIR]Parent Directory - [DIR]VMLClock/ 01-Mar-2004 22:38 - [DIR]animator/ 01-Mar-2004 22:37 - [DIR]blink/ 01-Mar-2004 22:37 - [DIR]boxsizing/ 01-Mar-2004 22:38 - [DIR]chart/ 30-May-2006 19:38 - [DIR]collist/ 30-May-2006 19:39 - [DIR]colorpickerscriptlets/ 01-Mar-2004 22:38 - [DIR]combobox/ 01-Mar-2004 22:38 - [DIR]contextmenu/ 01-Mar-2004 22:38 - [DIR]coolbutton2/ 01-Mar-2004 22:38 - [DIR]coolbuttons/ 01-Mar-2004 22:38 - [DIR]cssexpr/ 01-Mar-2004 22:38 - [DIR]cssmenu/ 01-Mar-2004 22:38 - [DIR]datepicker/ 01-Mar-2004 22:38 - [DIR]dhtmlmenu/ 01-Mar-2004 22:38 - [DIR]dhtmlmenu3/ 01-Mar-2004 22:38 - [DIR]dhtmlmenu4/ 01-Mar-2004 22:38 - [DIR]dockbar/ 01-Mar-2004 22:38 - [DIR]domgenmove/ 01-Mar-2004 22:38 - [DIR]errordialog/ 01-Mar-2004 22:38 - [DIR]favbar/ 01-Mar-2004 22:38 - [DIR]genmove/ 01-Mar-2004 22:37 - [DIR]genresize/ 01-Mar-2004 22:38 - [DIR]grid/ 01-Mar-2004 22:38 - [DIR]helptip/ 01-Mar-2004 22:38 - [DIR]ieemu/ 06-Jun-2002 15:22 - [DIR]keyhandler/ 01-Mar-2004 22:38 - [DIR]liquidizing/ 01-Jun-2002 00:33 - [DIR]mozInnerHTML/ 01-Mar-2004 22:37 - [DIR]persist/ 01-Mar-2004 22:38 - [DIR]pngbehavior/ 01-Mar-2004 22:38 - [DIR]richedit/ 01-Mar-2004 22:38 - [DIR]scrollzoom/ 01-Mar-2004 22:38 - [DIR]select/ 01-Mar-2004 22:38 - [DIR]selectableelements/ 01-Mar-2004 22:38 - [DIR]slidebar/ 01-Mar-2004 22:38 - [DIR]slider/ 01-Mar-2004 22:38 - [DIR]sortabletable/ 30-May-2006 19:38 - [DIR]spellchecker/ 30-May-2006 19:38 - [DIR]splashwin/ 01-Mar-2004 22:38 - [DIR]statusbar/ 01-Mar-2004 22:38 - [DIR]swipeFade/ 01-Mar-2004 22:38 - [DIR]syncscroll/ 01-Mar-2004 22:38 - [DIR]tablesort/ 01-Mar-2004 22:38 - [DIR]tabpane/ 01-Mar-2004 22:38 - [DIR]tooltip/ 01-Mar-2004 22:38 - [DIR]treewalker/ 01-Mar-2004 22:38 - [DIR]wincontrols/ 01-Mar-2004 22:38 - [DIR]xblmarquee/ 01-Mar-2004 22:38 - [DIR]xloadtree/ 01-Mar-2004 22:38 - [DIR]xmenu.old/ 01-Mar-2004 22:38 - [DIR]xmenu/ 01-Mar-2004 22:37 - [DIR]xmlextras/ 30-May-2006 19:41 - [DIR]xtree/ 30-May-2006 19:38 - [DIR]xtree2b/ 07-Jul-2005 00:35 -
Apache/2.0.52 (FreeBSD) SVN/1.3.0 PHP/4.3.11 DAV/2 mod_fastcgi/2.4.0 mod_ssl/2.0.52 OpenSSL/0.9.7d mod_perl/2.0.0 Perl/v5.8.4 Server at webfx.eae.net Port 80

jqueryeasyuicombox数据获取

 

    在jquery easyui 的demo中,通过

url="combobox_data.json" 

  从服务器获取json数据,combobox_data.json的数据内容如下

[{
	"id":0,
	"text":""
},{
	"id":1,
	"text":"Java"
},{
	"id":2,
	"text":"C#"
},{
	"id":3,
	"text":"Ruby",
	"selected":true
},{
	"id":4,
	"text":"Perl"
},{
	"id":5,
	"text":"Basic"
}]

 它是一个没有名字的数组。在我们实际通过ajax从服务器获得的json数据往往是有名字的,而不直接是一个没有名字的数组

{"datastore":[{"id":"1","text":"国庆节"},{"id":"2","text":"端午节"},{"id":"3","text":"中秋节"}]}

 如何让combobox支持这种格式的json数据呢。修改jquery.easyui.min.js中的第8127行,将

_603(_609,data,_60b);

 中的data后面加上你自己的数组名字,我这里是datastore。

$.ajax({url:opts.url,dataType:"json",data:_60a,success:function(data){
_603(_609,data.datastore||data,_60b);
},error:function(){
opts.onLoadError.apply(this,arguments);
}});