正则表达式

正则表达式

创建方法

构造函数创建

• var reg=new RegExp(正则内容，修饰符）

字面量创建

• var reg=/正则内容/修饰符

修饰符

i

• 不区分大小写

g

• 全局匹配

m

• 多行匹配

正则对象方法

test()

    var reg=/a/i;
    var bool=reg.test("bcAdf");
    console.log(bool);//true

• 判断test()参数中的字符串中有没有匹配正则表达式内容,返回一个布尔值,方法用于匹配字符串,匹配成功返回true,失败返回false

exec()

 var reg=/a/ig;
 var arr=reg.exec("bcAdfa");
 console.log(arr);//["A",index:2,input:"bcAdfa",group:undefined]

• 返回一个数组，表示exec()参数中字符串匹配正则的内容，不会全局匹配.检索字符串中的指定值。返回值是被找到的值。如果没有发现匹配，则返回 null。

字符串的方法

search()

  var str="0Babcdef";
  var index= str.search(/b/i);
  console.log(index);//1

• 只能找到第一个不能全局匹配，参数与match相同,返回字符串中第一个匹配项的索引下标,没有匹配项返回-1

match()

  var str="0Babcdef";
  var arr=str.match(/b/ig);
  console.log(arr);//["B","b"]

• 把找到匹配的元素用数组罗列，如果没有全局匹配和exec()相同.接受一个参数,正则去匹配字符串,如果匹配成功,就返回匹配成功的数组,如果匹配不成功,就返回null

replace()

 var str="0Babcdef";
   str=str.replace(/b/ig,"z");
   console.log(str);//ozazcdef

 str=str.replace(/b/ig,function(item,index){
        if(item==="B") return "Z";
        return "z";
    });
    console.log(str);//oZabxdf

• 当使用全局匹配时，可以完全所有元素的匹配替换.接受两个参数,第一个是匹配项,第二个可以是字符串或是一个函数

split()

        var str="abc(nihao)dejs";
        str=str.split(/[\(\)]/)[1];
        console.log(str);//nihao

• 把字符串分割为字符串数组。

元字符

点通配符

var str="catcbtc/tc1tc.tcabt";
console.log(str.match(/c.t/g))
//Array(5)
"cat"","cbt","c/t","c1t",:c.t"

• 查找单个字符，除了换行和行结束符。.匹配任何一个字符.

.

var str="catcbtc/tc1tc.tcabt";
console.log(str.match(/c\.t/g));//"c.t"

• 把通配符.转为字符.

[ab] 表示a或者b任意一个字符

[abcdefghi] 匹配其中任意一个

var str="catcbtc/tc1tc.tcabt";
console.log(str.match(/c[abcdefghi]t/g))//
["cat", "cbt"]
console.log(str.match(/c[a-i]t/g))//["cat", "cbt"]
console.log("catcytcjt".match(/c[a-ik-z]t/g))//(2) ["cat", "cyt"]

注意

• 写在[]中的.就是转义字符.，不是通配符

  console.log("ab.cd".match(/[ad.]/g));//
  ["a", ".", "d"]

• 所有的括号必须增加转义\

console.log("ab.cd".match(/[\{\}\[\]\(\)]/g));//null

• 两个\ 在字符或者正则表达式的[]都是一个\

 console.log("aa\\a\a".match(/[\\]/g));//["\"]

方括号[ ]

• [abc]

  • 查找方括号之间的任何字符。

• [^abc]

  • 查找任何不在方括号之间的字符。

• [0-9]

  • 查找任何从 0 至 9 的数字。

• [a-z]

  • 查找任何从小写 a 到小写 z 的字符。

• [A-Z]

  • 查找任何从大写 A 到大写 Z 的字符。

^

• 在[]内第一个字符是^，表示后面的字符不用，取反

console.log("abcdef".match(/[^d]/g));
//Array(5)
  0: "a"
  1: "b"
  2: "c"
  3: "e"
  4: "f"
  length: 5

• 如果^不是第一个，作为字符^使用

 console.log("abc^def".match(/[a^c]/g));//(3) ["a", "c", "^"]

转义字符类

• \w

  • 查找单词字符。包括字母、数字和下划线

• \W

  • 查找非单词字符。

• \s

  • 查找空白字符。

• \S

  • 查找非空白字符。

• \d

  • 查找数字。

• \D

  • 查找非数字字符。

重复

n{X}

• 匹配包含 X 个 n 的序列的字符串。

n{X,Y}

• 匹配包含 X 或 Y 个 n 的序列的字符串。

n{X,}

• 匹配包含至少 X 个 n 的序列的字符串。

n{0}

console.log("aaaaaaa".match(/a{0}/g));//
 ["", "", "", "", "", "", "", ""]

• 空字符串 空字符

贪婪匹配

console.log("aaaaaaa".match(/a{1,4}/g));//Array(2)
0: "aaaa"
1: "aaa"

• 先匹配最大的字符串

非贪婪匹配

• * 或者+ 或者 ｛num,｝ ? 来匹配最少的部分

/a*/g

• 等同于/a{0,}/g

/a+/g

• /a{1,}/g

/a?/g

• /a{0,1}/g

选择和起始结束

var inputs=document.querySelectorAll("input");
        init();
        function init(){
            inputs.forEach(function(item){
                item.ids=0;
                item.addEventListener("input",inputHandler)
            })
        }
        function inputHandler(e){
            if(this.ids) return;
            var input=this;
            this.ids=setTimeout(function(){
                clearTimeout(input.ids);
                input.ids=undefined;
                regText(input);
            },500)
        }

        function regText(input){
            var span= input.nextElementSibling;
            if(regTest(input.value,input.name)){
                span.textContent="OK";
                span.style.color="green";
            }else{
                span.textContent="错误";
                span.style.color="red";
            }
        }

        function regTest(txt,name){
            switch(name){
                case "user":
                return /^\w{8,36}$/.test(txt);
                case "password":
                return /^(?=\D+\d)(?=.*[a-z])(?=.*[A-Z])[a-zA-Z0-9]{8,16}$/.test(txt);
                case "email":
                return /^\w{3,36}@\w+\.(com|net|cn|org)$/.test(txt);
            }
            
        }

^ 起始符

console.log("bbaacc".match(/^a+/g));

• 表示开始从这个开始匹配，求起始就需要是一个字符串以上

$ 结束符

console.log("bbaacc".match(/c+$/g));

• 要求必须以某个字符结束

群组

match

• 当使用match时，如果使用群组，加上g和不加g是有差距，不加g可以将每个群组列表在数组的下标1开始的元素，加g就不能找到群组内容

 console.log("10[a]3[bc]".match(/(\d+)\[([a-zA-Z]+)\]/g))//Array(2)
  0: "10[a]"
  1: "3[bc]"
  length: 2

replace

• 在replace中如果不使用群组，后面的函数中参数第一位时符合正则内容，第二位是这个字符的下标。在replace中如果使用群组，后面的函数中参数分别是符合正则的内容，和每个群组的内容

  var str="10[a]3[bc]".replace(/(\d+)\[([a-zA-Z]+)\]/g,function(item1,item2,item3){
             return item3.repeat(item2);
          });
          console.log(str);//aaaaaaaaaabcbcbc

断言

前瞻断言 ?=， ?!

• 先行断言 紧随其后

  • 查找紧随其后的内容是某个字符的条件

 console.log("abac".replace(/a(?=c)/g,"z"));//abzc

查找紧随其后的内容不是某个字符的条件

  console.log("abac".replace(/a(?!c)/g,"z"));
  //zbac

后瞻断言 ?<=，?<!

• 后行断言 紧随其前

  • 前面必须是某个条件，紧随其后的字符

 console.log("abcb".replace(/(?<=a)b/g,"z"));//azcb

前面必须不是某个条件，紧随其后的字符

  console.log("abcb".replace(/(?<!a)b/g,"z"));//abcz
  
  console.log("6a66b7d".replace(/(?<=\d+)[a-z]+/g,"z"));//6z66z7z

1、字符中必须包含大写、小写字母，也必须包含数字，但是数字不能作为第一位使用

console.log(/^(?=\D+\d)(?=.*[a-z])(?=.*[A-Z])(?=.*\W).{8,16}$/)

匹配中文字符

• /[\u4e00-\u9fa5]/