精华内容
下载资源
问答
  • 要将resultStr中{}内部的内容识别出来,并与 = 前的内容匹配。即得到 author的值为S. Alireza Aghili and Divyakant Agrawal and Amr El Abbadi, title的值为Protein structure alignment using geometrical ...
  • // 自定义规则——该规则为匹配连续的8位数字 String rule = "\\d{8}"; Pattern p = Pattern.compile(rule); Matcher m = p.matcher(text); String date = null; while (m.find()) {
    // 静态方法调用
     private static String doDate(String text) {
     		// 自定义规则——该规则为匹配连续的8位数字 
     		String rule = "\\d{8}";
            Pattern p = Pattern.compile(rule);
            Matcher m = p.matcher(text);
            String date = null;
            while (m.find()) {
                date = m.group();
            }
            return date;
        }
    

    正则表达式在线测试工具:https://tool.oschina.net/regex

    展开全文
  • 正则表达式都是操作字符串的作用:对数据进行查找、替换、有效性验证创建正则表达式的两种方式://字面量方式/js///构造函数方式regular expressionnew RegExp()普通字符:字母 数字 汉字 _ 空格 ; , @ (没有特殊...

    正则表达式都是操作字符串的

    作用:对数据进行查找、替换、有效性验证

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

    //字面量方式

    /js/

    //构造函数方式

    regular expressionnew RegExp()

    普通字符:字母 数字 汉字 _ 空格 ; , @ (没有特殊含义的符号)

    两种匹配的方式:

    test 测试,找到返回true,反之为false

    exec 匹配字符,找到的话就返回该字符(以数组形式),反之返回null

    这两个都是属于正则的方法,所以前面是跟的正则

    var str="i love js";var pattern=/js/;

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

    console.log(pattern.exec(str));//["js", index: 7, input: "i love js", groups: undefined]

    var pattern=/Js/;

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

    console.log(pattern.exec(str));//null

    正则默认情况下是区分大小写的

    使用模式修饰符可以设置不区分大小写

    三种模式修饰符:

    i  ignoreCase  忽略大小写

    g  global  全局匹配

    m   multiline  多行匹配

    var str="i love js";var pattern=/Js/i;

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

    console.log(pattern.exec(str));//["js", index: 7, input: "i love js", groups: undefined]

    i g m这三个模式修饰符可以任意组合,无顺序要求

    var str="i love js";var pattern=new RegExp("js");

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

    console.log(pattern.exec(str));//["js", index: 7, input: "i love js", groups: undefined]

    var pattern=new RegExp("Js");

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

    console.log(pattern.exec(str));//null

    var pattern=new RegExp("Js","i");

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

    console.log(pattern.exec(str));//["js", index: 7, input: "i love js", groups: undefined]

    字面量方式与构造函数方式的区别:

    /js/i   直观简洁

    new RegExp("js", "i")  可以由于变量的检测

    var str="i love js";var userInput="js";//需要匹配的字符在变量中

    var pattern=/userInput/i;//该方式不可取,直接匹配的是userInput

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

    console.log(pattern.exec(str));//null

    var userInput="js";//需要匹配的字符在变量中

    var pattern="/"+userInput+"/i";//该方式不可取,正则变为了字符串,不再具有test和exec方法

    console.log(typeof pattern);//string

    console.log(pattern.test(str));//报错

    console.log(pattern.exec(str));//报错

    var pattern=new RegExp(userInput,"i");

    console.log(typeof pattern);//object 正则属于正则对象

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

    console.log(pattern.exec(str));//["js", index: 7, input: "i love js", groups: undefined]

    简单的转义字符

    / 表示正则的边界,匹配时需要进行转义

    var str="//我是注释";var pattern=;

    console.log(pattern.exec(str));//["//", index: 0, input: "//我是注释", groups: undefined]

    字符串中如果存在 ,默认会对下一个字符进行转义,如果需要作为普通字符处理,就对转义字符 再进行转义处理 \

    var str="\\";

    console.log(str);//结果只显示\

    普通字符加上 可能会有特殊含义

    如 n 代表换行

    var str="nba";var pattern=/n/;

    console.log(pattern.exec(str));//匹配n ["n", index: 0, input: "nba", groups: undefined]

    var pattern2=/n/;

    console.log(pattern2.exec(str));//匹配换行符 null

    t 匹配 tab键

    var str=" hello";var pattern=/t/;

    console.log(pattern.exec(str));//匹配n [" ", index: 0, input: " hello", groups: undefined]

    可以用 ascii码 来正则匹配字符

    var str="helloncyy";var pattern=/x0A/;

    console.log(pattern.exec(str));//匹配n ["↵", index: 5, input: "hello↵cyy", groups: undefined]

    可以用 unicode 编码来正则匹配字符

    var str=" 前面是tab键";var pattern=/u0009/;

    console.log(pattern.exec(str));//匹配tab键 [" ", index: 0, input: " 前面是tab键", groups: undefined]

    unicode 常用于匹配汉字

    匹配一个字符串中的所有中文:u4e00-u9fa5

    var str="i am 陈莺莺";var pattern=/[u4e00-u9fa5]/;

    console.log(pattern.exec(str));//匹配中文 ["陈", index: 5, input: "i am 陈莺莺", groups: undefined]

    可以匹配换行符的有: n    x0A   u000A

    字符类

    [ ] 匹配中间的任意一个字符

    var str="javascript";var pattern=/[js]/;

    console.log(pattern.exec(str));//匹配j ["j", index: 0, input: "javascript", groups: undefined]

    [^ ]  表示取反

    var str="javascript";var pattern=/[^js]/;//匹配除了j和s之外的

    console.log(pattern.exec(str));//["a", index: 1, input: "javascript", groups: undefined]

    [ ] 中间可以是一个范围

    var str="javascript";var pattern=/[k-z]/;//匹配k-z之间的字母

    console.log(pattern.exec(str));//["v", index: 2, input: "javascript", groups: undefined]

    表示范围时,前面的必须小于等于后面的

    var str="javascript";var pattern=/[c-c]/;//前面等于后面

    console.log(pattern.exec(str));//["c", index: 5, input: "javascript", groups: undefined]

    var pattern2=/[c-b]/;//前面大于后面

    console.log(pattern2.exec(str));//报错

    同时匹配大小写字母

    var str="JavaScript";var pattern=/[a-zA-Z]/;//前面等于后面

    console.log(pattern.exec(str));//["J", index: 0, input: "JavaScript", groups: undefined]

    匹配所有数字 0-9

    var str="JavaScript3333";var pattern=/[0-9]/;

    console.log(pattern.exec(str));//["3", index: 10, input: "JavaScript3333", groups: undefined]

    [ ] 中间可任意组合,如

    [a-zA-Z0-9@_]

    常用的字符类:

    . 匹配所有除了 n 之外的字符

    var str="3.14";var pattern=/./;

    console.log(pattern.exec(str));//["3", index: 0, input: "3.14", groups: undefined]

    如果单纯匹配 .  转义即可

    var str="3.14";var pattern=/./;

    console.log(pattern.exec(str));//[".", index: 1, input: "3.14", groups: undefined]

    . 不能匹配换行符

    var str="n";var pattern=/./;

    console.log(pattern.exec(str));//null

    数字字母下划线

    /[a-zA-Z0-9_]/      =    /w/

    /[^a-zA-Z0-9_]/    =   /W/

    var str="@_";var pattern=/w/;

    console.log(pattern.exec(str));//["_", index: 1, input: "@_", groups: undefined]

    数字

    /[0-9]/   =   /d/

    /[^0-9]/   =  /D/

    var str="@_123";var pattern=/d/;

    console.log(pattern.exec(str));//["1", index: 2, input: "@_123", groups: undefined]

    / /  匹配空格

    /  / 匹配 tab

    /s/  匹配空格或者制表符(tab)

    /S/  匹配除了空格或者制表符之外的其他字符

    匹配的顺序取决于字符串中的顺序

    var str=" 9";var pattern=/[ds]/;

    console.log(pattern.exec(str));//[" ", index: 0, input: " 9", groups: undefined]

    重复

    {n} 表示量词,出现 n 次

    var str="123456789";var pattern=/d{3}/;//匹配3个数字

    console.log(pattern.exec(str));//["123", index: 0, input: "123456789", groups: undefined]

    {n1, n2} 表示出现次数大于等于n1,小于等于n2

    var str="123456789";var pattern=/d{2,3}/;//匹配2-3个数字,会尽可能多的匹配

    console.log(pattern.exec(str));//["123", index: 0, input: "123456789", groups: undefined]

    {n1, } 表示大于等于n1

    { ,n2 } 不表示小于等于n2,这种写法是错误的

    var str="123456789";var pattern=/d{1,}/;

    console.log(pattern.exec(str));//["123456789", index: 0, input: "123456789", groups: undefined]

    var pattern2=/d{,2}/;//这种写法是错误的

    console.log(pattern2.exec(str));//null

    ?   =  {0,1}  匹配0次或者1次

    var str="123456789";var pattern=/d?/;

    console.log(pattern.exec(str));//["1", index: 0, input: "123456789", groups: undefined]

    +  =  {1,}  至少1次

    var str="123456789";var pattern=/d+/;

    console.log(pattern.exec(str));//["123456789", index: 0, input: "123456789", groups: undefined]

    *  =  任意次(包括0次)

    var str="123456789";var pattern=/d*/;

    console.log(pattern.exec(str));//["123456789", index: 0, input: "123456789", groups: undefined]

    匹配价格

    var str="肯德基豪华午餐¥15.5元";var pattern=/d+.?d*/;//前面的数字 至少有1位

    //. 出现0次或者1次

    //后面的数字 可以有也可以没有,任意次

    console.log(pattern.exec(str));//["15.5", index: 8, input: "肯德基豪华午餐¥15.5元", groups: undefined]

    匹配正整数和负整数

    var str="肯德基豪华午餐¥15.5元";var pattern=/-?[1-9]d*/;var pattern=/-{0,1}[1-9]d*/;

    非贪婪的重复

    正则匹配默认是贪婪模式,存在量词时会尽可能多的匹配

    var str="aaab";var pattern=/a+/;

    console.log(pattern.exec(str));//["aaa", index: 0, input: "aaab", groups: undefined]

    在量词后面加上 ?  ,表示由贪婪模式转为非贪婪模式,尽可能少的匹配

    var str="aaab";var pattern=/a+?/;

    console.log(pattern.exec(str));//["a", index: 0, input: "aaab", groups: undefined]

    但是正则有一个原则,就是去找第一个可能匹配的字符

    而不是最合适的位置

    var str="aaab";var pattern=/a+?b/;//此处并不会匹配到ab

    console.log(pattern.exec(str));//["aaab", index: 0, input: "aaab", groups: undefined]

    如上,并不会匹配到ab,因为正则从0开始就匹配到了a,之后会一直沿着下去寻找b

    贪婪匹配与非贪婪匹配的应用

    var str="

    第一格第二格";var pattern=/.*/;//贪婪模式,匹配两格

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

    第一格第二格", index: 0, input: "第一格第二格", groups: undefined]

    var pattern2=/

    .*?/;//非贪婪模式,匹配一格

    console.log(pattern2.exec(str));//["

    第一格", index: 0, input: "第一格第二格", groups: undefined]

    选择 |

    var str="css js";var pattern=/js|html|css/;

    console.log(pattern.exec(str));//["css", index: 0, input: "css js", groups: undefined]

    选择最先匹配的,而不是最合适的

    var str="ab";var pattern=/a|ab/;//先尝试匹配a,匹配成功后,不再匹配ab

    console.log(pattern.exec(str));//["a", index: 0, input: "ab", groups: undefined]

    正则匹配上传图片的后缀名:一般图片的后缀名有gif,jpg,jpeg,png等,并且不区分大小写

    /.gif|.jpg|.jpeg|.png/i

    分组和引用 ()

    var str="abab";var pattern=/(ab)+/;//将ab看成一个整体

    console.log(pattern.exec(str));//(2) ["abab", "ab", index: 0, input: "abab", groups: undefined]

    返回的数组中,第一个元素是匹配到的结果,第二个元素是 () 中分组的元素

    ( )  捕获分组

    (?: )  不捕获分组

    var str="abcd";var pattern=/(abc)d/;//匹配到abcd,捕获到abc

    console.log(pattern.exec(str));//(2) ["abcd", "abc", index: 0, input: "abcd", groups: undefined]

    var str="abcd";var pattern=/(?:abc)d/;//匹配到abcd,没有捕获

    console.log(pattern.exec(str));//(2) ["abcd", index: 0, input: "abcd", groups: undefined]

    平行分组依次返回

    var str="abcd";var pattern=/(ab)(cd)/;//匹配到abcd,第一个分组ab,第二个分组cd

    console.log(pattern.exec(str));//["abcd", "ab", "cd", index: 0, input: "abcd", groups: undefined]

    嵌套分组,按左边括号的顺序来进行返回

    var str="abcd";var pattern=/(a(b(c(d))))/;

    console.log(pattern.exec(str));//(5) ["abcd", "abcd", "bcd", "cd", "d", index: 0, input: "abcd", groups: undefined]

    可以在正则中直接使用分组  n 代表第n个分组

    var str="abcdab";var pattern=/(ab)cd1/;//1代表第一个分组,即ab

    console.log(pattern.exec(str));//(2) ["abcdab", "ab", index: 0, input: "abcdab", groups: undefined]

    分组的实际应用

    匹配外层容器中的html文本,外层容器是不确定的标签

    var str="

    这是html文本

    ";var pattern=/(.*?)1>/;//1代表闭合标签,必须与开始标签相同

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

    这是html文本

    ", "div", "

    这是html文本

    ", index: 0, input: "

    这是html文本

    ", groups: undefined]

    如上,第一个分组是外层标签名,第二个分组是获取到的内层html

    .exec 返回的数组:

    匹配到的结果

    分组依次返回

    index 匹配到的位置索引

    input 被匹配的字符串

    位置匹配之首尾匹配

    ^ 字符串的开始

    $ 字符串的结束

    var str="js";var pattern=/^js/;

    console.log(pattern.exec(str));//["js", index: 0, input: "js", groups: undefined]

    var str="html js";var pattern=/^js/;

    console.log(pattern.exec(str));//null

    匹配全是数字

    var str="123mm567";var pattern=/^d+$/;

    console.log(pattern.exec(str));//null

    if(pattern.test(str)){

    alert("全是数字");

    }else{

    alert("不全是数字");//不全是数字

    }

    反向思考,匹配不是数字

    var str="123mm567";var pattern=/D/;

    console.log(pattern.exec(str));//["m", index: 3, input: "123mm567", groups: undefined]

    if(!pattern.test(str)){

    alert("全是数字");

    }else{

    alert("不全是数字");//不全是数字

    }

    位置匹配之单词边界匹配

    单词边界 b

    非单词边界 B

    var str="js html";var pattern=/jsb/;

    console.log(pattern.exec(str));//["js", index: 0, input: "js html", groups: undefined]

    var str="@@@js@@@";//@也属于单词边界

    var pattern=/bjsb/;

    console.log(pattern.exec(str));//["js", index: 0, input: "js html", groups: undefined]

    实现可兼容IE低版本的 getElementsByClassName()

    Document
    • 1
    • 2
    • 3
    • 4

    functiongetByClass(className,node){//高版本浏览器

    if(document.getElementsByClassName(className)){returndocument.getElementsByClassName(className)

    }else{//IE低版本浏览器

    var node=node ||document;var arr=[];var elements=node.getElementsByTagName("*");//获取所有元素

    //注意,使用构造函数创建正则,其中的转义字符需要进行双重转义

    var pattern=new RegExp("(^|\s+)"+className+"($|\s+)");for(var i=0;i

    if(pattern.test(elements[i].className)){

    arr.push(elements[i]);

    }

    }returnarr;

    }

    }var odds=getByClass("odd");for(var i=0;i

    odds[i].style.background="pink";

    }var evens=getByClass("even");for(var i=0;i

    evens[i].style.background="#abcdef";

    }

    1075700f10e8b7c9b0f402169799a1a1.png

    使用单词边界的思路也可实现

    Document
    • 1
    • 2
    • 3
    • 4

    functiongetByClass(className,node){//高版本浏览器

    if(document.getElementsByClassName(className)){returndocument.getElementsByClassName(className)

    }else{//IE低版本浏览器

    var node=node ||document;var arr=[];var elements=node.getElementsByTagName("*");//获取所有元素

    //注意,使用构造函数创建正则,其中的转义字符需要进行双重转义

    var pattern=new RegExp("\b"+className+"\b");for(var i=0;i

    if(pattern.test(elements[i].className)){

    arr.push(elements[i]);

    }

    }returnarr;

    }

    }var odds=getByClass("odd");for(var i=0;i

    odds[i].style.background="pink";

    }var evens=getByClass("even");for(var i=0;i

    evens[i].style.background="#abcdef";

    }

    前瞻性匹配 (?= )

    var str="javascript";var pattern=/java(?=script)/;//如果java后面跟的是script,那么匹配出java

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

    var str="java";var pattern=/java(?=script)/;//如果java后面跟的是script,那么匹配出java

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

    负前瞻性匹配 (?!)

    var str="javascript";var pattern=/java(?!script)/;//如果java后面跟的是script,那么不匹配出java

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

    var str="java";var pattern=/java(?!script)/;//如果java后面跟的不是script,那么匹配出java

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

    RegExp 对象的实例方法

    其中的转义字符需要进行双重转义

    var pattern=new RegExp("b");

    console.log(pattern);

    var pattern=new RegExp("\b");

    console.log(pattern);///b/

    因此,如果是 ,直面量方式转义为 \,构造函数双重转义为 \\

    var pattern=new RegExp("\\");

    console.log(pattern);///\/

    pattern 就是正则实例的对象,pattern 拥有的方法就是实例方法

    如:  .test()     .exec()

    var str="js js js";var pattern=/js/;

    console.log(pattern.exec(str));//["js", index: 0, input: "js js js", groups: undefined]

    console.log(pattern.exec(str));//["js", index: 0, input: "js js js", groups: undefined]

    console.log(pattern.exec(str));//["js", index: 0, input: "js js js", groups: undefined]

    console.log(pattern.exec(str));//["js", index: 0, input: "js js js", groups: undefined]

    console.log(pattern.exec(str));//["js", index: 0, input: "js js js", groups: undefined]

    var pattern=/js/g;

    console.log(pattern.exec(str));//["js", index: 0, input: "js js js", groups: undefined]

    console.log(pattern.exec(str));//["js", index: 3, input: "js js js", groups: undefined]

    console.log(pattern.exec(str));//["js", index: 4, input: "js js js", groups: undefined]

    console.log(pattern.exec(str));//null

    console.log(pattern.exec(str));//["js", index: 0, input: "js js js", groups: undefined]

    如上,exec 有一个属性,叫 lastIndex,默认是0

    如果设置为全局匹配,则 lastIndex 是上一次匹配的结束位置的下一位

    如果匹配到为 null,就会自动重置为0,再次进行下一轮

    分组之后也能捕获

    var str="js js js";var pattern=/(j)s/;

    console.log(pattern.exec(str));//(2) ["js", "j", index: 0, input: "js js js", groups: undefined]

    console.log(pattern.exec(str));//(2) ["js", "j", index: 0, input: "js js js", groups: undefined]

    console.log(pattern.exec(str));//(2) ["js", "j", index: 0, input: "js js js", groups: undefined]

    console.log(pattern.exec(str));//(2) ["js", "j", index: 0, input: "js js js", groups: undefined]

    console.log(pattern.exec(str));//(2) ["js", "j", index: 0, input: "js js js", groups: undefined]

    var pattern=/(j)s/g;

    console.log(pattern.exec(str));//(2) ["js", "j", index: 0, input: "js js js", groups: undefined]

    console.log(pattern.exec(str));//(2) ["js", "j", index: 3, input: "js js js", groups: undefined]

    console.log(pattern.exec(str));//(2) ["js", "j", index: 6, input: "js js js", groups: undefined]

    console.log(pattern.exec(str));//null

    console.log(pattern.exec(str));//(2) ["js", "j", index: 0, input: "js js js", groups: undefined]

    实例:

    var str="1.js 2.js 3.js";var pattern=/js/g;var total=0;//出现的总次数

    varresult;while((result=pattern.exec(str))!=null){//先赋值再进行判断

    total++;

    console.log(result[0]+"第"+total+"次出现的位置是:"+result.index);

    }

    console.log("总共出现了"+total+"次");

    test 与 exec 类似原理

    var str="js js js";var pattern=/js/;

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

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

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

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

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

    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());///anb/ 此处返回的是字面量形式的字符串

    console.log(pattern.toLocaleString());///anb/

    console.log(pattern.valueOf());///anb/

    console.log(pattern.valueOf()===pattern);//true

    实例属性

    .ignoreCase  判断是否忽略大小写

    .global  是否全局

    .multiline  是否匹配到多行

    .source 返回字面量正则本身

    var str="js js js";var pattern=/js/im;

    console.log(pattern.ignoreCase);//true

    console.log(pattern.global);//false

    console.log(pattern.multiline);//true

    console.log(pattern.source);//js

    console.log(pattern.source===pattern);//false

    .lastIndex 最后一次匹配的位置的后一位

    var str="js js";var pattern=/js/;

    console.log(pattern.lastIndex);//0

    pattern.test(str);

    console.log(pattern.lastIndex);//0

    pattern.test(str);

    console.log(pattern.lastIndex);//0

    pattern.test(str);

    console.log(pattern.lastIndex);//0

    pattern.test(str);

    console.log(pattern.lastIndex);//0

    var pattern=/js/g;

    console.log(pattern.lastIndex);//0

    pattern.test(str);

    console.log(pattern.lastIndex);//2

    pattern.test(str);

    console.log(pattern.lastIndex);//5

    pattern.test(str);

    console.log(pattern.lastIndex);//0 匹配不到时重置到0

    pattern.test(str);

    console.log(pattern.lastIndex);//2

    构造函数属性  RegExp.

    .input 待匹配的字符串  =  $_

    .lastMatch  最近一次匹配到的字符  =  $&

    .leftContext 最近一次匹配时左边的字符  = $`

    .rightContext 最近一次匹配时右边的字符  = $'

    .lastParen  最近一次匹配到的子选项(分组中的内容) = $+

    .$n  捕获分组

    var str="js js";var pattern=/(j)s/;

    pattern.exec(str);//待匹配的字符串

    console.log(RegExp.input);//js js

    console.log(RegExp["$_"]);//js js

    //最近一次匹配到的字符

    console.log(RegExp.lastMatch);//js

    console.log(RegExp["$&"]);//js

    //最近一次匹配时左边的字符

    console.log(RegExp.leftContext);//空

    console.log(RegExp["$`"]);//空

    //最近一次匹配时右边的字符

    console.log(RegExp.rightContext);//js

    console.log(RegExp["$'"]);//js

    //最近一次匹配到的子选项(分组中的内容)

    console.log(RegExp.lastParen);//j

    console.log(RegExp["$+"]);//j

    //捕获分组

    console.log(RegExp.$1);//j

    string 对象中,与正则相关的方法

    str.search()  与是否全局无关,只查找一个,如果有,就返回 index

    如果没有,就返回 -1

    var str="js js";var pattern=/(j)s/;

    console.log(str.search(pattern));//0

    var pattern=/aa/;

    console.log(str.search(pattern));//-1

    str.match()

    普通匹配时与 exec 相同

    全局匹配时:直接返回所有匹配的元素,分组会失效

    var str="js js";var pattern=/(j)s/;

    console.log(str.match(pattern));//(2) ["js", "j", index: 0, input: "js js", groups: undefined]

    var pattern=/aa/;

    console.log(str.match(pattern));//null

    var pattern=/(j)s/g;

    console.log(str.match(pattern));//(2) ["js", "js"]

    var pattern=/aa/;

    console.log(str.match(pattern));//null

    str.match( pattern )

    非全局匹配时才能返回分组中的内容

    全局匹配时会返回所有匹配到的字符

    m 和 g 组合,结合首尾匹配,体现

    var str="1.jsn2.jsn3.js";var pattern=/js$/g;//匹配行尾的js,默认是一行

    console.log(str.match(pattern));//["js"]

    var pattern=/js$/mg;//匹配行尾的js,默认是多行

    console.log(str.match(pattern));//(3) ["js", "js", "js"]

    str.split()  字符串分割,转为数组

    var str="1,2,3";

    console.log(str.split(","));//(3) ["1", "2", "3"]

    var str="1, 2 , 3";var pattern=/s*,s*/g;

    console.log(str.split(pattern));//(3) ["1", "2", "3"]

    str.replace()

    var str="i love js js";

    console.log(str.replace("js","html"));//i love html js

    var pattern=/js/g;

    console.log(str.replace(pattern,"html"));//i love html html

    replace 替换时间格式

    var str="2020-2-15";var pattern=/-/g;

    console.log(str.replace(pattern,"/"));//2020/2/15

    使用 $n 进行分组引用

    var str="i love pink";var pattern=/(pink)/g;

    document.write(str.replace(pattern,"$1"));

    6a49820c2118c0bced4fd94c95cf438f.png

    敏感词的过滤

    var str="中国军队和阿扁一起办证";var pattern=/国军|阿扁|办证/g;

    document.write(str.replace(pattern,"*"));//中*队和*一起*

    一个文字对应一个 * 号

    $0 是每次匹配到的内容

    var str="中国军队和阿扁一起办证";var pattern=/国军|阿扁|办证/g;

    document.write(str.replace(pattern,function($0){

    console.log($0);var result="";for(var i=0;i

    result+="*";

    }returnresult;

    }));//中**队和**一起**

    616770985f901da86d62796dd47fe5c7.png

    f5  浅刷新

    ctrl+f5  深度刷新

    常用的正则表达式:

    1、QQ号:

    全数字 首位不是0  最少5位  (目前最多11位,以后可能会扩增)

    /^[1-9]d{4,10}$/

    /^[1-9]d{4,}$/

    2、用户名、昵称

    2-18位  中英文数字及下划线组成

    /^[ue400-u9fa5w]{2,18}$/

    /^[ue400-u9fa5a-zA-Z0-9_]{2,18}$/

    3、密码

    6-16位  不能有空白符  区分大小写

    /^S{6,16}$/

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

    首先是去除首部或者尾部

    var str=" cyy ";

    console.log("|"+str+"|");//| cyy |

    var pattern=/^s+/;

    str=str.replace(pattern,"");//替换左边空白符

    var pattern2=/s+$/;/*这里使用 s+ 比使用 s* 效率高

    s* 无论如何都会进行替换,哪怕没有空白符

    s+ 只在有空白符的时候进行替换,否则直接返回*/str=str.replace(pattern2,"");//替换右边空白符

    console.log("|"+str+"|");//|cyy|

    同时去除首尾空白符

    var str=" cyy ";

    console.log("|"+str+"|");//| cyy |

    var pattern=/^s+|s+$/g;

    str=str.replace(pattern,"");//替换左右空白符

    console.log("|"+str+"|");//|cyy|

    var str=" cyy ";

    console.log("|"+str+"|");//| cyy |

    functiontrim(str){return str.replace(/^s+/,"").replace(/s+$/,"");

    }

    console.log("|"+trim(str)+"|");//|cyy|

    5、转驼峰

    str.replace(pattern, 要替换的内容) 第二个参数可以是一个匿名函数的返回值

    匿名函数的参数中,第一个参数是匹配的内容,第二个参数开始是分组捕获的内容

    var str="background-color";var pattern=/-([a-z])/gi;发表于 2020-02-16 00:20

    阅读 ( 195 )

    推荐

    收藏

    展开全文
  • Python正则表达式1、 re.match函数re.match 尝试从字符串的起始位置匹配一个模式,如果不是起始位置匹配成功的话,match()就返回none。 re.match(pattern, string, flags=0)参数描述pattern匹配正则表达式string要...

    v2-99fbea9c5319c52c0d3bc34adf77c733_1440w.jpg?source=172ae18b

    Python正则表达式

    1、 re.match函数

    re.match 尝试从字符串的起始位置匹配一个模式,如果不是起始位置匹配成功的话,match()就返回none。

    re.match(pattern, string, flags=0)

    参数

    描述

    pattern

    匹配的正则表达式

    string

    要匹配的字符串。

    flags

    标志位,用于控制正则表达式的匹配方式,如:是否区分大小写,多行匹配等等

    2、 re.search函数

    re.search 扫描整个字符串并返回第一个成功的匹配。

    函数语法:

    re.search(pattern, string, flags=0)

    函数参数说明:

    参数

    描述

    pattern

    匹配的正则表达式

    string

    要匹配的字符串。

    flags

    标志位,用于控制正则表达式的匹配方式,如:是否区分大小写,多行匹配等等。

    3、 re.match与re.search的区别

    re.match 只匹配字符串的开始,如果字符串开始不符合正则表达式,则匹配失败,函数返回 None,而 re.search 匹配整个字符串,直到找到一个匹配。

    4、 检索和替换

    re.sub用于替换字符串中的匹配项。

    re.sub(pattern, repl, string, count=0, flags=0)

    参数:

    · pattern : 正则中的模式字符串。

    · repl : 替换的字符串,也可为一个函数。

    · string : 要被查找替换的原始字符串。

    · count : 模式匹配后替换的最大次数,默认 0 表示替换所有的匹配。

    · flags : 编译时用的匹配模式,数字形式

    5、 compile 函数

    compile 函数用于编译正则表达式,生成一个正则表达式( Pattern )对象,供 match() 和 search() 这两个函数使用。

    re.compile(pattern[, flags])

    · pattern : 一个字符串形式的正则表达式

    · flags 可选,表示匹配模式,比如忽略大小写,多行模式等,具体参数为:

    · re.I 忽略大小写

    o re.L 表示特殊字符集 w, W, b, B, s, S 依赖于当前环境

    o re.M 多行模式

    o re.S 即为' . '并且包括换行符在内的任意字符(' . '不包括换行符)

    o re.U 表示特殊字符集 w, W, b, B, d, D, s, S 依赖于 Unicode 字符属性数据库

    o re.X 为了增加可读性,忽略空格和' # '后面的注释

    6、 findall

    在字符串中找到正则表达式所匹配的所有子串,并返回一个列表,如果没有找到匹配的,则返回空列表。

    re.findall(string[, pos[, endpos]])

    参数:

    · string 待匹配的字符串。

    · pos 可选参数,指定字符串的起始位置,默认为 0。

    · endpos 可选参数,指定字符串的结束位置,默认为字符串的长度。

    7、 re.finditer

    和 findall 类似,在字符串中找到正则表达式所匹配的所有子串,并把它们作为一个迭代器返回。

    re.finditer(pattern, string, flags=0)

    参数

    描述

    pattern

    匹配的正则表达式

    string

    要匹配的字符串。

    flags

    标志位,用于控制正则表达式的匹配方式,如:是否区分大小写,多行匹配等等。

    8、 re.split

    split 方法按照能够匹配的子串将字符串分割后返回列表,它的使用形式如下:

    re.split(pattern, string[, maxsplit=0, flags=0])

    参数

    描述

    pattern

    匹配的正则表达式

    string

    要匹配的字符串。

    maxsplit

    分隔次数,maxsplit=1 分隔一次,默认为 0,不限制次数。

    flags

    标志位,用于控制正则表达式的匹配方式,如:是否区分大小写,多行匹配等等。

    9、 正则表达式对象

    re.RegexObject

    re.compile() 返回 RegexObject 对象。

    re.MatchObject

    group() 返回被 RE 匹配的字符串。

    start() 返回匹配开始的位置

    end() 返回匹配结束的位置

    span() 返回一个元组包含匹配 (开始,结束) 的位置

    10、 正则表达式修饰符 - 可选标志

    修饰符

    描述

    re.I

    使匹配对大小写不敏感

    re.L

    做本地化识别(locale-aware)匹配

    re.M

    多行匹配,影响 ^ 和 $

    re.S

    使 . 匹配包括换行在内的所有字符

    re.U

    根据Unicode字符集解析字符。这个标志影响 w, W, b, B.

    re.X

    该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。

    展开全文
  • 正则化匹配时,正则表达式pattern,需要匹配字符传string中的多处,并将没一处的位置信息返回! 2、代码: import java.util.ArrayList; import java.util.HashMap; import java.util.regex.Matcher; import java....

    1、需求:
    正则化匹配时,正则表达式pattern,需要匹配字符传string中的多处,并将没一处的位置信息返回!
    2、代码:

    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    public class test {
        public static void main(String[] args) {
            ArrayList<HashMap<String,Object>> list=new ArrayList<HashMap<String, Object>>();
            //“zidian”定义在此处,赋值要在循环内。
            HashMap<String,Object> zidian = null;
            String ss="ooaaoo";
            Pattern pt=Pattern.compile("(o+)");
            Matcher mt=pt.matcher(ss);
    //        mt.lookingAt();
            // mt.matches();
            while(mt.find()){
                System.out.println(mt.start());
                //赋值位置,每次循环要重新给字典赋内存空间,否则最后结果会覆盖前面结果。
                zidian=new HashMap<String, Object>();
    //            System.out.println(mt.end());
    //            System.out.println(mt.group());
                zidian.put("start",mt.start());
                zidian.put("end",mt.end());
                zidian.put("content",mt.group());
    //            ArrayList<Integer> span = new ArrayList<Integer>();
    //            span.add(mt.start());
    //            span.add(mt.end());
    //            zidian.put("span", span);
    //            System.out.println(zidian);
                list.add(zidian);
                System.out.println(list);
    
            }
    
        }
    }
    

    错误代码: HashMap<String,Object> zidian = new HashMap<String, Object>();
    这种方式,字典在存入list时,一直固定存入list的制定空间,当zidian值变化后,会覆盖原来的值。

    展开全文
  • 正则表达式是一个特殊的字符序列,它能帮助你方便的检查一个字符串是否与某种模式匹配。Python 自1.5版本起增加了re 模块,它提供 Perl 风格的正则表达式模式。re 模块使 Python 语言拥有全部的正则表达式功能。...
  • 正则表达式(regularExpression, re)是一个计算机科学的概念用于使用单个字符串来描述,匹配符合某个规则的字符串查找符合某些复杂规则的字符串的需要,正则表达式就是用于描述这些规则的工具正则表达式的写法- 参考...
  • Python3 正则表达式正则表达式是一个特殊的字符序列,它能帮助你方便的检查一个字符串是否与某种模式匹配。Python 自1.5版本起增加了re 模块,它提供 Perl 风格的正则表达式模式。re 模块使 Python 语言拥有全部的...
  • 1.python正则表达式中匹配(match)和查找(search)的区别答:正则表达式中match和search的方法比较相似相同点:都是在一个字符串s中寻找pat子字符串,如果能找到,就返回一个Match对象,如果找不到,就返回None。...
  • 概述正则表达式是一个特殊的字符序列,它能帮助你方便的检查一个字符串是否与某种模式匹配。Python 自1.5版本起增加了re 模块,它提供 Perl 风格的正则表达式模式。re 模块使 Python 语言拥有全部的正则表达式功能。...
  • Python 正则表达式re.matchre.match 尝试从字符串的起始位置匹配一个模式,匹配成功re.match方法返回一个匹配的对象,否则返回None。re.match(pattern, string, flags=0) import re print(re.match('www', '...
  • 正则表达式是一个特殊的字符序列,它能帮助我们方便的检查一个字符串是否与某种模式匹配。...^匹配字符串的开头$匹配字符串的末尾。.匹配任意字符,除了换行符,当re.DOTALL标记被指定时,则可以匹配...
  • 关于java正则匹配返回匹配的内容

    万次阅读 2017-12-07 10:23:49
    最近在使用Java正则进行字符串匹配的时候需要得到所有匹配的内容,记下一下方法: matcher.find()表示是否在指定的字符串中有匹配到的内容; 如果有匹配到,则通过matcher.group(i)循环输出所有匹配到的内容。...
  • 前几期讲了正则表表达式的一些概念,让我们具备正则表达式初步的印象,在python中使用re模块匹配字符串有match(),search(),findall()等方法。今天我们首先来看看match()方法的使用。使用match()方法匹配字符串...
  • 正则表达式正则表达式是一个特殊的字符序列,它能帮助你方便的检查一个字符串是否与某种模式匹配。Python 自1.5版本起增加了re 模块,它提供 Perl 风格的正则表达式模式。re 模块使 Python 语言拥有全部的正则表达式...
  • 一、简介正则表达式本身是一种...二、正则表达式中常用字符含义三、re模块中常用函数1、compile主要用于编译正则表达式,返回一个对象的模式,供 match() 、search() 、findall()等函数使用,语法格式如下:re.compi...
  • Python正则表达式正则表达式是一个特殊的字符序列,它能帮助你方便的检查一个字符串是否与某种模式匹配。re 模块也提供了与这些方法功能完全一致的函数,这些函数使用一个模式字符串做为它们的第一个参数。re.match...
  • 众多语言都能进行爬虫,但基于python...正则表达式正则表达式是一个特殊的字符序列,它能帮助你方便的检查一个字符串是否与某种模式匹配。就是 事先定义好的一些特定字符、及这些特定字符的组合,组成一个“规则字符...
  • 正则表达式是一个特殊的字符序列,它能帮助你方便的检查一个字符串是否与某种模式匹配。Python 中的 re 模块,提供 Perl 风格的正则表达式模式,使 Python 语言拥有全部的正则表达式功能,也提供了与这些方法功能...
  • 正则表达式的查找;主要是用到String类中的split();...来截取str.split(" ")按照空格截取str.split("cc+")按照c字符来截取,2个c或以上str.split((1)\\.+)按照字符串中含有2个字符或以上的地方截取(...
  • java正则边界匹配

    2020-06-05 20:03:56
    需求:有一个字符串"52,3,4",写一个正则表达式,传入2,但是字符串里面只有52,没有匹配的,返回false; 传入52,字符串里刚好有52可以匹配返回true 之前使用js来实现: "52,3,4".match(/\b52\b/)!=null; /...
  • Pattern类Java Pattern.matcher()匹配字符串或者返回Matcher实例Pattern.matcher()一个方法是对整个字符串进行匹配,只有整个字符串都匹配了才返回true;一个方法是返回一个Matcher实例。方法Pattern.matcher(String ...
  • 使用内置模块re,从内置角度可以看出来,正则的重要性。只有真正常用的模块才会被内置到python中。常用函数re.match方法返回一个匹配的对象,否则返回None。re.search方法返回一个匹配的对象,否则返回None。re.find...
  • 正则表达式是一个特殊的字符序列,能帮助用户检查一个字符串是否与某种模式匹配,从而达成快速检索或替换符合某个模式、规则的文本。Python 自1.5版本起增加了re 模块,它提供 Perl 风格的正则表达式模式。re 模块使...
  • 有人可以帮我使用正则表达式匹配来形成一个匹配给定字符串中的正则表达式的所有字符串的数组吗?谢谢!#1 热门回答(212 赞)(4castle's answer如果可以假设Java> = 9,则优于以下内容)你需要创建一个匹配器并使用...
  • 正则表达式是一个特殊的字符序列,它能帮助你方便的检查一个字符串是否与某种模式匹配。Python 自1.5版本起增加了re 模块,它提供 Perl 风格的正则表达式模式。re 模块使 Python 语言拥有全部的正则表达式功能。...
  • compile 函数根据一个模式字符串和可选的标志参数生成一个正则表达式对象。该对象拥有一系列方法用于正则表达式匹配和替换。re 模块也提供了与这些方法功能完全一致的函数,这些函数使用一个模式字符串做为它们的第...
  • 要使用Java正则表达式将一个字符串替换为另一个字符串,我们需要使用replaceAll()方法。该replaceAll()方法返回一个String,替换所有与正则表达式匹配的字符序列,并在替换后返回String。声明-java.lang.String....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 431
精华内容 172
关键字:

java正则返回匹配字符串

java 订阅