正则表达式

3次阅读

共计 3857 个字符,预计需要花费 10 分钟才能阅读完成。

第 1 章 认识正则

所谓正则,其实就是字符串规则表达式,比如说大家熟悉的 ”*” 代表的是所有字符. 其实不应该叫正则表达式,你叫它规则表达式更好,因为它的主要作用就是,通过规则,找出你想要找的东西。

1. 描述你要找的字符串的规律。
2. 调用函数,执行该正则表达式。

1.php

// 把字符串的 'hi' 找出来
// 规律:'hi'
$str = 'hi,this is his history';
$patt = '/hi/';
preg_match_all($patt,$str,$res);
print_r($res);

程序员都会用到,但是平常用的不多,所以容易忘。

入手: 找谁?怎么找?找几个?

  • 具体字符(字面值) –> 比如说就找 a,b,hi
  • 字符边界(下面加粗) –> 从哪开始到哪结束
  • 字符集合[ace],[0123456789] –> 里面任意条件符合找出来
  • 字符补集1: 不在 qxz 范围内 –> 里面任意条件符合的不要
  • 字符范围[a-z0-9] –> 注意: 必须是连续的,你不能写 a -Z
  • 字符簇(系统定义好的常用集合,在第二章) –> 系统定义好的常用集合

字符边界

  • ^ 匹配字符串的开始
  • $ 匹配字符串的结尾
  • \b 匹配单词的开始和结尾(边界)
  • \B 匹配单词的非边界

第 2 章 常用字符簇

代表
.(点) 任意字符,不含换行
w [a-zA-Z0-9 _]
W W 的补集
s 空白符,包括 nrtv 等
S 非空白符
d [0-9]
D 非数字

第 3 章 单词匹配

// 把字符串的 hi 单词找出来
// 规律,单词开始处 =>hi=> 单词结束处 \b
$str = 'hi,this is some history book';
$patt = '/\bhi\b/';
preg_match_all($patt,$str,$res);
print_r($res);

// 把包括在单词内部的 hi 找出来
$patt = '/\Bhi\B/';
$str = ''

第 4 章 集合与补集示例

/*
给定一组手机号,必须由 [0123456789] 组成的,才选出来从哪找? 从字符串的开始找,找到字符串的结束 ^ $ 
找谁[01235689]
找几个?11 个
*/
$arr = array('13800138000','13487656887','434456','45454353434543');
//$patt = '/^[^47]{11}$/'; // 补集方法
$patt = '/^[01235689]{11}$/';// 集合方式
foreach($arr as $v){preg_match_all($patt,$v,$res);
    print_r($res);
}

第 5 章 字符范围

// 试着找纯字母组成的单词
$str = 'o2o,b2b,hello,wordl,that';
//$patt = '/\[a-zA-Z]{1,}\b'; //{1,}最少 1 个字母
$patt = '/\b[a-zA-Z]+\b';
preg_match_all($patt,$str,$res);
print_r($res);

第 6 章 字符簇

就是系统规定好的标识方法

$str = 'tommorw is another day,o2o,you dont bird me i dont bird you';
$patt = '/\W{1,}';// \w \w[a-zA-Z0-9_]的补集
//preg_split 通过正则的表达式,分割字符串
print_r(preg_split($patt,$str));

// 把多个空格或者制表符换成一个空格
$str = 'a     b        hello          world';//'a b hello world';
$patt = '/\s{1,}/'; //\s 空白符,包括 \n\r\t\v 等
//preg_replace - 执行一个正则表达式的搜索和替换
echo preg_replace($patt,' ',$str);

第 7 章 找几个

  • * 匹配前面的子表达式零次或多次。
  • + 匹配前面的子表达式一次或多次。
  • ? 匹配前面的子表达式零次或一次。
  • {n} n 是一个非负整数。匹配确定的 n 次。
    {n,m} m 和 n 均为非负整数,其中 n <= m
  • 最少匹配 n 次且最多匹配 m 次。。
  • {n,} n 是一个非负整数。至少匹配 n 次。
