网创优客建站品牌官网
为成都网站建设公司企业提供高品质网站建设
热线:028-86922220
成都专业网站建设公司

定制建站费用3500元

符合中小企业对网站设计、功能常规化式的企业展示型网站建设

成都品牌网站建设

品牌网站建设费用6000元

本套餐主要针对企业品牌型网站、中高端设计、前端互动体验...

成都商城网站建设

商城网站建设费用8000元

商城网站建设因基本功能的需求不同费用上面也有很大的差别...

成都微信网站建设

手机微信网站建站3000元

手机微信网站开发、微信官网、微信商城网站...

建站知识

当前位置:首页 > 建站知识

怎么使用正则表达式

本篇内容介绍了“ 怎么使用正则表达式”的有关知识,在实际案例的操作过程中,不少人都会遇到这样的困境,接下来就让小编带领大家学习一下如何处理这些情况吧!希望大家仔细阅读,能够学有所成!

镇巴ssl适用于网站、小程序/APP、API接口等需要进行数据传输应用场景,ssl证书未来市场广阔!成为成都创新互联公司的ssl证书销售渠道,可以享受市场价格4-6折优惠!如果有意向欢迎电话联系或者加微信:028-86922220(备注:SSL证书合作)期待与您的合作!

一、前言

编程总在实践中出结果!

正则表达式,又称规则表达式。(英语:Regular Expression,在代码中常简写为regex、regexp或RE),计算机科学的一个概念。正则表达式通常被用来检索、替换那些符合某个模式(规则)的文本。

正则引擎主要可以分为两大类:一种是DFA,一种是NFA。这两种引擎都有了很久的历史(至今二十多年),当中也由这两种引擎产生了很多变体!于是POSIX的出台规避了不必要变体的继续产生。这样一来,主流的正则引擎又分为3类:一、DFA,二、传统型NFA,三、POSIX NFA。

正则也是一种非常有意思的技术,但往往不知道这些符号的编程在实际使用中该如何使用,因此总结了本篇文章,方便所有小伙伴可以当成一个工具文章使用,方便处理一些需要使用正则的技术内容。 

二、规则

1. 常用符号

  • x 字符 x
  • \ 反斜线字符
  • \0n 带有八进制值 0 的字符 n (0 <= n <= 7)
  • \0nn 带有八进制值 0 的字符 nn (0 <= n <= 7)
  • \0mnn 带有八进制值 0 的字符 mnn(0 <= m <= 3、0 <= n <= 7)
  • \xhh 带有十六进制值 0x 的字符 hh
  • \uhhhh 带有十六进制值 0x 的字符 hhhh
  • \t 制表符 ('\u0009')
  • \n 新行(换行)符 ('\u000A')
  • \r 回车符 ('\u000D')
  • \f 换页符 ('\u000C')
  • \a 报警 (bell) 符 ('\u0007')
  • \e 转义符 ('\u001B') 

2. 字母字符

  • [abc] a、b 或 c(简单类)
  • [^abc] 任何字符,除了 a、b 或 c(否定)
  • [a-zA-Z] a 到 z 或 A 到 Z,两头的字母包括在内(范围)
  • [a-d[m-p]] a 到 d 或 m 到 p:[a-dm-p](并集)
  • [a-z&&[def]] d、e 或 f(交集)
  • [a-z&&[^bc]] a 到 z,除了 b 和 c:[ad-z](减去)
  • [a-z&&[^m-p]] a 到 z,而非 m 到 p:[a-lq-z](减去) 

3. 预定义字符

  • . 任何字符(与行结束符可能匹配也可能不匹配)
  • \d 数字:[0-9]
  • \D 非数字:[^0-9]
  • \s 空白字符:[ \t\n\x0B\f\r]
  • \S 非空白字符:[^\s]
  • \w 单词字符:[a-zA-Z_0-9]
  • \W 非单词字符:[^\w] 

