正则表达式

概念

什么是正则表达式？

正则表达式(Regular Expression)是用于匹配字符串中字符组合的模式。在JavaScript中，正则表达式也是对象。

正则表达式通常用来检索，替换那些符合某个模式(规则)的文本，例如验证表单：用户名表单只能输入英文字母，数字或者下划线，昵称输入框中可以输入中文(匹配)。此外，正则表达式还常用于过滤掉页面内容中的一些敏感词(替换)，或从字符串中获取我们想要的特定部分(提取)等。

特点

  • 灵活性，逻辑性，和功能性非常的强
  • 可以迅速地用既简单的方式达到字符串的复杂控制
  • 对于刚接触的人来说，比较晦涩难懂
  • 实际开发，一般都是直接复制写好的正则表达式，但是要求会使用正则表达式并且根据实际情况修改正则表达式

转义 -> 转换意义/改变意义

  • 转义符号：\
  • 转义字符：\字符，改变原来的功能
  1. // 打印字符串里的双引号写法
  2. var str = '我是一名"牛逼"的程序员';

问题：为什么出现语法错误?

答案：因为中间的字符是变量，需要加号才能拼接在一起

程序是如何识别？

JavaScript对待语法来说，先解析正常的语法，分析完才做文本输出，此时发现变量与字符串中间没有加号，此时会报语法错误

  1. var str = "我是一名"牛逼"的程序员";

如何把原来的解析规则(字符串后引号)改为单纯的字符意义？(双引号的功能变为字符)

此时需要转义，让字符本来的功能变为另外的意义和功能

  1. var str = "我是一名\"牛逼\"的程序员";

如何只显示\？

  1. var str = "我是一名\\牛逼\\的程序员";

转义字符

特殊的转义字符：

  • \n：换行
  • \r：回车
  • \t：制表符

注意：

  • \n 只给编辑系统使用，在页码不显示换行，只显示空格(占用了字符)，原因HTML是纯文本而不是编辑系统
  • 如windows编辑系统回车键默认加\r，\n
  • 如mac编辑系统回车默认加\r
  • 如linux编辑系统回车默认加\n
  • 制表符：table的缩写tab 相当于4个空格

问题：为什么换行会报错？

  1. var str = '<h1>11111</h1>
  2.            <h2>22222</h2>
  3.            <h3>33333</h3>';

原因：JavaScript默认不允许字符串存在多行的情况

  1. var str = '<h1>11111</h1>\
  2.            <h2>22222</h2>\
  3.            <h3>333333</h3>';

转义为多个空格

描述

RegExp - regular expression

按照一定的规则匹配或检索这个规则当中指定的或指定类型的某些字符，或者是一些特殊的字符的方法

匹配规则则是正则表达式，对字符串操作的一种逻辑公式，对某一些字符串中的某一些字符进行检索，但逻辑需要一种方式 去写成一种规则，然后让程序调用这种规则。

用途

  • 检测输入(邮箱)
  • 密码是否带有某些字符
  • 替换数据中的某些字符串
  • 替换模板

正则也是一个对象，也可以实例化一个正则

  1. var reg = new RegExp(正则表达式);

参数1：为正则表达式

以这个正则表达式为规则，来检验一下，str里是否包含test，如果包含为true

  1. var str = 'This is a test';
  2. console.log(new RegExp('test')); // /test/
  3. console.log(new RegExp('test').test(str)); //true
  1. var str = 'This is a test';
  2. console.log(new RegExp('tes')); // /tes/
  3. console.log(new RegExp('tes').test(str)); //true
  1. var str = 'This is a test';
  2. console.log(new RegExp('Test')); // /Test/
  3. console.log(new RegExp('Test').test(str)); //false