$str = 'longren lao wang meng ge bi';
// 5 个字母组成的单词
//$patt = '/\b[a-zA-Z]{5}\b/';

// 3- 5 个字母组成的单词
//$patt = '/\b[a-zA-Z]{3,5}\b/';

// 5 个以上字母组成的单词
//$patt = '/\b[a-zA-Z]{5,}\b/';

preg_match_all($patt,$str,$res);
print_r($res);
/*
某编辑部,键盘坏了,0 键弹不出来,经常打出多个 0
于是 god 打成 good,gooood,请把这些单词替换成 god
*/
$s = 'goooood,goood,goooooooooood';
$p = '/go+d/';
print_r(preg_replace($p,'god',$s));

第 8 章 或者的用法

// 查询纯数字或者纯字母的词
$str = 'hello o2o 2b9 250';
$patt = '/\b[a-zA-Z]+\b|\b[0-9]+\b/';// 最少一个
preg_match_all($patt,$str,$res);
print_r($res);

// 查询苹果系统的产品
$str = 'ipad,iphone,imac,ipod,iamsorry';
$patt = '/\bi(pad|phone|mac|pod)\b/';
preg_match_all($patt,$str,$res);
print_r($res);

第 9 章 贪婪与非贪婪

$str = 'ksda good goooood good kl s ja dfs dk';
// 把 g(任意多的内容)d 这样的字符串,换成 god
$patt = '/g.+d/'; // 默认贪婪模式(会尽量多匹配)
preg_match_all($patt,$str,$res);
print_r($res); //god is not good

$patt = '/g.+?d/'; // 在数量 (+ * {n,}) 限定符后,加?,非贪婪模式
preg_match_all($patt,$str,$res);
print_r($res); //god,good

第 10 章 采集手机号

$str = '汤小姐,联系手机号:18611015252,备用电话:18828821111,QQ:381413622,email:381413622@qq.com,,身份证号:430426199901013478';\
// 采集电话号码 \
$patt = '/\b1[358]\d{9}\b/';\
preg_match_all($patt,$str,$res);\
print_r($res);

第 11 章 后向引用

找收尾字母相同的单词

$str = 'txt hello,high,bom,mum';
// 简化,先找到首尾字母都是 t 的
$patt = '/\bt\w+t\b/';
preg_match_all($patt,$str,$res);
print_r($res);

此方法重复 26 次,也能找到

// 第 n 个小括号内的子表达式,命中的内容,后面就用 \n 来引用
// 后向引用
$patt = '/\b([a-z])\w+\1\b/';
//1. 单词开始和结束 \b\b
//2. 开始的 [a-z] 都可以.\b[a-z]\b
//3. 后面跟什么都行,不管. 并且字数不限 \b[a-z]\w+\b
//4. 最后一个应该和第一个相同.\b([a-z])\w+\b 子表达式,放在下面另一个数组里面,最后一个引用子表达式匹配出来的结果 \b([a-z])\w+\1\b
preg_match_all($patt,$str,$res);
print_r($res);

把手机号中间的 4 位替换为 *

$str = '13800138000,13426060134';
// 前 3 位和后 4 位放子表达式中,中间 4 位随便,保留子表达式. 替换中间的 4 位
$patt = '/(\d{3})\d{4}(\d{4})/';
//preg_match_all($patt,$str,$res);
//print_r($res);
echo preg_replace($patt,'\1****\2',$str);

第 12 章 模式

模式修饰符,可以一定程度上影响正则的解析行为
比如 i,就代表正则不区分大小写,/[a-z A-Z]+/ —>/[a-z]+/i
比如 s,单行模式,就代表把整个文件看成一个 ” 单行 ”,忽略回车

$str = 'hello WORLD  ChINa';
//$patt = '/\b[a-z]+\b/'; //hello
$patt = '/\b[a-z]+\b/i'; // 忽略大小写
preg_match_all($patt,$str,$matches);
print_r($matches);


