简单粗暴的正则表达式笔记

@[TOC]

一、正则

==正则表达式是用来描述具有一定特征的字符串的特殊字符串。 Regular Expression。==
正则表达式本身也是一个字符串，类似于“元数据”的概念，相当于查找结构信息。 正则表达式，又称规则表达式。

符号	描述
.	匹配除换行符 \n 之外的任何单字符。要匹配 . ，请使用 \.
*	匹配前面的子表达式零次或多次。要匹配 字符，请使用 \
+	至少一个
\d	表示数字[0-9]
\D	匹配一个非数字字符。等价于 1
\w	表示任意字母、数字、_
\W	2，表示非字母、数字、_
（）	标记一个子表达式的开始和结束位置。子表达式可以获取供以后使用。要匹配这些字符，请使用 \( 和 \)
\s	表示任意空白（空格、空、tab、换行符...）
\S	3，表示非空白（空格、空、tab、换行符...）
^	匹配输入字符串的开始位置，除非在方括号[]表达式中使用，当该符号在方括号表达式中使用时，表示不接受该方括号表达式中的字符集合。要匹配 ^ 字符本身，请使用 \^
$	匹配输入字符串的结尾位置
?	匹配前面的子表达式零次或一次，或指明一个非贪婪限定符。要匹配 ? 字符，请使用 \?
\	将下一个字符标记为或特殊字符、或原义字符、或向后引用、或八进制转义符。例如， 'n' 匹配字符 'n'。'\n' 匹配换行符。序列 '\\' 匹配 "\"，而 '\(' 则匹配 "("
\		指明两项之间的一个选择。要匹配 \	，请使用 \\
{n}	n 是一个非负整数。匹配确定的 n 次
{n,}	n是一个非负整数。至少匹配n 次
{n,m}	m 和 n 均为非负整数，其中 n <= m。最少匹配 n 次且最多匹配 m 次
[]	匹配中括号集合中的任意一个字符
\b	匹配一个单词边界。例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。
\B	匹配非单词边界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。
(?=pattern)	先行断言，断言自身出现的位置的后面能匹配表达式exp。例如：如果我们想要匹配一个单词，这个单词中有一个字母a，a后面不是字母b，就像apple，hallo，但不能是absolute，那么写法为：\b[a-z]*a(?!b)[a-z]*\b
(?!pattern)	先行断言，断言自身出现的位置的后面不能匹配表达式exp。
(?<=pattern)	后行断言，断言自身出现的位置的前面能匹配表达式exp。
(?<!pattern)	后行断言，断言自身出现的位置的前面不能匹配表达式exp。

1.入门

1)、 匹配 match
==所谓的匹配，匹配子串即可。==
2)、作用
==验证、查找、替换、分割==

2、字符集

默认情况下区分大小写。

 1)、 普通字符

非特殊含义以外的字符，如 a b 中国 尚学堂

 2)、 元字符与转义

==14 个元字符: []() { } \ ^ $ . * + ? |→ 特殊含义==
转义字符: +字母 \d [0-9] \ \ \s空白符 \w –>字母数字_ (没有中文)
3)、 字符类
a)、自定义
由[]组，只匹配一个， 需要注意以下四个:
^: 如果在第一个位置，表示取反的含义。
-表示一个区间即范围
] 最后一个位置为:结束
\ 转义
.==在字符类中 不是代表任意的字符，代码 自身 .的含义。
如果需要表示原有的含义，挪到位置 或者\ 。==
b)、默认|标准字符类

3. 量词

匹配的过程中，需要指定次数。

• 0 个及以上

• 1 个及以上
  ? –>0 或 1 个
  {n}n 次 ,非负数
  {n,}大于等于 n 次
  {n,m} –>大于等于 n 小于等于 m 次

  4. 贪婪模式

  在匹配次数不定时如* {n,} +，匹配字符越多越好，默认模式即”贪婪模
  贪婪模式 greedy(匹配字符越多越好，可回溯) “回溯”指,可以从最后往前面找
  ?懒惰模式 lazy reluctant (匹配字符越少越好，可回溯)
  +独占模式 possessive(匹配字符越多越好,不可回溯) 用的较少

.*o –>贪婪模式
.{2,}o–>贪婪模式
.{2,}?o –>懒惰模式
.{2,}+o –>独占模式，不可回溯 没有匹配到内容。

5.边界

1)、 边界不占用宽度，只是一个界限。
2)、 ^ ：开始 \b：单词边界 \B：非单词边界 $：结束
^：多行代表每行头 单行代表整个字符串的开始
$: 多行代表每行尾 单行代表字符串的结尾
\b 匹配前面或后面的不是\w
\B 匹配前面或后面的是\w

6. 选择符与分组

