javascript正则表达式

我接触正则的第一个例子：
找出字符串中全部数字：

 1 var str = '1 h2jg2hj3g4ghj23423hj1';
 2 //要求输出结果["1", "2", "2", "3", "4", "23423", "1"]
 3 
 4 var arr = [];
 5 var tmp = '';
 6 
 7 for (var i=0; i<str.length; i++) {
 8     var v = parseInt(str.charAt(i));
 9 
10     if (!isNaN(v)) {
11         tmp += v;
12     } else {
13         if (tmp != '') {
14             arr.push(tmp);
15             tmp = '';
16         }
17     }
18 }
19 
20 if (tmp != '') {
21     arr.push(tmp);
22 }
23 
24 console.log(arr);

一样的需求用正则超简单

1 var arr2 = str.match(/\d+/g);
2 console.log(arr2);

1，正则的写法：

var re1 = new RegExp('a'); // 写法1
console.log(re1);
var re2 = /a/;  // 写法2
console.log(re2);

// 想起了一样有两种写法的 数组和json
//var j1 = new Object();
//var j2 = {};

//var arr1 = new Array(1,2,3);
//var arr2 = [1,2,3];

2，

转义：转换意思

转义字符：有特殊意义的字符

/**
 *  \
 *  \n 换行
 *  \r 回车
 *  \t 制表符
 *  \a 响铃
 */
//alert('通知\\n\'今天有雨，请不要带伞！\'');

var re3 = /\d/;
console.log(re3);
var re4 = new RegExp('\\d'); //两种写法的不一样
console.log(re4);

3，正则表达式经常使用方法

 1 /*
 2 * 方法：
 3 * test:
 4 * 正则对象.test(字符串) : 若是字符串中有正则对象匹配的内容，返回true，不然返回false
 5 * */
 6 alert( /\d/.test('ab1sd') );  // \d表明一个数字，在字符串中找到了，返回true
 7 
 8 /*
 9 * search：
10 * 字符串.search(要查找的字符能够接受正则) : 返回要查找的字符（或者正则匹配的内容）在前面的字符串中首次出现的位置，search参数支持正则
11 * */
12 // 找出’a’所在的位置
13 var str = 'abc';
14 alert(str.indexOf('a'));
15 alert(str.search('a'));
16 alert(str.search(/a/));
17 var str2 = 'Ab9c';
18 alert(str2.search(/a/i)); //i ： 当前正则匹配的内容不区分大小写
19 
20 /*
21 * match:
22 * 字符串.match(字符串|正则) : 在前面在字符串中搜索参数（字符串|正则）匹配的内容，并用数组的形式返回匹配的结果，若是匹配不成功返回null。
23 * */
24 var str = ‘haj123’;    var re = /\d/;     alert( str.match(re) ); //[1]    由于正则匹配成功就会结束，不会继续匹配。
25 var str = '1 h2jg2hj3g4ghj23423hj1';
26 var arr = str.match(/\d+/g); // g：全局匹配 +：量词，前面的规则匹配一次或者n次
27 console.log(arr);  //["1", "2", "2", "3", "4", "23423", "1"]
28 
29 /*
30 * replace：
31 * 字符串.replace(要查找的内容，替换内容) : 用“替换内容”替换在字符串中查找到的“要查找的内容”
32 * replace的第二个参数能够接受函数,当有内容被匹配的时候，这个函数就会被执行
33 * 这个函数在执行的时候会接收到一些参数，而且这个函数的返回值将做为当前这一次替换的内容
34 *     第一个参数：当前这一次匹配的内容
35 * */
36 var str = 'abaAc';
37 //var s1 = str.replace('a', '*');
38 //console.log(s1); *baAc
39 
40 var s2 = str.replace(/a/gi, '*');
41 //console.log(s2); *b**c

 1 //敏感词过滤：
 2 var str2 = "而且这个函数的返回值将做为当前这一次替换的内容";
 3 
 4 var s3 = str2.replace(/函数|返回值|内容/g, '*');
 5 //console.log(s3); //"而且这个*的*将做为当前这一次替换的*"
 6 
 7 var s3 = str2.replace(/函数|返回值|内容/g, function(a) {
 8     //console.log(a);
 9     //return 1;
10 
11     var s = '';
12     for (var i=0; i< a.length; i++) {
13         s += '*';
14     }
15 
16     return s;
17 
18 });
19 console.log(s3); //"而且这个**的***将做为当前这一次替换的***"

 1 /*
 2 * 子项表达式：
 3 * replace
 4 * 第一个参数是整个表达式当前匹配的内容
 5 * 后面的参数就是当前此次匹配的内容的子项对应的内容
 6 * */
 7 var str = 'a1ca2cb33ca56c';   //=>12b33c56
 8 
 9 /*var s1 = str.replace(/a((\d)+)(c)/g, function(a, b, c, d) {
10     console.log(a); //a1c a2c a56c
11     console.log(b); //1 2 56 总结出规律：参数依次表明的子项是按正则表达式中左小括号的顺序来排的
12 })*/
13 
14 var s1 = str.replace(/a(\d)+c/g, function(a, b) {
15     console.log(a); 
16     console.log(b);//匹配的是6
17 })

 1 /*
 2 * 小例子：
 3 * 日期处理
 4 * */
 5 var d1 = '2015-3-31';
 6 var d2 = '2015.3.31';
 7 var d3 = '2015/3/31';
 8 var d4 = '2015.3-31';
 9 var d5 = '2015/3-31';
