转义字符"\"

多行字符串：

document.body.innerHTML = "\

<div></div>\

<span><\span>\

";

字符串换行符\n；行结束：\r；制表符：\t（缩进）

正则表达式 RegExp

正则表达式的作用：匹配特殊字符或有特殊搭配原则的字符的最佳选择。 贪婪匹配原则。

两种创建方式：

我自己是一名从事了多年开发的web前端老程序员，目前辞职在做自己的web前端私人定制课程，今年年初我花了一个月整理了一份最适合2019年学习的web前端学习干货，各种框架都有整理，送给每一位前端小伙伴，想要获取的可以关注我的头条号并在后台私信我：前端，即可免费获取。

1、字面量 （推荐） /pattern/attributes

var reg1 = /abc/i;
var str = "abcd";
reg1.test(str);//true 返回true或者false
str.match(reg1);//["abc"] 返回的是数组

2、new RegExp(pattern,attributes);

var str = "abcd"
var reg2 = new RegExp("abc","i");
注：
若 var reg2 = new RegExp(reg1);则此时reg1与reg2内部值相同，但是指向两个引用。
但若 var reg2 = RegExp(reg1);则此时reg1与reg2内部值相同，且指向同一个引用。

修饰符：

i：执行对大小写不敏感的匹配；

g：执行全局匹配（查找所有匹配而非在找到第一个匹配后停止）；

m ：执行多行匹配。

var reg = /^a/g;
var reg2 = /^a/gm;
var str = "abcde\na";//包含换行
str.match(reg);//["a"]
str.match(reg2);//["a","a"]多行匹配

一个方括号代表一位！(red|blue\green)匹配"red"或"blue"或"green"

var reg = /[0123456789][0123456789][0123456789]/g;//表示全局匹配连续的三个数字
var str = "12309u98723lashgkjghajh";
str.match(reg);//["123","987"]

元字符也代表一位！方括号里也可以写元字符！ var reg = /[\w\d]/g;

\w === [0-9A-z_] \d === [0-9] \s === [\t\n\r\v\f ] 最后一个是空格 \b === 单次边界 . === [^\r\n]

\W === [^\w] \D === [^\d] \S === [^\s] \B ===非单次边界

var reg1 = /\bcde/g;//单次边界必须是在c之前的那个
var reg2 = /\bc/g;//匹配的是第二个c
var str = "abc cde fgh"'
str.match(reg1);//"cde"结果中不包含前面的空格
str.match(reg2);//"c"结果中不包含前面的空格
unicode编码 \uxxxx后面四位一般指常见的第一层的所有unicode编码，实际应该为\u01xxxx。另外十五层表示为(\u020000-\u02ffff)-(\u100000-\u10ffff)
var reg = /\u8001\u9093\u8eab\u4f53\u597d/g;
var str = "老邓身体好";
str.match(reg);//"老邓身体好"

贪婪匹配原则，尽量匹配最多的。n+ : {1,} n* : {0,}

reg.exec()和lastIndex相对应相匹配，且lastIndex可以手动修改。不使用全局匹配时，lastIndex值始终为0.

匹配连续出现的相同字符：var reg = /(\w)\1\1\1/g \1表示反向引用第一个子表达式的内容也就是第一个\w，这样一来，字符串如"aaaa"、"bbbb"都能匹配出来。如果要匹配出"aabb"，则需要reg = /(\w)\1(\w)\2/g，这里的\2表示反向引用第二个子表达式,也就是第二个\w。

var str = "aabb";
var reg = /(\w)\1(\w)\2/;
console.log(reg.exec(str));//["aabb","a","b",index:0,input:"aabb"]

var str = "aabb";
var reg1 = /(\w)\1(\w)\2/;
var reg2 = /(\w)\1(\w)\2/g;
console.log(str.match(reg1));//["aabb","a","b",index:0,input:"aabb"]
//返回匹配结果和两个子表达式的内容
console.log(str.match(reg2));//["aabb"]
//全局搜索时，返回的结果中不包含子表达式的内容

search匹配不到的话，返回-1，匹配到的话，返回匹配到的位置，且仅仅返回匹配到的第一个字符的位置，其后再有匹配到的也不会返回结果。所以search只管能不能匹配到，而不管能匹配到多少，更不用说其他匹配成功的字符位置了。

对于split方法，如果正则表达式中含有子表达式，则会在每一截分割的结果后跟着子表达式的内容。不管是不是全局搜索。

var str = "aa";
str1 = str.replace("a","b");
console.log(str1);//ba replace方法只对字符串的第一个指定字符进行了替换操作,它没有访问全局的能力
console.log(str);//aa replace方法不更改原来的字符串
 
var reg = /a/g;
str1 = str.replace(reg,"b");
console.log(str1);//bb 使用正则表达式全局匹配，可以全局替换
console.log(str);//aa 对原来的字符串依旧没有影响

replace方法的第二个参数必须是字符串格式(或者是用function但是返回的是字符串），其内部使用$1时表示的是第一个参数正则表达式的第一个子表达式，$2表示的是第一个参数正则表达式的第二个子表达式。（replace方法的精华）

var reg = /(\w)\1(\w)\2/g;
var str = "aabb";
console.log(str.replace(reg,"$2$2$1$1"));//bbaa
console.log(str.replace(reg,function($,$1,$2){
 return $2 + $2 + $1 + $1;
}));//bbaa

replace方法的第二个参数使用function时，系统自动传参。传递的第一个参数是全局匹配时每一次匹配到的str中的字符（串），往后依次为正则表达式匹配出的第一个子表达式第二个子表达式等。

e.g:将the-first-name变成theFirstName（小驼峰式）

var reg = /-(\w)/g;
var str = "the-first-name";
str.replace(reg,function($,$1){
 return $1.toUpperCase
});//theFirstName

全局匹配中，匹配了多少次，function就会执行多少次！

正向预查 正向断言

var str = "abaaaaaa";
var reg = /a(?=b)/g;//这里的(?=b)表示a后面需要跟一个b，但是b不参与选择，只参与修饰限定。
str.match(reg);//"a" 这里只能选出一个"a"
 
var str = "abaaaaaa";
var reg = /a(?!b)/g;//这里的(?!b)表示a后面不能跟b，此时的括号内容也只参与修饰限定。
str.match(reg);//"a","a","a","a","a","a" 这里能选出六个"a"

非贪婪匹配

将默认的贪婪匹配更改成为非贪婪匹配的方法为：在正则表达式内部末尾加一个?

var str = "aaaaaa";
var reg1 = /a+?/g;
var reg2 = /a+/g;
var reg3 = // 
str.match(reg1);//["a","a","a","a","a","a"]
str.match(reg2);//["aaaaaa"]

练习

将var str = "10000000000" 匹配替换为10,000,000,000

var str = "10000000000";
var reg = /(\d\d\d)/g;
console.log(str.split('').reverse().join('').replace(reg,function($,$1){
	return $1+',';
}).split('').reverse().join(''));//'10,000,000,000' 解法一
var reg2 = /(?=(\B)(\d{3})+$)/g;
console.log(str.replace(reg2,","));//'10,000,000,000' 解法二

原文链接：https://blog.csdn.net/qq_38349067/article/details/103364736