参数2：为属性(修饰符)

  1. //忽略大小写
  2. var str = 'This is a test',
  3.   reg = new RegExp('Test', 'i');
  4. console.log(reg); // /Test/i
  5. console.log(reg.test(str)); //true
  1. //修饰符只有i的时候
  2. //两个test时，只匹配一个
  3. var str = 'This is a test. Test is important.',
  4.   reg = new RegExp('Test', 'i');
  5. console.log(reg); // /Test/i
  6. console.log(str.match(reg)); 
  8. /**
  9.  * console.log(str.match(reg)):
  10.  * ["test", index: 10, input: "This is a test. Test is important.", groups: undefined]
  11.  *   0: "test"
  12.  *   groups: undefined
  13.  *   index: 10
  14.  *   input: "This is a test. Test is important."
  15.  *   length: 1
  16.  *   __proto__: Array(0)
  17.  */
  1. //修饰符有gi的时候
  2. //两个test时，全部匹配
  3. var str = 'This is a test. Test is important.',
  4.   reg = new RegExp('Test', 'gi');
  5. console.log(reg); // /Test/i
  6. console.log(str.match(reg)); 
  8. /**
  9.  * console.log(str.match(reg)):
  10.  * ["test", "Test"]
  11.  *   0: "test"
  12.  *   1: "Test"
  13.  *   length: 2
  14.  *   __proto__: Array(0)
  15.  */

要求

  • 字符串片段，大小写默认敏感
  • 连续的

修饰符

  • i：igore case 忽略大小写
  • g：global 全局匹配
  • m：multi-line 多行匹配
  1. //i忽略大小写
  2. var reg = /Test/i,
  3.   str = 'This is a test';
  4. console.log(reg.test(str)); //true
  6. var reg2 = /Test/,
  7.   str = 'This is a test';
  8. console.log(reg2.test(str)); //false
  1. //全局匹配
  3. //没加g匹配一个到一个结果
  4. var reg = /Test/i,
  5.   str = 'This is a test. Test is important.';
  6. //match()匹配所有正则里面的内容归纳成一个数组
  7. console.log(str.match(reg));
  9. /**
  10.  * console.log(str.match(reg)):
  11.  * ["test", index: 10, input: "This is a test. Test is important.", groups: undefined]
  12.  *   0: "test"
  13.  *   groups: undefined
  14.  *   index: 10
  15.  *   input: "This is a test. Test is important."
  16.  *   length: 1
  17.  *   __proto__: Array(0)
  18.  */
  20. //加了g匹配到两个结果
  21. var reg2 = /Test/gi,
  22.   str = 'This is a test. Test is important.';
  23. console.log(str.match(reg2));
  25. /**
  26.  * ["test", "Test"]
  27.  *   0: "test"
  28.  *   1: "Test"
  29.  *   length: 2
  30.  *   __proto__: Array(0)
  31.  */
  1. // 多行匹配
  2. // 希望匹配一行开头的单词
  3. var reg = /Test/gim,
  4.   str = 'This is a test. \nTest is important.';
  6. console.log(str.match(reg));
  8. /**
  9.  * ["test", "Test"]
  10.  *   0: "test"
  11.  *   1: "Test"
  12.  *   length: 2
  13.  *   __proto__: Array(0)
  14.  */

创建

创建方法一：字面量

  1. var reg = //;

此方法不适用套用变量

  1. var v = 'Test';
  2. var reg = /v/gi; //null

创建方法二：实例化构造函数

  1. var reg = new RegExp();

此方法适用套用变量

  1. var v = 'Test';
  2. var reg = new RegExp(v, 'i');

字面量创建的与实例化的正则不是同一个正则：

  1. var reg = /test/;
  2. var newReg = new RegExp('test');
  4. console.log(reg);
  5. console.log(newReg);
  7. reg.a = 1;
  8. console.log(newReg.a); //undefined

此时为什么会等于1？

同一个对象的引用

  1. var reg = /test/;
  2. var newReg = RegExp(reg);
  4. console.log(reg);
  5. console.log(newReg);
  7. reg.a = 1;
  8. console.log(newReg.a); //1

