正则表达式初识

什么是正则表达式

正则表达式是有以下两种字符组成的文字模式，该模式描述在查找文字时待匹配的的一个或多个字符串。正则表达式作为一个模板，将某个字符模式与所搜索的字符串进行匹配。
1，普通字符（例如26个英文字母，数字等）
2，特殊字符（有特殊含义的，例如.\等）

为什么使用正则表达式

查找字符串，替换字符串，数据有效性验证

创建正则表达式的两种方式

// 字面量的方式
var pattern = /js/;
var pattern = /js/i;

// 构造函数的方式
var pattern = new RegExp('js');
var pattern = new RegExp('js','i');

// 当正则表达式是可变的情况下，建议使用构造函数的方式

使用正则表达式

// 正则表达式的test方法，如果找到返回true，如果没找到返回false
// 正则表达式的exec方法，如果找到返回数组，如果没找到返回null
var str = "I love js";
var pattern1 = /js/;
var pattern2 = new RegExp("js");

console.log(pattern1.test(str)); // true
console.log(pattern1.exec(str)); // ["js"]

console.log(pattern2.test(str)); // true
console.log(pattern2.exec(str)); // ["js"]

正则表达式的模式修饰符

• i ignoreCase 忽略大小写

var str = "I love Js";
var pattern1 = /js/;
var pattern2 = /js/i;

console.log(pattern1.test(str)); // false
console.log(pattern1.exec(str)); // null

console.log(pattern2.test(str)); // true
console.log(pattern2.exec(str)); // ["Js"]

• g global 全局匹配
• m multiline 多行匹配

正则表达式详解

简单的转义字符

// 匹配转义字符 "/"
var str = '// 我是注释';
var pattern = /\/\//;
console.log(pattern.exec(str));  // ["//"]  两条斜杠

// 匹配转义字符 "/"
var str = '\\\\';                // 这里其实是两条斜杠
var pattern = /\\\\/;            // 这里是要匹配两条斜杠
console.log(str);                // 结果：//
console.log(pattern.exec(str));  // ["//"]  两条斜杠

// 匹配换行符 "/n"
var str = '1.html\n2.css\n3.js';
var pattern = /\n/;
console.log(str);               // 1.html
                                // 2.css
                                // 3.js
console.log(pattern.exec(str)); // ["\n"]  换行符

// 匹配制表符 "/t"
var str = ' js';
var pattern = /\t/;
console.log(pattern.exec(str)); // ["   "]  制表符

// 用ASCII码匹配
var str = 'a\nb';
var pattern = /\x61\x0A\x62/;    // \x61是"a"的ASCII码，\x0A是"\n"的ASCII码，\x62是"b"的ASCII码
console.log(pattern.exec(str));  // ["a\nb"]

// 用Unicode码匹配，匹配汉字的时候会经常用到
// 中文汉字的Unicode范围：\u4e00-\u9fa5
var str = ' js';
var pattern = /\u0009/;          // /u0009是TAB的Unicode码
console.log(pattern.exec(str));  // ["  "]

字符类：匹配字符类中的任意一个字符

var str = 'sjavascript';
var pattern = /[js]/;               // 匹配js中的任意一个字符
console.log(pattern.exec(str));     // ["s"]

var str = 'javascript';
var pattern = /[^js]/;              // ^是取反的意思，这里是指匹配js以外的任意一个字符
console.log(pattern.exec(str));     // ["a"]

// 要保证前面一个字符 <= 后面一个字符
var str = 'javascript';
var pattern = /[a-z]/;              // 匹配 a-z 之间的任意一个字符
console.log(pattern.exec(str));     // ["j"]

var str = 'javascript';
var pattern = /[c-d]/;              // 匹配 c-d 之间的任意一个字符
console.log(pattern.exec(str));     // ["c"]

var str = 'javascript';
var pattern = /[c-c]/;              // 匹配字符 c
console.log(pattern.exec(str));     // ["c"]

var str = 'JavaScript2.0';
var pattern = /[a-zA-Z0-9]/;        // 匹配 a-z，A-Z，0-9 之间的任意一个字符
console.log(pattern.exec(str));     // ["J"]

