很多时候多会被正则表达式搞的晕头转向，最近抽出时间对正则表达式进行了系统的学习，整理如下：
正则表达式的创建两种方法，一种是直接写，由包含在斜杠之间的模式组成；另一种是调用regexp对象的构造函数。
两种方法的创建代码如下：
// 直接创建const regex1 = /ab+c/; const regex2 = /^[a-za-z]+[0-9]*\w?_$/gi;// 调用构造函数const regex3 = new regexp('ab+c'); const regex4 = new regexp(/^[a-za-z]+[0-9]*\w?_$/, gi); const regex5 = new regexp('^[a-za-z]+[0-9]*\w?_$', 'gi');
可以看出，调用regexp构造函数创建正则表达式时，第一个参数可以是字符串，也可以是直接创建的正则表达式。
需要注意的是：regexp实例继承的tolocalestring()和tostring)()方法都会返回正则表达式的字面量，与创建正则表达式的方式无关
例如：
const ncname = '[a-za-z_][\\w\\-\\.]*'; const qnamecapture = '((?:' + ncname + '\\:)?' + ncname + ')'; const starttagopen = new regexp('^<' + qnamecapture); starttagopen.tostring();        // '/^<((?:[a-za-z_][\w\-\.]*\:)?[a-za-z_][\w\-\.]*)/'
正则表达式中的特殊字符\ (反斜杠)1.在非特殊字符前加反斜杠表示下一个字符是特殊的；
2.将其后的特殊字符转译为字面量；
注意：在使用regexp构造函数时要将\转译，因为\在字符串里也是转译字符
^ 1.匹配输入的开始；
2.在[]中的第一位时表示反向字符集；
例子：
/^a/.exec('an a')        // null/^a/.exec('an e')        // [a, index: 0, input: an e]
$ 匹配输入的结束
/t$/.exec('eater')        // null/t$/.exec('eat')          // [t, index: 2, input: eat]
*,  +,  .(小数点) *：匹配前一个表达式0次或多次。等价于 {0,}；
+：匹配前面一个表达式1次或者多次。等价于 {1,}；
.：匹配除换行符之外的任何单个字符；
? (问号)1.匹配前面一个表达式0次或者1次。等价于 {0,1}；
  2.如果紧跟在任何量词 *  + ? {} 的后面，将会使量词变为非贪婪的（匹配尽量少的字符），和缺省使用的贪婪模式正好相反；
  3.运用于先行断言
例子：
/\d+/.exec('123abc')        　// [123, index: 0, input: 123abc]/\d+?/.exec('123abc')            // [1, index: 0, input: 123abc]
(x)匹配 'x' 并且记住匹配项，括号表示捕获括号；
例子：
/(foo) (bar) \1 \2/.test('bar foo bar foo');   // false/(bar) (foo) \1 \2/.test('bar foo bar foo');   // true/(bar) (foo) \1 \2/.test('bar foo');           // false/(bar) (foo) \1 \2/.test('bar foo foo bar');   // false/(bar) (foo) \2 \1/.test('bar foo foo bar');   // true'bar foo bar foo'.replace( /(bar) (foo)/, '$2 $1' );    // foo bar bar foo
模式 /(foo) (bar) \1 \2/ 中的 '(foo)' 和 '(bar)' 匹配并记住字符串 foo bar foo bar 中前两个单词。模式中的 \1 和 \2 匹配字符串的后两个单词。
注意：\1、\2、\n 是用在正则表达式的匹配环节，在正则表达式的替换环节，则要使用像 $1、$2、$n 这样的语法。例如，'bar foo'.replace( /(...) (...)/, '$2 $1' )。
(?:x) 匹配 'x' 但是不记住匹配项，这种叫作非捕获括号；
例子：
'foo'.match(/foo{1,2}/)                // [foo, index: 0, input: foo]'foo'.match(/(?:foo){1,2}/)            // [foo, index: 0, input: foo]'foofoo'.match(/(?:foo){1,2}/)         // [foofoo, index: 0, input: foofoo]'foofoo'.match(/foo{1,2}/)             // [foo, index: 0, input: foofoo]
使用场景：示例表达式 /(?:foo){1,2}/。如果表达式是 /foo{1,2}/，{1,2}将只对 ‘foo’ 的最后一个字符 ’o‘ 生效。如果使用非捕获括号，则{1,2}会匹配整个 ‘foo’ 单词。
x(?=y), x(?!y), x|y x(?=y)：匹配'x'仅仅当'x'后面跟着'y'；
x(?!y)：匹配'x'仅仅当'x'后面不跟着'y'；
x|y: 匹配x或y
这两种匹配的结果都不包含y
例子：
'jacksprat'.match(/jack(?=sprat)/)            // [jack, index: 0, input: jacksprat]'jackwprat'.match(/jack(?=sprat)/)            // null'jackwprat'.match(/jack(?=sprat|wprat)/)    // [jack, index: 0, input: jackwprat]/\d+(?!\.)/.exec(3.141)        // [141, index: 2, input: 3.141]
{n}, {n,m}:{n}：匹配了前面一个字符刚好发生了n次；
{n,m}：匹配前面的字符至少n次，最多m次。如果 n 或者 m 的值是0， 这个值被忽略；
例子：
    /a{2}/.exec('candy')         // null/a{2}/.exec('caandy')        // [aa, index: 1, input: caandy]/a{2}/.exec('caaandy')       // [aa, index: 1, input: caaandy]/a{1,3}/.exec('candy')       // [a, index: 1, input: candy]/a{1,3}/.exec('caandy')      // [aa, index: 1, input: caandy]/a{1,3}/.exec('caaandy')     // [aaa, index: 1, input: caaandy]/a{1,3}/.exec('caaaandy')    // [aaa, index: 1, input: caaaandy]