又创建新的对象不同的引用

  1. var reg = /test/;
  2. var newReg = new RegExp(reg);
  4. console.log(reg);
  5. console.log(newReg);
  7. reg.a = 1;
  8. console.log(newReg.a); //undefined

表达式

  • []：区间
  • ^：非
  • |：或

正则匹配时是正向往后匹配,并不会逆向重新匹配

匹配过的字符就不会去匹配

  1. // 表达式 []
  2. //希望匹配第一位里符合1234567890的任意一位
  3. //希望匹配第二位里符合1234567890的任意一位
  4. //希望匹配第三位里符合1234567890的任意一位
  5. var str = '09wefjh0e0r9gj-0werfj',
  6.   str1 = '098efjh0e0r9gj-0werfj',
  7.   str2 = '098efjh0e0r912gj-0werfj';
  8. reg = /[1234567890][1234567890][1234567890]/g;
  10. console.log(str.match(reg)); //null
  11. console.log(str1.match(reg)); //["098"]
  12. console.log(str2.match(reg)); //["098", "912"]
  1. // 表达式 []
  2. //这里[]里是选择字符中间的一个,而不是一个范围
  3. //分析: 
  4. //[wx]选择中间的一个 x
  5. //[xy]选择中间的一个 y
  6. //[z]选择中间的一个 z
  7. //过程: 
  8. //1.w xy z匹配不了
  9. //2.x y z
  11. var reg = /[wx][xy][z]/g,
  12.   str = 'wxyz';
  14. console.log(str.match(reg)); //["xyz"]
  1. //写区间
  2. var str = 'fiksodf090dg0erGEOGIV-G345;Lgf-',
  3.   str1 = 'fiksodf090Dg0erGEOGIV-G345;Lgf-';
  5. //希望匹配第一位是数字
  6. //希望匹配第二位是大写
  7. //希望匹配第三位是小写
  8. reg = /[0-9][A-Z][a-z]/g;
  10. console.log(str.match(reg)); //null
  11. console.log(str1.match(reg)); //["0Dg"]
  1. // 表达式内部写 ^ 代表 非
  2. var str = 'fiksodf090dg0erGEOGIV-G345;Lgf-',
  3.   str1 = 'fiksodf090Dg0erGEOGIV-G345;Lgf-';
  5. //希望匹配第一位不是数字
  6. //希望匹配第二位是大写
  7. //希望匹配第三位是小写
  8. reg = /[^0-9][A-Z][a-z]/g;
  10. console.log(str.match(reg)); //[";Lg"]
  11. console.log(str1.match(reg)); //[";Lg"]
  1. // 表达式内部写 | 代表 或
  2. var str = '234siafdgosafdigj123sdfhsoarg',
  3.   reg = /123|234/g,
  4.   reg2 = /123|234[s-z]/g,
  5.   // 希望或了之后再匹配
  6.   reg3 = /(123|234)[s-z]/g;
  8. console.log(str.match(reg)); //["234", "123"]
  9. console.log(str.match(reg2)); //["234s", "123"]
  10. console.log(str.match(reg3)); //["234s", "123s"]

元字符