var str = 'Alex帅';
var pattern = /[\u4e00-\u9fa5]/;    // 匹配汉字
console.log(pattern.exec(str));     // ["帅"]

常用字符类

// /./  =>  相当于 /[^\n]/，意思是除了换行符之外的任意字符都能匹配

var str = '3.1415926';
var pattern = /./;                  // 匹配除了换行符之外的任意字符
console.log(pattern.exec(str));     // ["3"]

var str = '3.1415926';
var pattern = /\./;                 // 匹配小数点.
console.log(pattern.exec(str));     // ["."]

var str = '\n';
var pattern = /./;                  // 匹配除了换行符之外的任意字符
console.log(pattern.exec(str));     // null

// /\w/  =>  相当于/[a-zA-Z0-9_]/
// /\w/  =>  相当于[^a-zA-Z0-9_]/

var str = '_@';
var pattern = /\w/;
console.log(pattern.exec(str));     // ["_"]

var str = '_@';
var pattern = /\W/;
console.log(pattern.exec(str));     // ["@"]

// /\d/  =>  相当于/[0-9]/
// /\d/  =>  相当于/[^0-9]/

var str = '00544s';
var pattern = /\d/;
console.log(pattern.exec(str));     // ["0"]

var str = '00544s';
var pattern = /\D/;
console.log(pattern.exec(str));     // ["s"]

// /\s/  =>  匹配空格和制表符
// /\S/  =>  匹配空格和制表符之外的所有字符

var str = ' abc';
var pattern = /\s/;
console.log(pattern.exec(str));    // [" "]

var str = ' abc';
var pattern = /\S/;
console.log(pattern.exec(str));     // ["a"]

// 延伸：\s，\d也可以放在[]中
var str = '1 1';
var pattern = /[\s\d]/;             // 匹配空格/制表符/数字0-9
console.log(pattern.exec(str));     // ["1"]

重复(量词)：匹配多个字符，默认情况下会尽量多匹配

// {2}  =>  匹配2个字符

var str = '110';
var pattern = /\d{2}/;              // 匹配两个数字
console.log(pattern.exec(str));     // ["11"]

// {1,2}  =>  匹配 >=1 并且 <=2 个字符
// 注意,2之间不要有空格

var str = '110';
var pattern = /\d{1,2}/;            // 匹配1个或2个数字
console.log(pattern.exec(str));     // ["11"]

// {1,}  =>  匹配 >=1 个字符

var str = '110';
var pattern = /\d{1,}/;             // 匹配1个以上数字
console.log(pattern.exec(str));     // ["110"]

// ！！注意：以下这种写法是错误的
// 人可以没有上限，但是必须要有下限
var str = '110';
var pattern = /\d{,2}/;            // 没有这种写法！！
console.log(pattern.exec(str));    // null

// ?  =>  {0,1}，匹配 >=0 并且<=1个字符
// 用于某个字符可有可无的场景

var str = '110';
var pattern = /\d?/;             // 相当于/\d{0,1}/，匹配0个或1个数字
console.log(pattern.exec(str));  // ["1"]

var str = 'abc';
var pattern = /\d?/;             // 相当于/\d{0,1}/，匹配0个或1个数字
console.log(pattern.exec(str));  // [""]，认为匹配到了0个数字

// *  =>  {0,}，匹配 >=0 个字符

var str = '110';
var pattern = /\d*/;             // 相当于/\d{0,}/，匹配0个以上数字
console.log(pattern.exec(str));  // ["110"]

// +  =>  {1,}，匹配 >=1 个字符

var str = '110';
var pattern = /\d+/;             // 相当于/\d{1,}/，匹配1个以上数字
console.log(pattern.exec(str));  // ["110"]

// 量词练习
// 要求：匹配字符串中的价格

var str = '肯德基豪华午餐：￥15.5！';

// 以下两种写法是一样的，都能匹配到
// 注意小数点是需要转义的，因为.在正则中时特殊字符，有特殊含义
var pattern = /\d+\.?\d*/;
var pattern = /\d{1,}\.{0,1}\d{0,}/;

console.log(pattern.exec(str));  // ["15.5"]

非贪婪匹配

// 量词 + ?
// 在条件允许的情况下，会尽量少的匹配
// 注意这里是 尽量，所以也是有可能匹配多个的