4. POSIX 字符

  • \p{Lower} 小写字母字符:[a-z]
  • \p{Upper} 大写字母字符:[A-Z]
  • \p{ASCII} 所有 ASCII:[\x00-\x7F]
  • \p{Alpha} 字母字符:[\p{Lower}\p{Upper}]
  • \p{Digit} 十进制数字:[0-9]
  • \p{Alnum} 字母数字字符:[\p{Alpha}\p{Digit}]
  • \pPunct} 标点符号:!"#$%&'()*+,-./:;<=>?@[]^_`{~
  • \p{Graph} 可见字符:[\p{Alnum}\p{Punct}]
  • \p{Print} 可打印字符:[\p{Graph}\x20]
  • \p{Blank} 空格或制表符:[ \t]
  • \p{Cntrl} 控制字符:[\x00-\x1F\x7F]
  • \p{XDigit} 十六进制数字:[0-9a-fA-F]
  • \p{Space} 空白字符:[ \t\n\x0B\f\r] 

5. Character 类

  • \p{javaLowerCase} 等效于 java.lang.Character.isLowerCase()
  • \p{javaUpperCase} 等效于 java.lang.Character.isUpperCase()
  • \p{javaWhitespace} 等效于 java.lang.Character.isWhitespace()
  • \p{javaMirrored} 等效于 java.lang.Character.isMirrored() 

6. Unicode 块和类别的类

  • \p{InGreek} Greek 块(简单块)中的字符
  • \p{Lu} 大写字母(简单类别)
  • \p{Sc} 货币符号
  • \P{InGreek} 所有字符,Greek 块中的除外(否定)
  • [\p{L}&&[^\p{Lu}]]  所有字母,大写字母除外(减去) 

7. 边界匹配器

  • ^ 行的开头
  • $ 行的结尾
  • \b 单词边界
  • \B 非单词边界
  • \A 输入的开头
  • \G 上一个匹配的结尾
  • \Z 输入的结尾,仅用于最后的结束符(如果有的话)
  • \z 输入的结尾

8. Greedy 数量词

  • X? X,一次或一次也没有
  • X* X,零次或多次
  • X+ X,一次或多次
  • X{n} X,恰好 n 次
  • X{n,} X,至少 n 次
  • X{n,m} X,至少 n 次,但是不超过 m 次

9. Reluctant 数量词

  • X?? X,一次或一次也没有
  • X*? X,零次或多次
  • X+? X,一次或多次
  • X{n}? X,恰好 n 次
  • X{n,}? X,至少 n 次
  • X{n,m}? X,至少 n 次,但是不超过 m 次

10. Possessive 数量词

  • X?+ X,一次或一次也没有
  • X*+ X,零次或多次
  • X++ X,一次或多次
  • X{n}+ X,恰好 n 次
  • X{n,}+ X,至少 n 次
  • X{n,m}+ X,至少 n 次,但是不超过 m 次

11. Logical 运算符

  • XY X 后跟 Y
  • X|Y X 或 Y
  • (X) X,作为捕获组 

12. Back 引用

  • \n 任何匹配的 nth 捕获组

13. 引用

  • \ Nothing,但是引用以下字符
  • \Q Nothing,但是引用所有字符,直到 \E
  • \E Nothing,但是结束从 \Q 开始的引用