[xyz], [^xyz] [xyz]：一个字符集合。匹配方括号的中任意字符;
[^xyz]：一个反向字符集。匹配任何没有包含在方括号中的字符；
这两种匹配都可以使用破折号（-）来指定一个字符范围，特殊符号在字符集中没有了特殊意义。
例：
function escaperegexp(string){return string.replace(/([.*+?^=!:${}()|[\]\/\\])/g, \\$&); //$&表示整个被匹配的字符串}
例子中的.*+?^=!:${}()都表示字面量，并没有特殊意义。
其他\b：匹配一个词的边界。一个匹配的词的边界并不包含在匹配的内容中。换句话说，一个匹配的词的边界的内容的长度是0；
\b： 匹配一个非单词边界；
例子：
    /\bm/.exec('moon')            　  　// [m, index: 0, input: moon]/\bm/.exec('san moon')          // [m, index: 4, input: san moon]/oo\b/.exec('moon')             // null/\b../.exec('noonday')                    // [oo, index: 1, input: noonday]/y\b../.exec('possibly yesterday')        // /y\b../.exec('possibly yesterday')
\d：匹配一个数字，等价于[0-9]；
\d：匹配一个非数字字符，等价于[^0-9]；
\f：匹配一个换页符 (u+000c)；
\n：匹配一个换行符 (u+000a)；
\r：匹配一个回车符 (u+000d)；
\s：匹配一个空白字符，包括空格、制表符、换页符和换行符，等价于[ \f\n\r\t\v\u00a0\u1680\u180e\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]；
\s：匹配一个非空白字符，等价于[^ \f\n\r\t\v\u00a0\u1680\u180e\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]；
\w：匹配一个单字字符（字母、数字或者下划线），等价于[a-za-z0-9_]；
\w：匹配一个非单字字符，等价于[^a-za-z0-9_]；
正则表达式标志g：全局搜索；
i：不区分大小写；
m：多行搜索；
正则表达式使用regexp有exec()和test()方法；
exec匹配的结果为：匹配结果、捕获结果，index和input。
test匹配的结果为true或false，效率比exec要高。
string有match()，replace()，search()，split()方法；
match匹配的结果同regexp的exec，replace根据正则表达式替换，search查找所以位置，split根据正则表达式分割字符串。
其中，当replace有function时，参数说明如下：
* 匹配项
* 记忆项（括号里面的项）
* ...
* 匹配的index
* input输入项
以上就是总结js中正则表达式的创建与使用的详细内容。