// 贪婪匹配
var str = 'aaab';
var pattern = /a+/;
console.log(pattern.exec(str));     // ["aaa"]

// 非贪婪匹配
var str = 'aaab';
var pattern = /a+?/;                // 只要匹配到1个，就可以了
console.log(pattern.exec(str));     // ["a"]

// 正则表达式总是会寻找第一个可能匹配的字符串

// 这个没有问题，不解释
var str = 'aaab';
var pattern = /a+b/;
console.log(pattern.exec(str));     // ["aaab"]

// 也许有人会觉得应该匹配的是"ab"，但是，并没有
// 刚才说了，非贪婪匹配，是在条件允许的情况下，尽量少的匹配

// 在这里，从左到右匹配的时候，"aa"，并没有匹配到。也就是说，条件不允许尽量少匹配。
// 既然条件不允许，那么就多匹配一些a吧，接着会找到"aaa"，这个是符合/a+?/的，但是也还没匹配到
// 接着，找到"aaab"，咦，这个刚好匹配到了，所以最终结果就是 ["aaab"]

var str = 'aaab';
var pattern = /a+?b/;
console.log(pattern.exec(str));     // ["aaab"]

// 非贪婪匹配练习
// 要求：只匹配第一个td的内容

// 由于默认是贪婪匹配，所以把两个td都匹配到了
var str = '<td><p>a</p></td><td><p>b</p></td>';
var pattern = /<td>.*<\/td>/;
console.log(pattern.exec(str));     // ["<td><p>a</p></td><td><p>b</p></td>"]

// 这里是非贪婪匹配，所以匹配到一个就结束了
var str = '<td><p>a</p></td><td><p>b</p></td>';
var pattern = /<td>.*?<\/td>/;
console.log(pattern.exec(str));     // ["<td><p>a</p></td>"]

选择：|

// | =>  选择其中的一个匹配
// 从正则表达式的左边开始匹配

// 示例1
var str = 'css html js';
var pattern = /html|css|js/;        // 匹配字符串"html"，或者"css"，或者"js"
console.log(pattern.exec(str));     // ["css"]

var str = 'css html js';
var pattern = /html|css|js/g;        // 匹配字符串"html"，或者"css"，或者"js"
console.log(pattern.exec(str));     // ["css"]

var str = 'ab';
var pattern = /a|ab/;               // 匹配字符串"a"，或者"ab"
console.log(pattern.exec(str));     // ["a"]

分组：()，默认情况下会捕获正则中的分组，并显示在结果里

// ()  =>  匹配组成的字符串
var str = 'abab';
var pattern = /(ab)+/;              // 匹配一组或一组以上的"ab"字符串
console.log(pattern.exec(str));     // ["abab", "ab"]，第一个是匹配到的结果，第二个是分组

var str = 'abcd';
var pattern = /(ab)(c)/;
console.log(pattern.exec(str));     // ["abc", "ab", "c"]，第一个是匹配到的结果，第二三个是分组

var str = 'abcd';
var pattern = /(a(b(c)))/;
console.log(pattern.exec(str));     // ["abc", "abc", "bc", "c"]
// 由此可见，第一个分组是(abc)，第二个分组是(bc)，第三个分组是(c)

// ?:  =>  不显示分组

var str = 'abcd';
var pattern = /(?:ab)c/;
console.log(pattern.exec(str));     // ["abc"]，只有匹配到的结果

引用：\1 \2 ...

// \1  =>  第一个分组

var str = 'ab cd ab';
var pattern = /(ab) cd \1/;         // 相当于 /(ab) cd (ab)/，\1 代表第一个分组，依次类推
console.log(pattern.exec(str));     // ["ab cd ab", "ab"]

// 引用练习
// 要求：找到p标签内部的内容

var str = '<p><a>这是一段文字</a></p>';
var pattern = /<([a-zA-Z]+)>(.*?)<\/\1>/;
// 对于一个标签来说，开始和结尾肯定都是一样的，比如<p></p>
// 这里先用分组([a-zA-Z]+)找到开头的标签名，然后使用引用 \1 ，保证结束的标签名也是一样的
// 如果不用引用，无法保证标签的开始名和结束名一致