即正则使用的转义符号

  • \w：[0-9A-z_]
  • \W：[^\w] 非\w区间的所有字符
  • \d：[0-9] digit 数字
  • \D：[^\d] 非数字
  • \s：[\r\n\t\v\f] -> [回车\换行\制表\垂直\换页]
  • \S：[^\s]
  • \b： 单词边界
  • \B： 非单词边界
  • .： 可以匹配除了回车和换行的所有字符
  1. // \W \w
  2. var reg = /\wab/g,
  3.   reg1 = /\Wab/g,
  4.   str = '234abc-%&',
  5.   str1 = '234%abc-%&';
  7. console.log(str.match(reg)); //["4ab"]
  8. console.log(str.match(reg1)); //null
  9. console.log(str1.match(reg1)); //["%ab"]
  1. // \W \w
  2. var reg = /[\w][\W][\w]/g,
  3.   reg1 = /[\W][\W][\W]/g,
  4.   str = '234%abc-%&';
  6. console.log(str.match(reg)); //["4%a"]
  7. console.log(str.match(reg1)); //["-%&"]
  1. // \d \D
  2. var reg = /\dab/g,
  3.   reg1 = /\Dab/g,
  4.   str = '234%abc-%&';
  6. console.log(str.match(reg)); //null
  7. console.log(str.match(reg1)); //["%ab"]
  1. //\s \S 
  2. var reg = /\sab/g,
  3.   str = '23 ab-$%';
  5. console.log(str.match(reg)); //[" ab"]
  1. //\b \B 
  2. var reg = /\bThis\b/g,
  3.   str = 'This is a test';
  5. console.log(str.match(reg)); //["This"]
  1. //.
  2. var reg = /./g,
  3.   str = 'This\ris\na\ttest';
  5. console.log(str.match(reg));
  6. //["T", "h", "i", "s", "i", "s", "a", "\t", "t", "e", "s", "t"]
  1. //如何匹配全部字符
  2. //希望匹配3位全部字符
  3. var reg = /[\w\W][\s\S][\d\D]/g,
  4.   str = 'abcdefg';
  6. console.log(str.match(reg));
  7. //["abc", "def"]

原则

正则的两个原则:

  1. 不回头
  2. 贪婪模式(能匹配多就不匹配少)

量词

  • n+：{1, 正无穷} 出现1次到正无穷
  • n*：{0, 正无穷} 出现0次到正无穷
  • n?：{0, 1} 出现0次到1次
  1. //+ 
  2. //只要符合条件 有+的情况下,出现多少次,匹配出多少次结果
  3. //分析:匹配0-9A-Z包括_中任意一个字符可以出现1次或者多次的字符串匹配出来
  4. var reg = /\w+/g,
  5.   str = 'abcdefg';
  6. console.log(str.match(reg)); //["abcdefg"]
  1. //* 
  2. //只要符合条件 有*的情况下,出现多少次,匹配出多少次结果
  3. //分析:
  4. //1.匹配0 - 9A - Z包括_中任意一个字符可以出现0次或者多次的字符串匹配出来
  5. //2.匹配到结尾g  贪婪 0次: 发现仍有空, 就把空字符也匹配进去
  6. var reg = /\w*/g,
  7.   str = 'abcdefg';
  8. console.log(str.match(reg)); //["abcdefg", ""]
  1. //* 
  2. //分析:
  3. //匹配a非数字匹配不上 贪婪 遇到空 
  4. //匹配b非数字匹配不上 贪婪 遇到空
  5. //...
  7. //原理:
  8. //字符串从左到右,依次先匹配多,再匹配少,如果一旦匹配上就不回头匹配
  9. //贪婪匹配原则: 能匹配上多个,绝不匹配少个.
  11. var reg = /\d*/g,
  12.   str = 'abcdefg';
  13. console.log(str.match(reg));
  14. //["", "", "", "", "", "", "", ""]
  1. //?
  2. //一旦匹配上就不回头匹配 再匹配匹配一个空
  3. var reg = /\w?/g,
  4.   str = 'abcdefg';
  5. console.log(str.match(reg));
  6. //["a", "b", "c", "d", "e", "f", "g", ""]
  1. //n{x, y} 区间问题 
  2. //注意这里有空格返回null
  3. var reg = /\w{1, 2}/g,
  4.   str = 'abcdefg';
  5. console.log(str.match(reg)); //null
  7. var reg1 = /\w{1,2}/g,
  8.   str = 'abcdefg';
  9. console.log(str.match(reg1)); //["ab", "cd", "ef", "g"]
  1. //n{x,正无穷} 区间问题 
  2. //{1,正无穷} === n+
  3. var reg = /\w{1,}/g,
  4.   str = 'abcdefg';
  5. console.log(str.match(reg)); //["abcdefg"]
  7. //{0,正无穷} === n*
  8. var reg1 = /\w{0,}/g,
  9.   str = 'abcdefg';
  10. console.log(str.match(reg1)); //["abcdefg", ""]
  12. //{0,1} === n?
  1. //{5,正无穷}
  2. var reg = /\w{5,}/g,
  3.   str = 'abcdefg';
  4. console.log(str.match(reg)); //["abcdefg"]
  6. //不足5位
  7. var reg = /\w{5,}/g,
  8.   str1 = 'abcd';
  9. console.log(str1.match(reg)); //null
  1. //量词的上尖角号 ^n
  2. //匹配任何以n开头的字符串
  3. var reg = /^ab/g,
  4.   str = 'abcdabcd';
  5. console.log(str.match(reg)); //["ab"]
  7. //多行匹配也生效
  8. var reg1 = /^ab/gm,
  9.   str1 = 'abcdabcd\nabcdabcd';
  10. console.log(str1.match(reg1)); //["ab", "ab"]
  1. //问题:检查字符串是否以abcd开头和以abcd结尾
  2. //分析:以abcd开头任意字符匹配多次以abcd结尾
  3. var reg = /^abcd[\s\S]*abcd$/g,
  4.   str = 'abcd123123abcd';
  5. console.log(str.match(reg)); //["abcd123123abcd"]
  1. //问题:检查字符串是否以abcd开头和以abcd结尾, 并且开头结尾之间是数字
  2. var reg = /^abcd[\d]+abcd$/g,
  3.   str = 'abcd123123abcd';
  4. console.log(str.match(reg)); //["abcd123123abcd"]
  1. //匹配以138开头的11位手机号码
  2. var reg = /138[\d]{8}/g,
  3.   str = '13812345678';
  4. console.log(str.match(reg)); //["abcd123123abcd"]
  1. //?=n 匹配任何其后紧接着指定字符串n的字符串
  2. var reg = /a(?=b)/g,
  3.   str = 'abcdabcd';
  4. console.log(str.match(reg)); //["a", "a"]
  1. //?!n 匹配任何其后紧接着指定字符串n的字符串
  2. var reg = /a(?!b)/g,
  3.   str = 'abcdaccda';
  4. console.log(str.match(reg)); //["a", "a"]

