mysql 正则regrx_JS 正则（RegExp）

通过 new 关键词来定义 RegExp 对象。

test()

test() 方法检索字符串中的指定值。返回值是 true 或 false。

var r = new RegExp("e");

var str = "hello world!";

alert(r.test(str)) // true

exec()

exec() 方法检索字符串中的指定值。返回值是被找到的值。如果没有发现匹配，则返回 null。

var r = new RegExp("e");

var str = "hello world!";

alert(r.exec(str)); // "e"

这些是JS RegExp提供的一些方法，简单介绍下；

字面量

var reg = /\bis\b/;

这就是一个简单的字面量正则赋值

\：将下一个字符标记为或特殊字符、或原义字符、或向后引用、或八进制转义符。

例如， 'n' 匹配字符 'n'。'\n' 匹配换行符。序列 '\\' 匹配 "\"，而 '\(' 则匹配 "("。

还有关于如何选择一个\？

var str1 = "aaa\\AAA"; // 这里的\\，转换成文本后，只表示一个\,就是说这段待执行文本内含一个\

console.log(str1); // "aaa\AAA"

var r = new RegExp(/\\/); // 构建正则

console.log(str1.replace(r,"R")); // "aaaRAAA"

思考一下创建正则的几种方式,并且多认识一个正则方法

+:匹配前面的子表达式一次或多次。要匹配 + 字符，请使用 \+。

var s = "dddddddddd";

var r = /d/; // "Sddddddddd"

var r1 = new RegExp("d"); // "Sddddddddd"

var r2 = new RegExp(/d/); // "Sddddddddd"

var r3 = new RegExp("\d"); // "Sddddddddd"

var R = /d+/; // "S"

var R1 = new RegExp("d+") // "S"

var R2 = new RegExp(/d+/); // "S"

var R3 = new RegExp("\d+"); // "S"

// console.log(s.replace(rX,"S"))

\b：匹配一个字边界，即字与空格间的位置。(不是空格！！！)

var reg = /\bis\b/;

var str = "He is a boy. This is a dog. Where is she?";

console.log(

str.replace(reg,"IS")

);

// "He IS a boy. This is a dog. Where is she?"

// 使用replace方法，将按照正则规则选择到的字符串(... is ...)替换为"IS",但是我们发现只有第一句被替换

只有第一句被替换？引出我们的：

\g:执行全局匹配(查找所有匹配而非在找到第一个匹配后停止)

在一段字符串中，可能存在若干符合正则的选择，不执行全局g，只会选择第一个，执行全局g，所有符合的都会被选择到。

另一种说法：global可选标志，带这个标志表示替换将针对行中每个匹配的串进行，否则则只替换行中第一个匹配串

reg = /\bis\b/g;

console.log(str.replace(reg,'IS')); // "He IS a boy. This IS a dog. Where IS she?"

.：除了换行符以外的任意字符。要匹配包括 'n' 在内的任何字符，请使用像"(.|\n)"的模式。

*:匹配前面的子表达式零次或多次 OR (*前边的内容可以连续重复使用任意次以使整个表达式得到匹配)

例如，zo* 能匹配 "z" 以及 "zoo"。* 等价于{0,}。

PS：.*连在一起就意味着任意数量的不包含换行的字符

var str = "dddddd\ndfdf";

console.log(str); // "dddddd

// dfdf" 这里文本排列错误，但是知道里面存在一个换行符就对了

var reg = /.*/;

console.log(str.replace(reg,"X")); // "X

// dfdf" 选择了换行符前面的任意字符(这里重复任意次)

\d：匹配一个数字字符。等价于 [0-9]。

\D：匹配一个非数字字符。等价于 [^0-9]。

这里要提到一个中括号：

[a-z]：字符范围。匹配指定范围内的任意字符。例如，'[a-z]' 可以匹配 'a' 到 'z' 范围内的任意小写字母字符。(包括本身)

var str = "a1b2c3d4";

var reg = /\d/; // 选择一个数字字符(而已)哪怕有更多选择只选择第一个遇到的

console.log(str.replace(reg,"X")); // "aXb2c3d4"

reg = /\d/g; // 在全局中，选择数字字符，并返回多个(如果存在)符合规则的字串

console.log(str.replace(reg,"X")); // "aXbXcXdX"

reg = /[a-z]\d/g // 一个a-z任意字符和一个数字字符，并返回多个(如果存在)符合规则的字串

console.log(str.replace(reg,"X")); // "XXXX"

reg = /[a-z]\d/ // 一个a-z任意字符和一个数字字符

console.log(str.replace(reg,"X")); // "Xb2c3d4"

// \D 匹配一个非数字字符，与\d相反

str = "123ABC"

reg = /\D/;

console.log(str.replace(reg,"0")); // "1230BC"

reg = /\D/g; // 一个非数字字符，并返回多个(如果存在)符合规则的字串

console.log(str.replace(reg,"0")); // "123000"

reg = /\D{3}/; // 三个连续的非数字字符

console.log(str.replace(reg,"456")); // "123456"

// 区分大小写

str = "A1B2C3d4"

reg = /[A-Z]/g; // 选择A-Z大写字母任意一个，并返回多个(如果存在)符合规则的字串

console.log(str.replace(reg,"O")) // "O1O2O3d4"

reg = /[A-Z]\d/; // 选择A-Z大写字母任意一个和一个数字

console.log(str.replace(reg,"O")) // "OB2C3d4"

reg = /[A-Z]\d/g; // 选择A-Z大写字母任意一个和一个数字，并返回多个(如果存在)符合规则的字串

console.log(str.replace(reg,"O")) // "OOOd4"

和大括号：

{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?'。请注意在逗号和两个数之间不能有空格。

?：匹配前面的子表达式零次或一次。例如，"do(es)?" 可以匹配 "do" 或 "does" 中的"do" 。? 等价于 {0,1}。

+：匹配前面的子表达式一次或多次。例如，'zo+' 能匹配 "zo" 以及 "zoo"，但不能匹配 "z"。+ 等价于 {1,}。

还有之前的：

*：匹配前面的子表达式零次或多次。例如，zo* 能匹配 "z" 以及 "zoo"。* 等价于{0,}。

以上5种在正则中被成为限定符，很好理解，限制匹配次数嘛

var str = "A1234B123C123456";

var reg = /\d{4}/; // {4}之前的\d重复匹配4次

console.log(str.replace(reg,"&")); // "A&B123C123456"

reg = /\d{6}/ // 重复6次

console.log(str.replace(reg,"&")); // "A1234B123C&"

reg = /[A-Z]\d{6}/ // 一个A-Z任意字母，和一个连续6个任意数字

console.log(str.replace(reg,"&")) // "A1234B123&"

str = "000&1111&222222&55555555&";

reg = /\d{4,}/; // 一个数字，至少匹配4次

console.log(str.replace(reg,"——")); // "000&——&222222&55555555&"

reg = /\d{4,}/g; // (一个数字，至少匹配4次)，并返回多个符合规则的匹配串

console.log(str.replace(reg,"——")); // "000&——&——&——&"

reg = /\d{4,6}/g; // (一个数字，至少4次，至多6次)

console.log(str.replace(reg,"——")); // "000&——&——&——55&"

reg = /\d?/g; // 等价于：{0,1}

console.log(str.replace(reg,"？")); //　"？？？？&？？？？？&？？？？？？？&？？？？？？？？？&？"

reg = /\d+/; // 等价于：{1,}

console.log(str.replace(reg,"+")); // "+&1111&222222&55555555&"

reg = /\d+/g;

console.log(str.replace(reg,"+")); // "+&+&+&+&"

reg = /\d*/g;

console.log(str.replace(reg,"+")); // "++&++&++&++&+"