console.log(pattern.exec(str));     
// ["<p><a>这是一段文字</a></p>", "p", "<a>这是一段文字</a>"]
// 数组中的第三个元素就是我们想要的内容

位置匹配：^(首) $(尾)

// ^  =>  首匹配

var str = 'js html';
var pattern = /^js/;                // 匹配以"js"开始的字符串
console.log(pattern.exec(str));     // ["js"]

var str = 'html js';
var pattern = /^js/;                // 匹配以"js"开始的字符串
console.log(pattern.exec(str));     // null

// $  =>  尾匹配

var str = 'html js css';
var pattern = /js$/;                // 匹配以"js"结束的字符串
console.log(pattern.exec(str));     // null

var str = 'html css js';
var pattern = /js$/;                // 匹配以"js"结束的字符串
console.log(pattern.exec(str));     // ["js"]

// 位置匹配练习
// 要求：判断字符串是不是全部都有数字构成

// 方式1：正向匹配
var str = '110119120';
var pattern = /^\d+$/;             // 如果字符串全部都由数字构成，匹配到，否则匹配不到
console.log(pattern.exec(str));    // ["110119120"]

var str = '110119a120';
var pattern = /^\d+$/;             // 如果字符串全部都由数字构成，匹配到，否则匹配不到
console.log(pattern.exec(str));    // null，字符串中存在非数字，所以匹配结果是空

// 方式2：反向匹配
var str = '110119120';
var pattern = /\D/;                // 匹配字符串中的非数字
console.log(pattern.exec(str));    // null，说明字符串中都是数字

var str = '11011a9120';
var pattern = /\D/;                // 匹配字符串中的非数字
console.log(pattern.exec(str));    // ["a"]，说明字符串中存在非数字

位置匹配：\b(边界)

// \b  =>  \b本身不是字符，代表的是边界
// 所谓边界，可以理解为 \w 与 \W 之间的那个位置
// 常用于匹配单词

// 注意js后面的位置，这个位置前面是字符"s"(\w)，后面是空格" "(\W)，这就是一个边界
// 所以匹配到的结果就是["js"]
var str = 'js html';
var pattern = /js\b/;
console.log(pattern.exec(str));     // ["js"]

// 注意js前面的位置，这个位置前面是字符"@"(\W)，后面是字符"j"(\w)，这就是一个边界
// 注意js后面的位置，这个位置前面是字符"s"(\w)，后面是字符"@"(\W)，这就是一个边界
// 所以匹配到的结果就是["js"]
var str = '@@@js@@@';
var pattern = /\bjs\b/;
console.log(pattern.exec(str));     // ["js"]

位置匹配：?=(前瞻性匹配)

var str = 'javascript';
var pattern = /java(?=script)/;     // java后面如果跟着script，就匹配java
console.log(pattern.exec(str));     // ["java"]，能匹配到

var str = 'java';
var pattern = /java(?=script)/;     // java后面如果跟着script，就匹配java
console.log(pattern.exec(str));     // null，匹配不到

位置匹配：?!(负向前瞻性匹配)

var str = 'javasda';
var pattern = /java(?!script)/;     // java后面如果不是跟着script，就匹配java
console.log(pattern.exec(str));     // ["java"]

var str = 'javascript';
var pattern = /java(?!script)/;     // java后面如果不是跟着script，就匹配java
console.log(pattern.exec(str));     // ["java"]

RegExp对象

双重转义：以构造函数的方式定义正则表达式，需要双重转义

// 以下两种方式是一样的
console.log(/\b/);
console.log(new RegExp('\\b'));

// 以下两种方式是一样的
console.log(/\\/);
console.log(new RegExp('\\\\'));

常用方法：exec()，test()，toString()，toLocaleString()，valueOf()

// exec()

// 普通匹配，匹配到一个就会结束，所以index和lastIndex一直都是0
var str = 'js js js';
var pattern = /js/;
console.log(pattern.exec(str));     // ["js", index: 0]
console.log(pattern.exec(str));     // ["js", index: 0]
console.log(pattern.exec(str));     // ["js", index: 0]
console.log(pattern.exec(str));     // ["js", index: 0]