1)、选择符
| → 优先级低 ,满足匹配则停止，不会查找更优的方案
hellohe
he|hello –>只匹配 he,不匹配 hello
hello|ehe 匹配 he 与 hello
2)、分组
() 组，提高优先级，内部存在缓存，==可以使用缓存即反向引用。==
必须认识组编号，为( 的位置
(")test\1 –> “第 1 个左括号中
((")test)\2 –> “第 2 个左括号中
非捕获组:(?:xxx) ： 不缓存组
3)、 模式修改符
==(?ism )*(?-ism)
i： insensitive 使正则表达式对大小写不敏感； (重点)==
s： singleline 开启“单行模式”，即点号“ .”匹配新行符；
m： multiline 开启“多行模式”，即“ ^”和“ $”匹配新行符的前面和后面的位置。

Select
select
select
SELECT * from

(?i)select(?-i) 不区分大小写。

7. 零宽断言(难点)

前瞻（ Lookahead） 后顾（ Lookbehind）

问题：什么是断言？

答案：断言用于查找某些内容或内容所在的位置，该内容或内容所在位置应满足一定的条件。

二、简单正则案例练习

案例1：匹配11位手机号，要求：第一位数字为1，第二位数字是34578中的一个，接下来后9位都是0到9的数字

@Test
public void regular3() {
    String regular = "^1[34578]\\d{9}$";
    String str1 = "15221621619";
    String str2 = "11221621619";
    System.out.println("手机号str1校验:" + Pattern.compile(regular).matcher(str1).find());  //手机号str1校验:true
    System.out.println("手机号str2校验:" + Pattern.compile(regular).matcher(str2).find());  //手机号str2校验:false
}

案例2：匹配QQ号，要求：第一个数不可能是0，目前qq最多是10位数字，最少5位

@Test
public void regular4() {
    String regular = "^[1-9][0-9]{4,9}";
    String str3 = "924382";
    String str4 = "0101";
    System.out.println("QQ号str3校验:" + Pattern.compile(regular).matcher(str3).find());  //QQ号str3校验:true
    System.out.println("QQ号str4校验:" + Pattern.compile(regular).matcher(str4).find());  //QQ号str4校验:false
}

案例3：采用“零宽断言”需求：在字符串 ‘北京市(朝阳区)(西城区)(海淀区)’ 中，取出没有被()包裹的字符 北京市

需求：在字符串 ‘北京市(朝阳区)(西城区)(海淀区)’ 中，取出没有被()包裹的字符 北京市

  你可能有疑问，如果我正则写成这个样子.*(?=\()，为什么结果就不对？这个正则结果是：北京市(朝阳区)(西城区)
 
  答案：
      . 代表匹配除了换行和行结束符的任意字符
     * 代表匹配任意次数，保证我们得到的是北京市而不是市这个单字
       ? 代表对多个连续的值，要么匹配0次，要么匹配1次，最多匹配一次
 
     上面说了，?在这个表达式里，表示要么不匹配，要么最多匹配一次，这就是非贪婪模式
     而不添加?，表达式以贪婪模式运行。什么是贪婪模式？就是尽可能多的去匹配，匹配到了还去匹配，贪得无厌，一直匹配到字符串的末尾
     因为字符串中有三个(，贪婪模式下会一直匹配到字符串结尾，就会得到“北京市(朝阳区)(西城区)”这个结果。

@Test
public void regular5() {
    String regular = ".*?(?=\\()";
    String str5 = "北京市(朝阳区)(西城区)(海淀区)";
    Matcher matcher = Pattern.compile(regular).matcher(str5);
    if (matcher.find()) System.out.println("采用‘零宽断言‘，对str5提取想要内容:" + matcher.group());  //采用‘零宽断言‘，对str5提取想要内容:北京市
    }

三.常用类

1.正则

java.util.regex Pattern Matcher String
查找、替换、分割、组的使用
1)、 Pattern

2)Matcher(匹配器)

3)、字符串与正则

三.附件

Eclipse和JS的2种使用正则方法:

Eclipse使用正则:
//第一种使用方法matches(正则)    公式:str.matches(reg) 
        String reg="\\d";
        String str="lksdafks2dkjf2lkds4sjdflksd6lkdj";
        System.out.println(str.matches(reg));
        //replace 识别正则表达式的时候默认替换第一个满足正则的内容,如果想要替换多个,使用replaceAll
        System.out.println(str.replaceAll("\\d", "S")); 把所有数字替换成S
        //切割字符串
        System.out.println(Arrays.toString(str.split("\\d")));
        
//第二种使用方法Pattern 表示正则语法的类
        Pattern regex=Pattern.compile(reg);
        //获取匹配器对象  公式: regex.matcher(str)
        Matcher macher=regex.matcher(str);
        //查找是否有满足条件的内容,继续向下查找
        System.out.println(macher.find());
        System.out.println(macher.find());






js中使用正则:
<!--
        js中使用正则:
            match  匹配
                可以是第一个满足的内容--数组
                可以是所有满足的内容--数组  --g 代表全局变量
                如果没有满足条件的返回null
            test 判断是否满足 true,false
--> 

<script>
        var str="ab1cadac";
        var str2='A3441';
        //全局匹配,获取多个能满足正则语法的数组形式的内容

        //隐式定义正则形式  使用/xxxx/
        var reg1=/^[A-Z]\d{5}$/;
        //显示定义正则    使用new RegExp(‘’)
        var reg2=new RegExp('\\d');
        
        var arr=str2.match(reg1);//第一种方法使用match,  公式: str2.match(reg1)
        console.log(arr);

        console.log(reg1.test(str2)); //第二种方法使用test,  公式: reg1.test(str2)
    </script>

重要信息

• 官网：https://ais.cn/u/vEbMBz

---

1. 0-9 ↩
2. \w ↩
3. \s ↩