正则表达式

正则表达式

简单应用

const 变量名 = /表达式/

const reg = /java/;
const reg = reg.test('学习java');// reg = true

修饰符

i (ignore): 忽略大小写

g(globe): 全局匹配

i:
const reg = /a/;
reg.test('a');// true
reg.test('abc');//true
reg.test('ABC');//false

const reg = /a/i
reg.test('ABC')//true


g:
const reg = /java/;
const str = '学java,java有意思';
str.replace(reg,前端）；//  学前端，java有意思
            
const reg = /java/g
const str = '学java,java有意思';
str.replace(reg,前端）；//  学前端，前端有意思
            
            
i+g:
const reg = /java/ig
const str = '学java,Java有意思';
str.replace(reg,前端）；//  学前端，前端有意思            
            

元字符

边界符

​ 单词边界：\b

const reg = /\bcat\b/g;
const str ='The cat scannered his food all over the room.'
str.replace(reg,'dog'); //The dog sdogtered his food all over the room.

字符串边界：^ $

const reg = /^a/;
reg.test('a');//true
reg.test('abc');//true
reg.test('bcd');//false
reg.test('Abc');//false


const reg = /a$/;
reg.test('a');//true
reg.test('ab');//false

const reg = /^a$/; //精确匹配，^与$之间是什么，就只能匹配什么；故'aaa'、'aa' 都为false
reg.test('a');//true
reg.test('aaa');//false

量词

*：重复零次或更多。

+：重复一次或多次。

?：重复零次或一次。

{n}:重复n次。

{n,}:重复n次或多次。

{n,m}:重复n到m次。

*:
const reg = /^a*$/;//重复零次或更多。
reg.test('a');//true
reg.test('');//true
reg.test('aaa');//true
reg.test('b');//false

+:
const reg = /^a+$/;//重复一次或多次。
reg.test('a');//true
reg.test('');//false
reg.test('aaa');//true
reg.test('b');//false

?:
const reg = /^a?$/;//重复零次或一次。
reg.test('a');//true
reg.test('');//true
reg.test('aaa');//false
reg.test('b');//false


{n}:
const reg = /^a{3}$/;//只能有3次。
reg.test('a');//false
reg.test('');//false
reg.test('aaa');//true
reg.test('b');//false


{n,}:
const reg = /^a{2}$/;//大于等于2次。
reg.test('a');//false
reg.test('');//false
reg.test('aaa');//true
reg.test('aa');//true
 
 
 {n,m}:
const reg = /^a{3，5}$/;//大于等于3次且小于等于5次
reg.test('a');//false
reg.test('');//false
reg.test('aaa');//true
reg.test('aaaaa');//true
reg.test('aaaaaa');//false

字符类

匹配字符集合:[ ]

​ 在[ ]中允许使用连字符 ‘-’;

const reg = /[abc]/; // 匹配abc中的任意一个
reg.test('abc');//true
reg.test('andy');//true
reg.test('body');//true
reg.test('ddy');//false

const reg = /[a-z]/;a到z的26个字母中的任意一个
const reg = /[A-Z]/;A到Z的26个之母中的任意一个
const reg = /[0-9]/;

const reg = /[a-zA-Z0-9_]/  //仅可使用字母、数字、下划线。

^ [ ] :取反

const reg = /[^a]/;
reg.test('a');//false
reg.test('bc');//true
reg.test('abc');//true

. : 匹配除换行符之外的任意单个字符

const reg = /./;
reg.test('aaa');//true
reg.test('123');//true
reg.test('');//false
reg.test('/n');//false
reg.test('/r');//false

预定义

\d:匹配0-9之间的任意数字，相当于[0-9]

\D:匹配0-9以外的任意字符，相当于【^ 0-9 ]

\w:匹配任意的字母，数字和下划线，相当于/[a-zA-Z0-9_]/

\W:匹配除字母，数字和下划线以外的字符，相当于/【^a-zA-Z0-9_]/

\s:匹配空格（包含换行、空格、制表符等），相当于[\t\r\n\v\f]

\S:匹配非空格的字符，相当于【^\t\r\n\v\f]

分组和分支结构

/ab+/ 只能匹配到 ab , abb , abbb 等类似的值，如果想要匹配到 ab , abab , ababab 时，仅使用/ab+/依然无法满足，所以 可以使用（） 把 ab括起来 分为一组，即：

const reg = /(ab)+/;
reg.test('ab');//true
reg.test('abab');//true

规则：从1开始，连续不间断

​ 以左括号为基准，最左边的是第一组，其次为第二组，以此类推

分组捕获：

const reg = /^(\d{4})-(\d{2})-(\d{2})$/;
const date='2023-04-30';
reg.test(date);//true
date.replace(reg,'$2/$3/$1');//  04/30/2023

正则内部使用：\\组号

正则外部使用：$组号

分支结构：

const reg = /前端|java/;
const str1= '学前端'；
const str2= '学java';
const str3= '学挖机'；
reg.test(str1);//true
reg.test(str2);//true
reg.test(str3);//false

Java应用

Pattern pattern = Pattern.compile(String reg);
Matcher matcher = pattern.matcher(str);
Boolean boolean =matcher.find();//有返回true,否则false
String s = matcher.group();//将符合正则表达式的内容进行截取并给s

网站爬取：

URL url = new URL("https://www.baidu.com");//创建一个URL对象
URLConnection connection =url.openConnection();//连接上这个网站，前提：保证网络通畅
BufferedReader br = new BufferedReader(new InputStreamReader(connection.getInputStream()));//创建一个对象，去读取网络中的数据
Pattern pattern = Pattern.compile（"正则表达"）；
String line = br.readLine();//每次读取一行
while(line!=null){
	Matcher matcher = patter.matcher(line);
	System.out.print(matcher.group());
}
br.close();//关闭数据流

贪婪爬取：在爬取数据的时候尽可能多的获取数据

非贪婪爬取：再爬取数据时尽可能少获取数据

Java中默认的就是贪婪爬取，如果在数量词+*的后面加上？，此时为非贪婪爬取

正则表达式在字符串方法中的使用

string.matchers(reg);//判断字符串是否满足正则表达式的规则
string.replaceAll（reg,newStr）;//按照正则表达式的规则进行替换
string.split（reg）；//按照正则表达式的规则切割字符串，返回一个字符串数组

案例

密码匹配：6-16为字母，数字或下划线

const reg = / ^[(a-zA-Z0-9_){6,16}]$/

匹配16进制颜色值： #f0f0f0 , #fff

const reg = / [^(#0-9a-fA-f){3,6}$]/

匹配24小时制的时间：23:59 ， 08:29

const reg = /^([01][0-9])|[2][0-3]:[0-5][0-9]$/

手机号码脱敏：13592653366 => 135==****==3366

const reg = /^(1[3-9]{2})[0-9]{4}([0-9]{4})$/;
const mobile = '13592653366';
mobile.replace(reg,'$1****$2');