// 全局匹配，匹配到一个之后还会继续匹配，所以index和lastIndex会变化
var str = 'js js js';
var pattern = /js/g;

// 第一次匹配，从lastIndex=0开始匹配，匹配到"js"的index是0
// RegExp实例的lastIndex属性值会变为2
console.log(pattern.exec(str));     // ["js", index: 0]

// 第二次匹配，从lastIndex=2开始匹配，匹配到"js"的index是3
// RegExp实例的lastIndex属性值会变为5
console.log(pattern.exec(str));     // ["js", index: 3]

// 第三次匹配，从lastIndex=5开始匹配，匹配到"js"的index是6
// RegExp实例的lastIndex属性值会变为8
console.log(pattern.exec(str));     // ["js", index: 6]

// 第四次匹配，从lastIndex=8开始匹配，字符串匹配已经结束
// RegExp实例的lastIndex属性值会重置为0
console.log(pattern.exec(str));     // null

// 第五次匹配，从lastIndex=0开始匹配，匹配到"js"的index是0
// RegExp实例的lastIndex属性值会变为2
console.log(pattern.exec(str));     // ["js", index: 0]

// test()

// 普通匹配，匹配到一个就会结束，所以lastIndex一直都是0
var str = 'js js js';
var pattern = /js/;
console.log(pattern.exec(str));     // ["js", index: 0]
console.log(pattern.exec(str));     // ["js", index: 0]
console.log(pattern.exec(str));     // ["js", index: 0]
console.log(pattern.exec(str));     // ["js", index: 0]

// 全局匹配，匹配到一个之后还会继续匹配，所以lastIndex会变化
// 原理与exec()类似，不解释
var str = 'js js js';
var pattern = /js/g;

console.log(pattern.test(str));     // true
console.log(pattern.test(str));     // true
console.log(pattern.test(str));     // true
console.log(pattern.test(str));     // false
console.log(pattern.test(str));     // true

// toString()，toLocaleString()，valueOf()
var pattern = new RegExp('a\\nb')

console.log(pattern.toString());            // /a\nb/，转换为字面量的正则表达式
console.log(pattern.toLocaleString());      // /a\nb/，转换为字面量的正则表达式
console.log(pattern.valueOf() === pattern); // true，就是正则表达式本身

常用属性：ignoreCase，global，multiline，source，lastIndex

// 很直观，不解释
var str = 'js js js';
var pattern = new RegExp('\\b', 'i');

console.log(pattern.ignoreCase);    // true
console.log(pattern.global);        // false
console.log(pattern.multiline);     // false
console.log(pattern.source);        // \b，字面量形式的正则
console.log(pattern.lastIndex);     // 0

String对象中与正则表达式相关的方法

search()：查找字符串，并返回字符串的下标

// search()：搜索字符串中是否存在匹配的内容，如果有，返回index，否则返回-1
// 由于search()方法只要找到一个匹配的内容就会返回index，所以正则中是否带g，无关紧要

var str = 'html js js';
var pattern = /js/g;
console.log(str.search(pattern));   // 5

var str = 'html js js';
console.log(str.search('js'));      // 5，其实这种方式也是将"js"转换成正则，然后再匹配

match()：匹配字符串，并返回匹配到的字符串

// match()：匹配字符串，并返回匹配到的字符串
// 非全局匹配：会返回分组中的匹配到的内容
// 全局匹配：不会返回分组中的匹配到的内容，会返回所有匹配到的内容

// 正则的exec()
// 无论是否全局匹配都会返回分组中匹配到的内容，都只会返回当前匹配到的一个内容，而不是全部返回

var str = 'js js js';
var pattern = /(j)s/;
console.log(str.match(pattern));    // ["js", "j"]，与exec()类似

var str = 'js js js';
var pattern = /(j)s/g;
console.log(str.match(pattern));    // ["js", "js", "js"]，可以看到与exec()不一样了

// 模式修饰符m

// 想要发挥m的作用，需要两个条件
// 条件1：与模式修饰符g一起使用
// 条件2：与首匹配(^)或者尾匹配($)一起使用

// 没有符合条件1，所以不能发挥m的作用
var str = '1.js\n2.js\n3.js';
var pattern = /js/m;
console.log(str.match(pattern));    // ["js"]，有没有m，结果都一样