14. 特殊构造(非捕获)

  • (?:X) X,作为非捕获组
  • (?idmsux-idmsux)  Nothing,但是将匹配标志i d m s u x on - off
  • (?idmsux-idmsux:X)   X,作为带有给定标志 i d m s u x on - off  的非捕获组  (?=X) X,通过零宽度的正 lookahead
  • (?!X) X,通过零宽度的负 lookahead
  • (?<=X) X,通过零宽度的正 lookbehind
  • (?
  • (?>X) X,作为独立的非捕获组

三、案例

1. 字符匹配

"a".matches(".")
 
  • 结果:true
  • 描述:. 匹配任意字符

"a".matches("[abc]")
 
  • 结果:true
  • 描述:包含 abc 任意一个字符都匹配,默认匹配一次

"a".matches("[^abc]")
 
  • 结果:true
  • 描述:任何字符,除了 a、b 或 c(否定)

"A".matches("[a-zA-Z]")
 
  • 结果:false
  • 描述:a 到 z 或 A 到 Z,两头的字母包括在内(范围)

"A".matches("[a-z]|[A-Z]")
 
  • 结果:true
  • 描述:a 到 z 或 A 到 Z,两头的字母包括在内(范围)

"A".matches("[a-z(A-Z)]")
 
  • 结果:true
  • 描述:a-z,A-Z,匹配范围相同,括号是捕获组

"R".matches("[A-Z&&(RFG)]")
 
  • 结果:true
  • 描述:匹配 A-Z 与 RFG 交集

"a_8".matches("\\w{3}")
 
  • 结果:true
  • 描述:\w 单词字符等同于 [a-zA-Z_0-9],{3} 匹配三次

"\\".matches("\\\\")
 
  • 结果:true
  • 描述:\ 表示的是一个 \

"hello sir".matches("h.*")
 
  • 结果:true
  • 描述:. 任何字符,* 匹配零次到多次

"hello sir".matches(".*ir$")
 
  • 结果:true
  • 描述:.* 匹配任意字符 ir$ 确定匹配行的结尾

"hello sir".matches("^h[a-z]{1,3}o\\b.*")
 
  • 结果:true
  • 描述:^h 匹配开头,[a-z]{1,3}o 匹配1到3次的a-z之后匹配字母o,\b 并不匹配这些单词分隔字符中的任何一个,它只匹配一个位置。匹配的是o后面的位置。

"hellosir".matches("^h[a-z]{1,3}o\\b.*")
 
  • 结果:false
  • 描述:o后面跟着s,是字母,不是空格,\b 不能匹配单词的o的边界。

" \n".matches("^[\\s&&[^\\n]]*\\n$")
 
  • 结果:true
  • 描述:匹配开头是一个空格     ^[\\s&&[^\\n]],且不能是换行符,最后必须是换行     \\n$

System.out.println("java".matches("(?i)JAVA"));
 
  • 结果:true
  • 描述:(?i)非捕获组里面这个表示忽略大小写 

2. 模式匹配 

2.1 验证匹配
Pattern p = Pattern.compile("[a-z]{3,}");
Matcher m = p.matcher("fgha");
System.out.println(m.matches()); // true,匹配字符3次及以上
 
  • 结果:true
  • 描述:Pattern 与 Matcher 一起合作 .Matcher 类提供了对正则表达式的分组支持,以及对正则表达式的多次匹配支持.。单独用Pattern只能使用 Pattern.matches(String regex,CharSequence input) 一种最基础最简单的匹配。 
2.2 匹配功能
Pattern p = Pattern.compile("\\d{3,5}");
Matcher m = p.matcher("123-4536-89789-000");
System.out.println(m.matches());
m.reset();// 把吃进去的字符吐出来重新匹配,否经过m2.matches会吃进去字符 下面的匹配就不成功
System.out.println(m.find());
System.out.println(m.start() + "-" + m.end());  // 找到了 就把首位位置打印下(必须找到才能打印)
System.out.println(m.find());
System.out.println(m.start() + "-" + m.end()); // 找到了 就把首位位置打印下(必须找到才能打印)
System.out.println(m.find());
System.out.println(m.start() + "-" + m.end()); // 找到了 就把首位位置打印下(必须找到才能打印)
System.out.println(m.find());
System.out.println(m.lookingAt());              //每次都是才头上开始找

测试结果

false
true
0-3
true
4-8
true
9-14
true
true
  • m.matches(),是全量匹配
  • m.reset(),把吃进去的字符吐出来重新匹配,否经过m2.matches会吃进去字符 下面的匹配就不成功
  • m.find(),查找匹配
  • m.start(),匹配到的字符串,开始位置
  • m.end(),匹配到的字符串,结束位置 
2.3 匹配普通替换
Pattern p = Pattern.compile("java",Pattern.CASE_INSENSITIVE);
Matcher m = p.matcher("java_Java_jAva_jAVa_IloveJava");
System.out.println(m.replaceAll("JAVA"));
 
  • 结果:JAVA_JAVA_JAVA_JAVA_IloveJAVA
  • 描述:把所有匹配到的小写字母 java、JavA,都匹配为大写 
2.4 匹配逻辑替换
Pattern p = Pattern.compile("java", Pattern.CASE_INSENSITIVE);
Matcher m = p.matcher("java_Java_jAva_jAVa_IloveJava fdasfas");
StringBuffer sb = new StringBuffer();
int i = 0;
while (m.find()) {
    i++;
    if (i % 2 == 0) {
        m.appendReplacement(sb, "java");
    } else {
        m.appendReplacement(sb, "JAVA");
    }
}
m.appendTail(sb);
System.out.println(sb);
 
  • 结果:JAVA_java_JAVA_java_IloveJAVA fdasfas
  • 描述:按照程序逻辑     i % 2,进行单双数替换匹配 
2.4 分组匹配
Pattern p = Pattern.compile("(\\d{3,5})([a-z]{2})");
Matcher m = p.matcher("123bb_78987dd_090po");
while(m.find()){
    System.out.println(m.group(1));
}
  • 结果:

    123
    78987
    090

    Process finished with exit code 0
  • 描述:分组加括号只取数字一组,grop括号里面第0组是整体,第一组是左起第一个括号,第二组是左起第二个括号

2.5 贪婪的匹配与不贪婪匹配
Pattern p = Pattern.compile("(.{3,10}?)[0-9]");
Matcher m = p.matcher("aaaa5dddd8");
while (m.find()) {
    System.out.println(m.start() + "-" + m.end());
}
  • 结果:

    0-5
    5-10

    Process finished with exit code 0
  • 描述:.{3,10}后面没问号就是贪婪匹配会配到最长,如果{3,10}?加?号就是懒蛋匹配之匹配最少的,从3个开始找。如果这里用if(m.find)(){m.start()+"-"+m.end()}  那么之匹配第一个

2.6 普通捕获
Pattern p = Pattern.compile(".{3}");
Matcher m = p.matcher("ab4dd5");
while(m.find()){
    System.out.println(m.group());
}
  • 结果:

    ab4
    5-10

    Process finished with exit code 0
  • 描述:每次匹配三个任意字符,用 m.group() 输出。

2.7 非捕获组(?=a)
 Pattern p = Pattern.compile(".{3}(?=a)");           
 Matcher m = p.matcher("ab4add5");
 while (m.find()) {
     System.out.println("后面不能是a的:" + m.group());
 }
  • 结果:     后面不能是a的:ab4
  • 描述:(?=a)这个是非捕获组的意思,最后一个是a而且还不把这个a取出来!!(?=a)这个要是写在前面就不一样了

Pattern p = Pattern.compile("(?!a).{3}");           
Matcher m = p.matcher("abbsab89");
while (m.find()) {
    System.out.println("前面不能是a的:" + m.group());
}
  • 结果:前面不能是a的:bbs、前面不能是a的:b89
  • 描述:(?!a)前面不能是a的,所以找到整个字符串中 bbs、b89
2.8 去除><号匹配
Pattern p = Pattern.compile("(?!>).+(?=<)");
Matcher m = p.matcher(">小傅哥<");
while (m.find()) {
    System.out.println(m.group());
}
  • 结果:小傅哥
  • 描述:一般可以匹配网页中的特殊字符串里面的内容信息。
2.9 向前引用
Pattern p = Pattern.compile("(\\d\\d)\\1");
Matcher m = p.matcher("1212");
System.out.println(m.matches());
  • 结果:true
  • 描述:这里面的1是向前引用,12是第一匹配到的,下一次在匹配出来12和前面相同 所以是true

“ 怎么使用正则表达式”的内容就介绍到这里了,感谢大家的阅读。如果想了解更多行业相关的知识可以关注创新互联网站,小编将为大家输出更多高质量的实用文章!


网站题目:怎么使用正则表达式
URL分享:http://bjjierui.cn/article/ieeico.html

其他资讯