$str = "abc haha
abc dgh";
$patt = '/.+/s'; # single 单行模式,将所有内容看成一整行
preg_match_all($patt,$str,$matches);
print_r($matches);
//U 模式,把传入的参数看成 unicode 字符集的编码,可以判断中文
// http://blog.sina.com.cn/s/blog_640937d101017pca.html
// PHP 下正则匹配中文,u 模式,\x{4e00}-\x{9fa5}

$str = 'bob 李';
$patt = '/^[\x{4e00}-\x{9fa5}]+$/u';
echo preg_match($patt,$str)?'国货':'杂货';

  1. qxz ↩
正文完
 0

正则表达式

3次阅读

共计 1176 个字符,预计需要花费 3 分钟才能阅读完成。

[…]中括号在正则表达式里面也是一个非常常用的知识点,它的主要作用是设置一个 集合 范围。

一:集合
[abc] 在正则表达式里表示一个包含 a 或者 b 或者 c 的集合,匹配三者之中的 任意一个 。注意元素之间不用空格和逗号隔开,因为在正则表达式里,[] 里的空格或者逗号也会被判定为一个匹配元素。
来看一个例子:

let reg = /1[abc]2/g;
'1a2'.match(reg); //["1a2"]
'1b2'.match(reg); //["1b2"]

上面的正则表达式需要匹配的是数字 1 和 2 之间为 a,b,c 三者中的任意一个。所以‘1a2’, ‘1b2’ 都可以匹配。
再看下面一个例子:

let reg = /1[abc]2/g;
'1abc2'.match(reg); //null

仍然是上面的正则表达式,但是‘1abc2’是不匹配的。这里要注意的一点就是 […] 里面的元素,当只有出现其中的任意 一个 时才能匹配,可以理解为 […] 里面的元素 只占一个位置。我们这里的 abc 占了三个位置,是不匹配我们给出的正则的。

二:范围
[1-9] 表示数字 1 到 9 之间任意一个数字,[a-z]表示 a 到 z 之间的任意一个小写字母。在 [] 里用连字符(-)链接一个范围的两边,就能用来表示一个范围。

let reg = /[1-9][a-z]/g;
'5d'.match(reg); //["5d"]
'd1'.match(reg); // null

三:集合和范围之外

[^]当我们在中括号里的元素前加上一个 ^,就表示匹配 除此之外 的元素。

 [^abc] 除了 'a','b', 'c' 之外的任意字符
 [^0-9] 除了数字之外的任意字符,等同于 \D
 [^\s] 除了空格之外的任意字符,等同于 \S

看一个例子:

let reg = /[^0-9a-z]/ig;
'nana123@gmail.com'.match(reg); //["@", "."]

这里我们需要匹配除了字母和数字之外的字符,所以我们匹配到了 ”@” 和 ”.” 这两个字符。

四:[…]里的元字符
我们知道元字符都有特色的含义与作用,比如 ”.”, “+”, “?”, “()” 等,如果我们要把他们作为普通字母匹配,需要用 ”” 转义。例如,如果我们要匹配 ”.”, 需要用到 ”.”。但是当他们出现在 [] 里面的时候,就失去了他们特色的作用,就做回了自己本身,也不需要再用后斜杠转义。

但是前面我们也讲到 ^ 出现在 [] 内部最前面,还有 ”-“ 出现在 [a-z] 这种情况下,还是有特殊意义的。那么当 ^ 不出现在 [] 内部最前面,还有 ”-“ 不出现在 [a-z] 这种情况下,他们也就是自己本身。例如:

let reg = /[-().^+]/g;
"1 + 2 - 3".match(reg); //["+", "-"]

这里的 ”^” 和 ”-“ 都只是字符本身,所以我们能匹配到 [“+”, “-“]。
当然如果在 [] 里面给这些元字符转义加上 ””,也不会有错,依然能匹配得到。

正文完
 0

正则表达式

3次阅读

共计 5139 个字符,预计需要花费 13 分钟才能阅读完成。