// 没有符合条件2，所以不能发挥m的作用
var str = '1.js\n2.js\n3.js';
var pattern = /js/mg;
console.log(str.match(pattern));    // ["js", "js", "js"]，有没有m，结果都一样

// 我们看看满足条件1和条件2的m会发挥出什么效果
// 没有m，会认为str字符串是一行，只有一个行尾，所以只能找到一个"js"
var str = '1.js\n2.js\n3.js';
var pattern = /js$/g;
console.log(str.match(pattern));    // ["js"]

// 加了m，会认为str字符串是多行，拥有多个行尾，所以就能找到多个"js"
var str = '1.js\n2.js\n3.js';
var pattern = /js$/mg;
console.log(str.match(pattern));    // ["js", "js", "js"]

// 与行首(^)配合使用的情况也是一样的，不解释。

// 混合使用：选择，分组，重复

// 把"css"字符串找出来，找到一个就停止
var str = 'csscsshtmljs';
var pattern = /css/;
console.log(str.match(pattern));    // ["css"]

// 把"css"字符串都找出来，找到一个还会继续往下找
var str = 'csscsshtmljscss';
var pattern = /css/g;
console.log(str.match(pattern));    // ["css", "css", "css"]

// 以"css"为分组，把字符串都找出来，找到一个还会继续往下找
var str = 'csscsshtmljs';
var pattern = /(css)/g;
console.log(str.match(pattern));    // ["css", "css"]

var str = 'csscsshtmljscss';
var pattern = /(css)/g;
console.log(str.match(pattern));    // ["css", "css", "css"]

// 把由>=1个"css"组成的字符串都找出来，找到一个还会继续往下找
var str = 'csscsshtmljs';
var pattern = /(css)+/g;
console.log(str.match(pattern));    // ["csscss"]

var str = 'csscsshtmljscss';
var pattern = /(css)+/g;
console.log(str.match(pattern));    // ["csscss", "css"]

// 把由>=1个"css"/"html"/"js"组成的字符串都找出来，找到一个还会继续往下找
var str = 'csscsshtmljs';
var pattern = /(css|html|js)+/g;
console.log(str.match(pattern));    // ["csscsshtmljs"]

var str = 'csscssjshtml';
var pattern = /(css|html|js)+/g;
console.log(str.match(pattern));    // ["csscssjshtml"]

split()：把字符传转化成数组

// split()：把字符传转化成数组

// 这种情况，有没有用正则，都是一样的
var str = 'html,css,js';
console.log(str.split(','));        // ["html", "css", "js"]

var str = 'html,css,js';
var pattern = /,/g;                 // 这里有没有g都是一样的
console.log(str.split(pattern));    // ["html", "css", "js"]

// 这种情况，就可以看出正则的作用了
var str = 'html ,   css  ,   js';
var pattern = /,/;
console.log(str.split(pattern));    // ["html ", "   css  ", "   js"]

var str = 'html ,   css  ,   js';
var pattern = /\s*,\s*/;
console.log(str.split(pattern));    // ["html", "css", "js"]

replace()：替换字符串中的字符串

// replace()：替换字符串中的字符串

// 普通替换，只能替换掉第一个匹配到的字符串
var str = 'I love js js';
console.log(str.replace('js', 'html'));        // I love html js

// 使用正则，没有带g，也只能替换掉第一个匹配到的字符串
var str = 'I love js js';
var pattern = /js/;
console.log(str.replace(pattern, 'html'));    // I love html js

// 使用正则，带g，可以替换掉所有匹配到的字符串
var str = 'I love js js';
var pattern = /js/g;
console.log(str.replace(pattern, 'html'));    // I love html html

var str = '1111-11-11';
var pattern = /-/g;
console.log(str.replace(pattern, '.'));       // 1111.11.11

// 分组的引用：$1，$2，...
// 这就就是找到字符串"js"，然后把它加红加粗了
var str = 'I love js';
var pattern = /(js)/;
document.write(str.replace(pattern, '<strong style="color: red;">$1</strong>'));

//  replace方法的第二个参数，也可以说使用函数