子表达式/反向引用

  1. //xxxx 
  2. // 子表达式 反向引用 方法
  3. // 子表达式方式: ()匹配谁 有表达式 有记忆匹配的是谁
  4. // \1  匹配到第一个子表达式 反向引用子表达式
  5. // /(第一个子表达式)\1(第二个子表达式)/g
  6. // 举例: 
  7. // (a)\1 反向引用第一个子表达式
  8. // (a)\2 反向引用第二个子表达式
  9. // (a)\3 反向引用第三个子表达式
  11. var str = 'bbaaaaccaaaaiddddbaaaa',
  12.   // \1 这里反向引用3次
  13.   reg = /(a)\1\1\1/g,
  14.   //分析:(\w)带记忆后面的都反向引用3次
  15.   reg1 = /(\w)\1\1\1/g;
  16. console.log(str.match(reg)); 
  17. //["aaaa", "aaaa", "aaaa"]
  18. console.log(str.match(reg1)); 
  19. //["aaaa", "aaaa", "dddd", "aaaa"]
  1. //xxyy
  2. var str = 'aabbccddddddccceevv',
  3.   //这里反向引用第一个子表达式1次,反向引用第二个子表达1次
  4.   reg = /(\w)\1(\w)\2/g;
  5. console.log(str.match(reg)); 
  6. //["aabb", "ccdd", "dddd", "ccee"];

对象属性

  • reg.global：判断是否用g
  • reg.ignoreCase：判断是否用忽略大小写i
  • reg.multiline：判断是否用换行m
  • reg.resource：正则本体，如/(\w)/
  • reg.lastIndex：查到跟exec()执行后类数组里面的index一样的值，可更改值，还能调整下标

问题：如果用reg.lastIndex更改index的值 并不是需要的，它会变得怎么样？

