正则表达式学习笔记

概述

　　正则表达式是事先声明一组规则，用于匹配字符串中的字符。

基本语法

　　元字符

　　　　在正则表达式的模式中，有一些字符是有特殊含义的，被称为

元字符

。元字符都是针对单个字符匹配的。

　　　　\w

匹配大小写英文字符及数字 0 到 9 之间的任意一个及下划线，相当于

[a-zA-Z0-9_]

　　　　\W

不匹配大小写英文字符及数字 0 到 9 之间的任意一个，相当于

[^a-zA-Z0-9_]

　　　　\s

匹配任何空白字符，相当于

[ \f\n\r\t\v]

　　　　\S

匹配任何非空白字符，相当于

[^\s]

　　　　\d

匹配任何 0 到 9 之间的单个数字，相当于

[0-9]

　　　　\D

不匹配任何 0 到 9 之间的单个数字，相当于

[^0-9]

　　　　[\u4e00-\u9fa5]

匹配任意单个汉字（这里用的是 Unicode 编码表示汉字的 )

　　界定符

　　　　比较通用的正则表达式界定符是双斜杠

/regex/

　　原子的概念

　　　　正则表达式中的原子分为可见原子和不可见原子。

　　　　[\f\n\r\t\v]

属于不可见原子，其他表示可见原子

　　量词

　　　　\*

匹配 0 到多个元字符，相当于

{0,}

　　　　?

匹配 0 到 1 个元字符，相当于

{0,1}

　　　　{n}

匹配 n 个元字符

　　　　{n,}

匹配至少 n 个元字符

　　　　{n,m}

匹配 n 到 m 个元字符

　　　　\+

匹配至少 1 个元字符，相当于

{1,}

　　边界

　　　　\b

匹配单词边界

　　　　^

字符串必须以指定的字符开始

　　　　$

字符串必须以指定的字符结束

　　捕获分组

　　　　正则表达式中，使用

()

将若干单位（可以是字符，正则表达式）组织在一起，成为一个独立单元。

　　　　正则表达式中，分组分为捕获分组和非捕获分组。

　　　 /(pattern)/flags

模式修正

　　贪婪/懒惰，忽略大小写，忽略空白字符

使用场景

　　表单验证, 模板引擎

/****************************************************************************************************/

　　　　　　　　　　　　　　　　　　JS 中的正则表达式

概述

　　在 JS 中，正则表达式是个

RegExp

对象，具有

exec

，

test

方法。而在

String

对象中，也存在

match

，

replace

，

search

，

split

操作正则表达式的方法。

声明

　　JS 中的正则表达式有两种声明方式（对象字面量 / 构造函数），都会生产一个

RegExp

对象的实例。

　/pattern/flags
　new RegExp(pattern[, flags])

RegExp 对象

　　实例

　     var pattern = /quick\s(brown).+?(jumps)/ig;
　　　　var pattern = new RegExp("quick\\s(brown).+?(jumps)","ig");

　　　　实例之后的

pattern

对象就具有以下属性:

　　lastIndex

：下次开始匹配的字符串位置，若是无设置全局模式，会始终为 0

　　ignoreCase

：是否设置忽略大小写模式

　　global

：是否设置了全局匹配模式　　

　　source

：正则表达式的文本内容

　　　　注意使用构造函数声明正则表达式的时候，需合理使用转义符。

　　方法

　　　　RegExp.exec

检索字符串中指定的值。返回一个结果数组。该方法总是返回单词匹配的结果。

　　　　在正则表达式设置了

g

模式的情况下，会同时更新

RegExp

对象的

lastIndex

属性。

　　　　var result = re.exec('The Quick Brown Fox Jumps Over The Lazy Dog');
　　　　// console.log(result)
　　　　// ["Quick Brown Fox Jumps", "Brown", "Jumps"]

　　　　var pattern = /ab*/g;
　　　　var str = 'abbcdefabh';
　　　　var matchArray;
　　　　while ((matchArray = pattern.exec(str)) !== null) {
　　　　  var msg = 'Found ' + matchArray[0] + '. ';
　　　　 msg += 'Next match starts at ' + pattern.lastIndex;
　　　　 //console.log(msg);
　　　　 // Found abb. Next match starts at 3
　　　　 // Found ab. Next match starts at 9
　　　　}

　　　　使用循环的时候，不要把正则表达式的操作放置在循环体中（这样每次都会重新生成

RegExp

对象），同时必须设置全局模式，可能会造成死循环。

　　　　RegExp.test

执行检索字符串中指定值的操作。返回

true

或

false

。

var pattern = /^\d{4}-\d{2}-\d{2}$/;
　　　　var result = re.test('2010-12-20');

　　　　console.log(result)
　　　　// true

　　　　在正则表达式设置了

g

模式的情况下，跟

RegExp.exec

一样，会同时更新

RegExp

对象的

lastIndex

属性。

var pattern = /^\d{4}-\d{2}-\d{2}$/g;
　　　　pattern.test('2010-12-20'); // true
　　　　pattern.test('2010-12-20'); // false

　　　　RegExp.test

在匹配成功之后，各个捕获分组的文本会保存下来，用

RegExp.$1

，

RegExp.$2

··· 就可以获得，不过，保存整个表达式匹配文本的

RegExp.$0

并不存在。

String 对象

　　方法

　　　　String.match

返回一个结果数组或

null

。

　　　　在正则表达式设置了

g

模式的情况下，

match

默认返回所有可能的匹配结果。

　　　　var str = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
　　　　var re = /[A-E]/gi;
　　　　var matches = str.match(re);

　　　　console.log(matches);
　　　　// ['A', 'B', 'C', 'D', 'E', 'a', 'b', 'c', 'd', 'e']

　　　　如果正则表达式没有设置

g

模式，那么

match

方法返回的结果与

RegExp.exec()

一致。

　　　　var str = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
　　　　var re = /[A-E]/i;
　　　　var matches_1 = str.match(re);
　　　　var matches_2 = re.exec(str)

　　　　console.log(matches_1, matches_2)

　　　　//[ 'A',
　　　　 index: 0,
　　　　input: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz' ]

　　　　该返回结果包含匹配的字符串，还有一个额外的

index

属性，表示匹配字符串的位置，

input

属性即是所传入的字符串。

　　　　String.search

返回第一次匹配的位置或

-1

　　　　该方法用来寻找某个正则表达式在字符串中第一次匹配成功的位置，失败的时候返回

-1

。

　　　　这个方法只能找到“第一次”，即使设置了

g

模式，结果也不会有任何变化，所以如果需要使用一个正则表达式多次验证字符串，调用该方法判断结果是否为 0，是更好的办法。

　　　 "1234".search(/^\d+$/g) == 0 // true
　　　　"5678".search(/^\d+$/g) == 0 // true

　　　　var pattern = /^\d+$/g;
　　　　pattern.test("1234"); // true
　　　　pattern.test("5678"); // false

　　　　String.split

使用一个正则表达式来切割字符串。返回数组

　　　　正则表达式是否设置了

g

模式对结果没有影响。

　    var matchArray = "a b c".split(/\s+/);

　　　　console.log(matchArray);
　　　　// ["a", "b", "c"]

　　　　也可以设置第二个参数

limit

，指定返回数组的数目。在 JS 中，该参数取值的结果如下

取值	结果
limit < 0 || limit > n	等同于未指定
0<=limit<=n	返回一个包含 n 元素的数组

　　　　var matchArray = "a b c".split(/\s+/,2);

　　　　console.log(matchArray);
　　　　// ["a", "b"]