// 这种方式把敏感词都替换成*
var str = '中国军队和阿扁一起办证';
var pattern = /国军|阿扁|办证/g;
console.log(str.replace(pattern, '*'));

// 这种方式可以根据敏感词的字数，替换成相应个数的*
var str = '中国军队和阿扁一起办证';
var pattern = /国军|阿扁|办证/g;
console.log(str.replace(pattern, function ($0) {
    var result = '';
    for (var i = 0; i < $0.length; i++) {
        result += '*';
    }
    return result;
}));

常用的正则表达式

QQ号，昵称和密码

// 1.QQ
//  全是数字
//  首位不能为0
//  最少5位(10000)

// 注意用于验证的话，需要加上首尾匹配
function matchQQ(str) {
    return /^[1-9]\d{4,}$/.test(str);
}

// 2.昵称
//  中、英文、数字以及下划线
//  2-18位

// 以下两种方式都是可以的
// \w 就是a-zA-Z0-9_，所以可以简写
function matchNickName(str) {
    // return /^[\u4e00-\u9fa5a-zA-Z0-9_]{2,18}$/.test(str);
    return /^[\u4e00-\u9fa5\w]{2,18}$/.test(str);
}

// 3.密码
//  6-16位
//  不能用空白字符\s
function matchPassword(str){
    return /^\S{6,16}$/.test(str);
}

去除字符串首尾的空白字符

// 去除字符串首部的空白字符
var str = '        Alex         ';
var pattern = /^\s+/;
console.log('|' + str.replace(pattern, '') + '|');  // |Alex         |

// 去除字符串尾部的空白字符
var str = '        Alex         ';
var pattern = /\s+$/;
console.log('|' + str.replace(pattern, '') + '|');  // |        Alex|

// 去除字符串首部和尾部的空白字符：方法1
// 虽然这样写比较高大上，简洁，但是性能并没有分开写来的高
var str = '        Alex         ';
var pattern = /^\s+|\s+$/g;
console.log('|' + str.replace(pattern, '') + '|');  // |Alex|

// 去除字符串首部和尾部的空白字符：方法2
// 虽然这样会多写一点，但是可读性和性能都比较高，有时候建议这样写
var str = '        Alex         ';
var pattern1 = /^\s+/;
var pattern2 = /\s+$/;
console.log('|' + str.replace(pattern1, '').replace(pattern2, '') + '|');   // |Alex|

// 封装一个去除字符串首尾空白字符的函数
function trim(str) {
    return str.replace(/^\s+/, '').replace(/\s+$/, '');
}

转驼峰

// 封装一个转驼峰的函数
function toCamelCase(str) {
    return str.replace(/-([a-z])/gi, function (all, letter) {
        // all：所有匹配到的内容
        // letter：第一个分组，也就是我们需要的"-"后面的字符
        return letter.toUpperCase();
    })
}

匹配HTML标签

// 穷举法
var str = '<p class="odd" id="odd">123</p>';
var pattern = /<\/?[a-zA-Z]+(\s+[a-zA-Z]+=".*")*>/g;
console.log(str.match(pattern));

// 反向思考，匹配不是">"的所有字符串
// 但是这里存在一个问题，如果出现value=">"，无法匹配到整个标签
var str = '<p class="odd" id="odd">123</p>';
var pattern = /<[^>]+>/g;
console.log(str.match(pattern));

// 穷举法
// 把字符串分解成""里面的内容，和""外面的内容
// 把字符串分解成''里面的内容，和''外面的内容
var str = '<input type="text" value=">" name="username" />';
var pattern = /<(?:[^"'>]|"[^"]*"|'[^']*')*>/g;
console.log(str.match(pattern));

// 穷举法
// 把字符串分解成""里面的内容，和""外面的内容
// 把字符串分解成''里面的内容，和''外面的内容
// 使用引用，保证"后面跟的是"，'后面跟的是'
var str = '<input type="text" value=">" name="username" />';
var pattern = /<(?:[^"'>]|(["'])[^"']*\1)*>/g;
console.log(str.match(pattern));

邮箱

function matchEmail(str){
    return /(?:\w+\.)*\w+@(?:\w+\.)+[a-z]{2,4}/i.test(str);
}