执行1次找到跟修改数字接近得匹配的下标，执行2次会被修改为下一轮的下标

对象方法

  • reg.test(str)：判断是否能匹配出来
  • reg.exec()：执行
  1. //exec()
  2. var reg = /123/g,
  3.   str = '123123123123123';
  4. console.log(reg.exec(str));
  6. /**
  7.  * 问题: 此类数组继承的是Array.prototype, 不是应该继承Object.prototype吗?
  8.  * 自己写是继承Object.prototype, 但是这里的类数组是继承Array.prototype
  9.  * console.log(reg.exec(str));
  10.  * 打印出一个类数组
  11.  * ["123", index: 0, input: "123123123123123", groups: undefined]
  12.  *   0: "123"
  13.  *   groups: undefined
  14.  *   index: 0 //这里是下标/光标 第一次匹配exec()为0 第二次为3 第三次为6，第四次为9...直到匹配结束了就变回0 ,一轮一轮的匹配
  15.  *   input: "123123123123123"
  16.  *   length: 1
  17.  *   __proto__: Array(0)
  18.  */

在正则规则里包含反向引用子表达式时，执行exec()会在类数组中显示子表达式

  1. var reg = /(\w)\1(\w)\2/g,
  2.   str = 'aabbccddddddccceevvv';
  3. console.log(reg.exec(str));
  5. /**
  6.  * ["aabb", "a", "b", index: 0, input: "aabbccddddddccceevvv", groups: undefined]
  7.  *   0: "aabb"
  8.  *   1: "a" 第一项子表达式是a
  9.  *   2: "b" 第二项子表达式是b
  10.  *   groups: undefined
  11.  *   index: 0
  12.  *   input: "aabbccddddddccceevvv"
  13.  *   length: 3
  14.  *   __proto__: Array(0)
  15.  */

关于exec():

  1. //不加g 返回单个值得数组
  2. // 加g 返回所有值的数组,具有记忆功能
  3. var str = 'cat,bat,sat,fat',
  4.   reg = /.at/g,
  5.   match1 = reg.exec(str),
  6.   match2 = reg.exec(str),
  7.   match3 = reg.exec(str),
  8.   match4 = reg.exec(str);
  10. console.log(match1);
  11. //["cat", index: 0, input: "cat,bat,sat,fat", groups: undefined]
  12. console.log(match2);
  13. //["bat", index: 4, input: "cat,bat,sat,fat", groups: undefined]
  14. console.log(match3);
  15. //["sat", index: 8, input: "cat,bat,sat,fat", groups: undefined]
  16. console.log(match4);
  17. //["fat", index: 12, input: "cat,bat,sat,fat", groups: undefined]

正向预查

匹配一个字符串，但有条件，字符串后面指定一个特定的字符或者字符串

  1. //找后面紧跟2的1
  2. var str = '1231231231',
  3.   reg = /1(?=2)/g;
  4. console.log(str.match(reg)); //["1", "1", "1"]

贪婪模式

能匹配多，不匹配少

注：?可以将贪婪模式改为非贪婪模式

  1. //匹配大括号包含里面的内容
  2. var str = 'abcd{{efg}}abcd{{xyz}}',
  3.   // 贪婪情况(默认)
  4.   reg = /{{.*}}/g,
  6.   //非贪婪情况
  7.   //任意字符零次或多次
  8.   //? 可以将贪婪模式改为非贪婪模式
  9.   reg1 = /{{(.*?)}}/g;
  10. console.log(str.match(reg)); //["{{efg}}abcd{{xyz}}"]
  11. console.log(str.match(reg1)); //["{{efg}}", "{{xyz}}"]

能匹配多，不匹配少(贪婪)

  1. //匹配0次或1次,先匹配1次然后匹配0次
  2. var str = 'aaaaaa',
  3.   reg = /\w?/g;
  4. console.log(str.match(reg));
  5. //["a", "a", "a", "a", "a", "a", ""]