10 var d6 = '2015----3.31';
11 
12 //'2015年3月31日'
13 //\d 一个数字  \D 一个非数字
14 
15 console.log( formatDate(d1) );
16 console.log( formatDate(d2) );
17 console.log( formatDate(d3) );
18 console.log( formatDate(d4) );
19 console.log( formatDate(d5) );
20 console.log( formatDate(d6) );
21 
22 function formatDate(d) {
23     return d.replace(/(\d+)\D+(\d+)\D+(\d+)/g, function($0, $1, $2, $3) {
24         //console.log($0);
25         return $1 + '年' + $2 + '月' + $3 + '日';
26 
27     });
28 }

4，正则表达式字符类：
任意字符：[abc]
实例：o[ab]t——oat、obt 其余的oct就不符合要求了
范围：[a-z][0-9]
实例：id[0-9]——id0、id5。好比刚才的\d，能够写成[0-9]
排除：[^a]
实例:o[^0-9]t——oat、o?t、o t ；[^0-9a-z]
组合：[a-z0-9A-Z]

//[1-37] 匹配的是1-3和7；若是是1-37，正则应该这样写：([1-2]\d)|3[0-7]|\d

5，转义字符：

\d : 一个数字 至关于[0-9]
\w : 一个字符（字母、数字、下划线） [a-z0-9_]
\s : 一个空格
\D : 一个非数字 [^0-9] 例：/\D/判断不全是数字
\W : 一个非字符[^a-z0-9_]
\S : 一个非空格
\b : 一个边界符 (若是一个\w的左侧或者右侧再也不是一个\w，那么这个地方就会是一个边界符)
\B : 一个非边界符

[^0-9] 中括号中的第一个若是是^，那么表明取反 \D
. 点 : 任意字符 例：/<[^<>]>/g

1 例：
2 var str = 'my name is zmouse';
3 var s = str.replace(/\b/g, '|');
4 console.log(s); //"|my| |name| |is| |zmouse|"

6，子项

\1 : 重复匹配第一个子项匹配的内容
\2 : 重复匹配第二个子项匹配的内容
// /(\w)\s\1/ aa aa
// /(\d)(\s)\2\1/ => 1 1 2 2

 1 //例子：
 2 var str = 'assssjdssskssalsssdkjsssdss';
 3 var arr = str.split('');
 4 str = arr.sort().join(''); //先排序一下，让相同字符排到一块儿
 5 var value = '';
 6 var index = 0;
 7 
 8 var re = /(\w)\1+/g;
 9 str.replace(re,function($0,$1){
10         //alert($0);
11         if(index<$0.length){
12             index = $0.length;
13             value = $1;
14         }
15 });
16 alert('最多的字符:'+value+',重复的次数:'+index);

 1 var qq = '200824584';
 2 
 3 // ^ : 若是不是在中括号中出现，表示字符串的起始符
 4 // $ : 表示字符串的结束符
 5 
 6 if ( /^[1-9]\d{4,11}$/.test(qq) ) {
 7     alert('是qq');
 8 } else {
 9     alert('不是qq');
10 }

7，量词：出现的次数，匹配不肯定的位置

{n} : 正好出现n次
{n,m} : 最少n次，最多m次 例：QQ号码 ^[1-9]\d{4,11}$
{n,} : 最少n次，最多不限
+ : 至关于{1,} 最少1次，最多不限 例：/\d+/等同于/\d{1,}/
? : 至关于 {0,1} 最少0次，最多1次 例：固定电话，(0\d{2,3}-)?[1-9]\d{7}(-\d{1,5})?
* : 至关于{0,} 最少0次，最多不限

1 var str = ‘12 ff’; alert( str.macth(/\d*/g) ); //有错，由于空格和f会被认为出现0次数字

1 // 写了一个邮箱的验证：
2 var re = /^\w+@[a-z0-9]+(\.[a-z]){1,3}+$/;
3 if( re.test(oTxt.value) ){ alert(‘邮箱合法’); }else{ alert(‘你写错了’); }

1 // 去掉字符串先后空格
2 var str = '   my name is zmouse  ';
3 
4 console.log( trim(str) );
5 
6 function trim(s) {
7     return s.replace(/^\s+|\s+$/g, '');
8 }