RegExp 对象
Regular Experssion 使用单个字符串来描述、匹配一系列符合某个句法规则的字符串
测试网站:https://regexper.com
创建方式
字面量
var reg = /\bis\b/g
“he is a boy”.replace(reg,’IS’)
//”he IS a boy”
构造函数
var reg = new RegExp(‘\\bis\\b’,’g’);
“he is a boy”.replace(reg,’IS’)
//”he IS a boy”
元字符正则表达式由两种基本字符类型组成:

原义文本字符

元字符

元字符是在正则表达式中有特殊含义的非字母字符

* + ? $ ^ . | \ () {} []

字符类
一般情况下正则表达式一个字符对应字符串一个字符
表达式 ab\t 的含义是
![](https://user-gold-cdn.xitu.io/2019/1/25/16885330303c07df?w=155&h=43&f=png&s=3294)

我们也可以使用元字符 [] 来构建一个简单的类
所谓类是指符合某些特征的对象,一个泛指,而不是特指某个字符
表达式 [abc] 把字符 a 或 b 或 c 归为一类,表达式可以匹配这类的字符,
‘a1b2c3d3′.replace(/[abc]/g,’X’)
“X1X2X3d3″
字符串取反

使用元字符 ^ 创建反向类 / 负向类
反向类的意思是不属于某类的内容
表达式 [^abc] 表示不是字符 a 或 b 或 c 的内容

范围类

正则表达式还提供了范围类
可以用 [a-z] 来连接两个字符表示从 a 到 z 的任意字符

这是个闭区间,也就是包含 a 和 z 本身

‘a1b2c3d4x5z6′.replace(/[a-z]/g,’X’)
//”X1X2X3X4X5X6″

在 [] 组成的类内部是可以连写的[a-zA-Z]

‘a1b2c3d4x5z6DSFDAFDAFD’.replace(/[a-zA-Z]/g,’X’)
//”X1X2X3X4X5X6DSFDAFDAFD”
这种情况下如何匹配到 ’-‘? 只需要在后面补上一个 ’-‘ 就行了
‘a1b2-c-3d4x5z6DS-F-DAFDAFD’.replace(/[a-zA-Z-]/g,’X’)
//”X1X2XXX3X4X5X6XXXXXXXXXXXX”
JS 预定义类及边界
预定类:
“This is a boy”.replace(/\Bis\b/,’0′)
//”Th0 is a boy”
几个常用的边界匹配字符: 示例一:
“This is a boy”.replace(/is/g,’0′)
//”Th0 0 a boy”
只想替换第一个 ’is
“This is a boy”.replace(/\Bis\b/,’0′)
//”Th0 is a boy”
只想替换第二个
“This is a boy”.replace(/\bis\b/g,’0′)
//”This 0 a boy”
示例二:
“@123@345@”.replace(/@./g,’Q’)
//”Q23Q45@”
只想替换第一个
“@123@345@”.replace(/^@./g,’Q’)
//”Q23@345@”
只替换最后一个
“@123@345@”.replace(/.@$/g,’Q’)
//”@123@34Q”
var mulstr = “@123
@456
@678”;

mulStr.replace(/^@\d/gm,’x’)
// X123
X456
X678
量词
我们希望匹配一个连续出现 20 次数字的字符串:
显然不能用这中方式:\d\d\d\d\d\d\d\d\d\d\d\d\d\d\d\d\d\d\d\d\d

?

+*

JS 正则贪婪模式与非贪婪模式
贪婪模式正则表达式在匹配的时候会尽可能多的匹配,直到匹配失败
“12345678”.replace(/\d{3,6}/g,’X’)
//”X78″

//123456 -> X
非贪婪模式

让正则表达式尽可能少的匹配,也就是说一旦成功匹配不再继续尝试就是非贪婪模式
做法很简单,在量词后面加上? 即可

“12345678”.replace(/\d{3,6}?/g,’X’)
//”XX78″

//123,456 -> X,X
分组

()匹配字符串 Byron 连续出现三次的场景,可能会用 Byron{3}
并不能达到我们期待的结果,只会处理紧挨着的,用 () 可以达到分组的功能,使量词作用域分组:

‘a1b2c3d4′.replace(/[a-z]\d{3}/g,’X’)
//”a1b2c3d4″
‘a1b2c3d4′.replace(/([a-z]\d){3}/g,’X’)
//”Xd4″

使用 | 达到效果 Byron|Casper

‘ByronCasper’.replace(/Byron|Casper/g,’X’)
// “XX”
‘ByronsperByrCasper’.replace(/Byr(on|Ca)sper/g,’X’)
//”XX”
反向引用
2015-12-25 –> 12/25/2015
‘2015-12-25’.replace(/(\d{4})-(\d{2})-(\d{2})/g,’$2/$3/$1′)
//”12/25/2015″

忽略分组
不希望捕获某些分组,只需要在分组内加上?: 就可以(?:Byron).(ok)
不让捕获分组
前瞻

正则表达式从文本头部向尾部开始解析,文本尾部方向

前瞻就是在正则表达式匹配到规则的时候,向前检查是否符合断言,后顾 / 后瞻方向相反
javascript 不支持后顾
符合和不符合特定断言称为肯定 / 正向匹配和否定 / 负向匹配

前瞻
‘a2*3′.replace(/\w(?=\d)/g,’X’)
//”X2*3″
JS 对象属性
对象属性

g:global 全文搜索,不添加,搜索到第一个匹配停止

i:ignore case 忽略大小写,默认大小写敏感

m:multiple lines 多行搜索

lastIndex: 是当前表达式匹配内容的最后一个字符的下一个位置

source: 正则表达式的文本内容框

var reg1 = /\w/
var reg2 = /\w/gim

reg1.ignoreCase
//false

reg1.multiline
//false

reg1.global
//false

reg2.ignoreCase
//true
reg2.multiline
//true
reg2.global
//true
test 和 exec 方法
test
RegExp.prototype.test(str)

用于测试字符串参数中是否存在匹配正则表达式模式的字符串
如果存在则返回 true,不存在则返回 false

var reg1 = /\w/
var reg2 = /\w/g

while(reg2.test(‘ab’)){
console.log(reg2.lastIndex)
}

//1
//2

exec
RegExp.prototype.exec(str)

使用正则表达式模式对字符串执行搜索,并将更新全局 RegExp 对象的属性以反映匹配结果

如果没有匹配的文本则返回 null,否则返回一个结果数组

index 声明匹配文本的第一个字符的位置

input 存放被检索的字符串 string

非全局调用

调用非全局的 RegExp 对象的 exec()时,返回数组
第一个元素是与正则表达式相匹配的文本
第二个元素是与 RegExpObject 的第一个子表达式相匹配的文本(如果有的话)
第三个元素是与 RegExp 对象的第二个子表达式相匹配的文本(如果有的话),以此类推

var reg3 = /\d(\w)(\w)\d/
var reg4 = /\d(\w)(\w)\d/g
var ts = ‘1az2bb3cy4dd5cc’

var ret = reg3.exec(ts)

console.log(reg3.lastIndex+’\t’+ret.index+’\t’+ret.toString())
//”0 0 1az2,a,z”
// 非全局 lastIndex 不生效,reg3.lastIndex 并未生效
console.log(reg3.lastIndex+’\t’+ret.index+’\t’+ret.toString())
//”0 0 1az2,a,z”

while(ret = reg4.exec(ts)){
console.log(reg4.lastIndex+’\t’+ret.index+’\t’+ret.toString())
}
//”4 0 1az2,a,z”
//”10 6 3cy4,c,y”

字符串对象方法
String.prototype.search(reg)

search()方法用于检索字符串中指定的子字符串,或检索与正则表达式相匹配的子字符串
方法返回第一个匹配结果 index,查找不到返回 -1

search()方法不执行全局匹配,它将忽略标志 g,并且总是从字符串的开始进行检索

‘dafd1afd’.search(/1/g)
//4
// 输入数字也能匹配到,尝试往正则表达式转
String.prototype.match(reg)

match()方法将检索字符串,以找到一个或多个与 regexp 匹配的文本

regexp 是否具有标志 g 对结果影响很大

非全局调用

如果没有 regexp 没有标志 g,那么 match()方式就只能在字符串中执行一次匹配
如果没有找到任何匹配的文本,将返回 null

找到了它将返回一个数组,其中存放了与它找到的匹配文本有关的信息

返回数组的第一个元素存放的是匹配文本,而其余的元素存放的是与正则表达式的子表达式匹配的文本

除了常规的数组元素之外,返回的数组还包含了两个对象属性

index 声明匹配文本的起始字符,在字符串的位置

input 声明,对 stringObject 的引用

var reg3 = /\d(\w)\d/
var reg4 = /\d(\w)\d/g
var ts = ‘$1a2b3c4d5e’

var ret = ts.match(reg3)
console.log(ret)
console.log(ret.index+’\t’+reg3.lastIndex)

//[“1a2”, “a”, index: 1, input: “$1a2b3c4d5e”, groups: undefined]
// 1 0
全局调用

如果 regexp 具有标志 g 则 match()方法将执行全局检索,找到字符串中的所有匹配字符串

没有找到任何匹配的字符串,则返回 null

如果找到了一个或多个匹配字符串,则返回一个数组

数组元素中存放的是字符串中所有的匹配子串,而且也没有 index 属性或 input 属性

var reg3 = /\d(\w)\d/
var reg4 = /\d(\w)\d/g
var ts = ‘$1a2b3c4d5e’

var ret = ts.match(reg4)
console.log(ret)
console.log(ret.index+’\t’+reg4.lastIndex)

//[“1a2”, “3c4”]
//undefined 0
String.prototype.split(reg)
我们经常使用 split 方法将字符串分割为字符数组
‘a,b,c,d’.split(‘,’) //[“a”,”b”,”c”,”d”]
在一些复杂的分割情况下我们可以使用正则表达式解决
‘a1b2c3d’.split(/\d/);
//[“a”, “b”, “c”, “d”]
‘a1.b|2c3d’.split(/\.|\|/);

//[“a1”, “b”, “2c3d”]
String.prototype.replace()
String.prototype.replace(str,replaceStr)
‘a1b1c1’.replace(‘1’,2)
//”a2b1c1″
String.prototype.replace(reg,replaceStr)
‘a1b1c1’.replace(/1/,2)
//”a2b1c1″
String.prototype.replace(reg,function)

function 会在每次匹配替换的时候调用,有四个参数

1、匹配字符串
2、正则表达式分组内容,没有分组则没有该参数
3、匹配项在字符串中的 index

4、原字符串

‘a1b2c3d4’ => ‘a2b3c4d5’

‘a1b2c3d4e5’.replace(/\d/g,function(match,index,origin){
console.log(index)
return parseInt(match) + 1
})
// 1
//3
//5
//7
//9
//”a2b3c4d5e6″

‘a1b2c3d4e5’.replace(/(\d)(\w)(\d)/g,function(match,group1,group2,group3,index,origin){
console.log(index)
return parseInt(group1)+parseInt(group3)
})
// 1
//5
//”a3c7e5″

正文完
 0

正则表达式

3次阅读

共计 2749 个字符,预计需要花费 7 分钟才能阅读完成。

校验基本日期格式:var reg = /^(\d{1,4})(-|\/)(\d{1,2})\2(\d{1,2})$/;var r = fieldValue.match(reg);if (r==null) {alert(‘Date format error!’);}
1 . 校验密码强度
密码的强度必须是包含大小写字母和数字的组合,不能使用特殊字符,长度在 8 -10 之间。
var reg = /^(?=.\d)(?=.[a-z])(?=.*[A-Z]).{8,10}$/;
校验中文
字符串仅能是中文。
var reg = /^[\u4e00-\u9fa5]{0,}$/;
由数字、26 个英文字母或下划线组成的字符串
var reg = /^\w+$/;
校验 E -Mail 地址
同密码一样,下面是 E -mail 地址合规性的正则检查语句。
var reg = /[\w!#$%&’+/=?^_{|}~-]+(?:\\.[\\w!#$%&’*+/=?^_{|}~-]+)@(?:\w?\.)+\w?/;
校验身份证号码
下面是身份证号码的正则校验。15 或 18 位。
15 位:
var reg = /^[1-9]\d{7}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{3}$/;18 位:
var reg = /^[1-9]\d{5}[1-9]\d{3}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{3}([0-9]|X)$/;
校验日期
“yyyy-mm-dd“格式的日期校验,已考虑平闰年。
var reg = /^(?:(?!0000)[0-9]{4}-(?:(?:0[1-9]|1[0-2])-(?:0[1-9]|1[0-9]|2[0-8])|(?:0[13-9]|1[0-2])-(?:29|30)|(?:0[13578]|1[02])-31)|(?:[0-9]{2}(?:0[48]|2468|13579)|(?:0[48]|2468|13579)00)-02-29)$/;
校验金额
金额校验,精确到 2 位小数。
var reg = /^[0-9]+(.[0-9]{2})?$/;
校验手机号
下面是国内 13、15、18 开头的手机号正则表达式。(可根据目前国内收集号扩展前两位开头号码)
var reg = /^(13[0-9]|14[5|7]|15[0|1|2|3|5|6|7|8|9]|18[0|1|2|3|5|6|7|8|9])\d{8}$/;
判断 IE 的版本
IE 目前还没被完全取代,很多页面还是需要做版本兼容,下面是 IE 版本检查的表达式。
var reg = /^.MSIE 5-8?(?!.Trident\/[5-9]\.0).*$/;
校验 IP-v4 地址
IP4 正则语句。
var reg = /\b(?:(?:25[0-5]|20-4|[01]?0-9?)\.){3}(?:25[0-5]|20-4|[01]?0-9?)\b/;
校验 IP-v6 地址
IP6 正则语句。
var reg = /(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))/;
检查 URL 的前缀
应用开发中很多时候需要区分请求是 HTTPS 还是 HTTP,通过下面的表达式可以取出一个 url 的前缀然后再逻辑判断。
var reg = /^[a-zA-Z]+:\/\//;if (!s.match(/^[a-zA-Z]+:\/\//)) {s = ‘http://’ + s;}
提取 URL 链接
下面的这个表达式可以筛选出一段文本中的 URL。
var reg = /^(f|ht){1}(tp|tps):\/\/([\w-]+\.)+[\w-]+(\/[\w- ./?%&=]*)?/;
文件路径及扩展名校验
验证 windows 下文件路径和扩展名(下面的例子中为.txt 文件)
var reg = /^([a-zA-Z]\:|\\)\\(1+\\)*2+\.txt(l)?$/;
提取 Color Hex Codes
有时需要抽取网页中的颜色代码,可以使用下面的表达式。
var reg = /^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/;
提取网页图片
假若你想提取网页中所有图片信息,可以利用下面的表达式。
var reg = /\< [img]3[src] = [\”\’]{0,1}(4*)/;
提取页面超链接
提取 html 中的超链接。
var reg = /(])(href=”https?:\/\/)((?!(?:(?:www\.)?’.implode(‘|(?:www\.)?’, $follow_list).’))5+)”((?!.\brel=)6)(?:6)>/;
查找 CSS 属性
通过下面的表达式,可以搜索到相匹配的 CSS 属性。
var reg = /^\s[a-zA-Z\-]+\s[:]{1}\s[a-zA-Z0-9\s.#]+[;]{1}/;
抽取注释
如果你需要移除 HMTL 中的注释,可以使用如下的表达式。
var reg = /<!–(.*?)–>/;
匹配 HTML 标签
通过下面的表达式可以匹配出 HTML 中的标签属性。
var reg = /<\/?\w+((\s+\w+(\s=\s(?:”.?”|’.?’|[\^'”>\s]+))?)+\s|\s)\/?>/;

\\ ↩

\/:*?”<>| ↩

\\> ↩

\”\’\ > ↩

” ↩

> ↩

正文完
 0