能匹配少就不匹配多(非贪婪)

  1. //能匹配少就不匹配多,并把多次省略掉
  2. var str = 'bbbbbbbb',
  3.   reg = /\w??/g;
  4. console.log(str.match(reg));
  5. //["", "", "", "", "", "", "", "", ""]

replace()

  1. var str = 'JSplusplus',
  2. // str.replace('要被替换的字符串', '+');
  3. reg = /plus/;
  4. reg1 = /plus/g;
  6. console.log(str.replace('plus','+')); //JS+plus
  7. console.log(str.replace(reg,'+')); //JS+plus
  8. console.log(str.replace(reg1,'+')); //JS++
  1. //xxyy -> yyxx
  2. var str ='aabbccdd',
  3. reg = /(\w)\1(\w)\2/g;
  5. // 写法一
  6. //希望变成bbaaddcc
  7. // $可以拿到
  8. // 将第二个反向引用子表达式重复两遍，再重复两遍第一个反向引用子表达式两遍
  9. console.log(str.match(reg)); //["aabb", "ccdd"]
  10. console.log(str.replace(reg, '$2$2$1$1')); //bbaaddcc
  12. // 写法二
  13. console.log(
  14.   str.replace(reg, function ($, $1, $2) {
  15.     // console.log($, $1, $2);
  16.     //第一次打印：当前被匹配字符串，第一个子表达式，第二个子表达式
  17.     //aabb a b
  19.     //第二次打印：当前被匹配字符串，第一个子表达式，第二个子表达式
  20.     //ccdd c d
  22.     // return $2$2$1$1; //报错
  23.     return $2 + $2 + $1 + $1; //bbaaddcc
  24.   })
  25. );
  1. //js-plus-plus -> jsPlusPlus
  2. var str = "js-plus-plus",
  3.   reg = /-(\w)/g;
  5. console.log(
  6.   str.replace(reg, function ($, $1) {
  7.     console.log($, $1); //-p p
  8.     return $1.toUpperCase();
  9.   })
  10. ); //jsPlusPlus
  1. //jsPlusPlus -> js_plus_plus
  2. var str = "jsPlusPlus",
  3.   //匹配大写
  4.   reg = /([A-Z])/g;
  6. console.log(
  7.   str.replace(reg, function ($, $1) {
  8.     console.log($, $1); //P P
  9.     return "_" + $1.toLowerCase();
  10.   })
  11. ); //js_plus_plus
  1. //xxyyzz -> XxYyZz
  2. var str = "xxyyzz",
  3.   reg = /(\w)\1(\w)\2(\w)\3/g;
  5. console.log(
  6.   str.replace(reg, function ($, $1, $2, $3) {
  7.     // console.log($, $1); //xxyyzz x
  8.     return (
  9.       $1.toUpperCase() + $1 + 
  10.       $2.toUpperCase() + $2 + 
  11.       $3.toUpperCase() + $3
  12.     );
  13.   })
  14. ); //XxYyZz
  1. //aabbcc -> a$b$c$ -> 不能使用function
  2. var str = "aabbcc",
  3.   reg = /(\w)\1(\w)\2(\w)\3/g;
  5. console.log(
  6.   // str.replace(reg,'$1$$2$$3$') //a$2$3$
  7.   str.replace(reg,'$1$$$2$$$3$$') //a$b$c$
  8. );
  1. //aabbcc -> abc
  2. // 字符串去重
  3. var str = "aaaaabbbccccccccc",
  4. // 匹配0次或多次
  5. reg = /(\w)\1*/g;
  7. console.log(str.replace(reg, "$1"));
  1. //100000000000 -> 100,000,000,000
  2. var str = "100000000000",
  3. // 匹配0次或多次
  4. // \B 非单词边界
  5. reg = /(\d{3})/g;
  6. reg1 = /(\d{3}\B)/g;
  8. console.log(str.replace(reg, "$1,")); //100,000,000,000,
  9. console.log(str.replace(reg1, "$1,")); //100,000,000,000