正则表达式

于 2022-11-29 17:36:00 发布
阅读量509 收藏
点赞数
分类专栏： 项目实战 文章标签： 项目实战
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sb_jb/article/details/128081285
版权

正则表达式规则可以匹配
A指定字符A
\u548c指定Unicode字符和
.任意字符a, b, &, 0, ...
\d0-90, 1, 2, ..., 9
\wa-z, A-Z, 0-9, _a, A, 0, _, ...
\s空格、tab键“ ”
\D非数字a, A, &, _, ...
\W非\w&, @, 中, ...
\S非\sa, A, &, _, ...
AB*任意个数字符A, AB, ABB, ABBB
AB+至少1个字符AB, ABB, ABBB
AB?0个或1个字符A, AB
AB{3}指定个数字符ABBB
AB{1, 3}指定范围个数字符AB, ABB, ABBB
AB{2,}至少n个字符ABB, ABBB, ...
AB{0, 3}最多n个字符A, AB, ABB, ABBB

 

// java版本：
public class test {

    // 区号（3-4个数字）-电话号码（6-8个数字）
    public static boolean isValidTel(String s) {
        //return s.matches("\\d{3,4}\\-\\d{6,8}");
        //国内区号以0开头
        return s.matches("0\\d{2,3}\\-\\d{6,8}");
    }

    public static void main(String[] args) {
        System.out.println(isValidTel("010-123456"));
        System.out.println(isValidTel("0123-12345678"));
        System.out.println(isValidTel("123-0123456"));

        System.out.println("------");
        System.out.println(isValidTel("010#12345678"));
        System.out.println(isValidTel("010X12345678"));
        System.out.println(isValidTel("01-12345678"));
        System.out.println(isValidTel("01234-12345678"));
        System.out.println(isValidTel("01A-12345678"));
        System.out.println(isValidTel("012-1234567A"));
    }
}

true
true
false
------
false
false
false
false
false
false

# python版本：
import re
 
def isValidTel(str):
	# 国内区号以0开头
	# 匹配成功 re.match 方法返回一个匹配的对象，否则返回 None
	return re.match(r'^0\d{2,3}\-\d{6,8}$', str)
 
print(isValidTel("010-123456"));
print(isValidTel("0123-12345678"));
print(isValidTel("123-0123456"));

print("------");
print(isValidTel("010#12345678"));
print(isValidTel("010X12345678"));
print(isValidTel("01-12345678"));
print(isValidTel("01234-12345678"));
print(isValidTel("01A-12345678"));
print(isValidTel("012-1234567A"));

# re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；
# 而re.search匹配整个字符串，直到找到一个匹配
print("------");
print(re.match(r'0\d{2,3}\-\d{6,8}', "1012-1234567A")); # None
print(re.search(r'0\d{2,3}\-\d{6,8}', "1012-1234567A")); # <re.Match object; span=(1, 12), match='012-1234567'>

print("------");
pattern2 = re.compile(r'^0\d{2,3}\-\d{6,8}$')
match2 = pattern2.match("0123-12345678")
if match2:
    print(match2.group()) # "0123-12345678"
    print(match2.start()) # "0"
    print(match2.end()) # "13"


<re.Match object; span=(0, 10), match='010-123456'>
<re.Match object; span=(0, 13), match='0123-12345678'>
None
------
None
None
None
None
None
None
------
None
<re.Match object; span=(1, 12), match='012-12345678'>
------
0123-12345678
0
13

正则表达式规则可以匹配
^开头字符串开头
$结尾字符串结束
[ABC][...]内任意字符A, B, C
[A-F0-9xy]指定范围的字符A, ..., F, 0, ..., 9, x, y
[^A-F]指定范围外的任意字符非A, ..., F
AB|CDAB或CDAB, CD
AB|CD|EFGAB或CD或EFGAB, CD, EFG
// java版本：
public class test {

    // 区号（3-4个数字）-电话号码（6-8个数字）
    public static boolean isValidTel(String s) {
        //return s.matches("\\d{3,4}\\-\\d{6,8}");
        //国内区号以0开头，电话号码不能以0开头
        return s.matches("0\\d{2,3}\\-[1-9]\\d{5,7}");
    }

    // QQ号码
    public static boolean isValidQQ(String s) {
        return s.matches("^[1-9]\\d{4,9}$");
    }

    public static void main(String[] args) {
        System.out.println(isValidQQ("10000"));
        System.out.println(isValidQQ("99999"));
        System.out.println(isValidQQ("1234567890"));

        System.out.println("-----");
        System.out.println(isValidQQ("00001"));

        System.out.println("-----");

        System.out.println(isValidTel("010-123455"));
        System.out.println(isValidTel("0123-12345678"));

        System.out.println("-----");
        System.out.println(isValidTel("123-12345678"));
        System.out.println(isValidTel("010-023456"));


    }
}

true
true
true
-----
false
-----
true
true
-----
false
false
# python版本：
import re
 
def isValidTel(str):
	# 国内区号以0开头
	# 匹配成功 re.match 方法返回一个匹配的对象，否则返回 None
	return re.match(r'^0\d{2,3}\-[1-9]\d{5,7}$', str)
 
def isValidQQ(str):
 	# QQ号码
	return re.match(r'^[1-9]\d{4,9}$', str) 	

print(isValidQQ("10000"));
print(isValidQQ("99999"));
print(isValidQQ("1234567890"));

print("-----");
print(isValidQQ("00001"));

print("-----");

print(isValidTel("010-123455"));
print(isValidTel("0123-12345678"));

print("-----");
print(isValidTel("123-12345678"));
print(isValidTel("010-023456"));


<re.Match object; span=(0, 5), match='10000'>
<re.Match object; span=(0, 5), match='99999'>
<re.Match object; span=(0, 10), match='1234567890'>
-----
None
-----
<re.Match object; span=(0, 10), match='010-123455'>
<re.Match object; span=(0, 13), match='0123-12345678'>
-----
None
None
  • 示例：判断用户输入的年份是否是19xx年：
    • 规则：1 9 0-9 0-9
    • 正则：19\d\d
    • java字符串："19\\d\\d"
    • java代码： 
      # java版本：
public class test {

    public static boolean is19xx(String s) {
        if (s == null){
            return false;
        }
        return s.matches("19\\d\\d");
    }

    public static void main(String[] args) {
        System.out.println(is19xx("1900"));
        System.out.println(is19xx("1911"));
        System.out.println(is19xx("1999"));
        System.out.println("------");
        System.out.println(is19xx(null));
        System.out.println(is19xx(""));
        System.out.println(is19xx("19"));
        System.out.println(is19xx("190A"));
        System.out.println(is19xx("19001"));
        System.out.println(is19xx("1900s"));
        System.out.println(is19xx("2900"));
        System.out.println(is19xx("A900"));
    }
}
    • 运行结束： 
      true
true
true
------
false
false
false
false
false
false
false
false

      # python版本：
import re
 
def is19xx(str):
	# 国内区号以0开头
	# 匹配成功 re.match 方法返回一个匹配的对象，否则返回 None
	return re.match(r'19\d\d', str)
 
print(is19xx("1900"));
print(is19xx("1911"));
print(is19xx("1999"));
print("------");
print(is19xx(""));
print(is19xx("19"));
print(is19xx("190A"));
print(is19xx("19001"));
print(is19xx("1900s"));
print(is19xx("2900"));
print(is19xx("A900"));

print("------");
pattern2 = re.compile(r'^0\d{2,3}\-\d{6,8}$')
match2 = pattern2.match("0123-12345678")
if match2:
    print(match2.group()) # "0123-12345678"
    print(match2.start()) # "0"
    print(match2.end()) # "13"


<re.Match object; span=(0, 4), match='1900'>
<re.Match object; span=(0, 4), match='1911'>
<re.Match object; span=(0, 4), match='1999'>
------
None
None
None
<re.Match object; span=(0, 4), match='1900'>
<re.Match object; span=(0, 4), match='1900'>
None
None
------
0123-12345678
0
13

import java.util.regex.Matcher;
import java.util.regex.Pattern;

// java版本：
public class test {
    public static void main(String[] args) {

        String regex = "^\\d{3,4}\\-\\d{6,8}$";
        System.out.println("010-12345678".matches(regex));

        System.out.println("------");
        // 反复使用一个正则表达式字符串进行快速匹配效率较低
        // （因为字符串首先得编译成Pattern对象）
        // 反复使用，可以移动到方法外
        Pattern pattern = Pattern.compile("^\\d{3,4}\\-\\d{6,8}$");
        Matcher matcher = pattern.matcher("010-12345678");
        System.out.println(matcher.matches());
        System.out.println(pattern.matcher("021-123456").matches());
        System.out.println(pattern.matcher("021#123456").matches());

        System.out.println("------");
        //使用Matcher.group(n)可以快速提取子串
        Pattern pattern1 = Pattern.compile("^(\\d{3,4})\\-(\\d{6,8})$");
        Matcher matcher1 = pattern1.matcher("010-12345678");
        if (matcher1.matches()){
            System.out.println(matcher1.group(0)); // "010-12345678",0表示匹配的整个字符串
            System.out.println(matcher1.group(1)); // "010", 1表示匹配的第1个子串
            System.out.println(matcher1.group(2)); // "12345678", 2表示匹配的第2个子串
        }
    }
}

true
------
true
true
false
------
010-12345678
010
12345678
# python版本：
import re
 
# re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match() 就返回 none
regex = "^\d{3,4}\-\d{6,8}$"
print(re.match(regex, "010-12345678"))
 
print("----")
print(re.match(regex, "021-123456"))
print(re.match(regex, "021#123456"))

print("----")
# re.compile感觉是完全匹配整个字符串
pattern = re.compile(r'^\d{3,4}\-\d{6,8}$')
print(pattern.match('021-123456A'))
print(pattern.match("021-123456"))

print("----")
matchObj = re.match(r'^(\d{3,4})\-(\d{6,8})$',"010-12345678")
if matchObj:
   print("matchObj.group() : ", matchObj.group())
   print("matchObj.group(1) : ", matchObj.group(1))
   print("matchObj.group(2) : ", matchObj.group(2))
else:
   print("No match!!")


<re.Match object; span=(0, 12), match='010-12345678'>
----
<re.Match object; span=(0, 10), match='021-123456'>
None
----
None
<re.Match object; span=(0, 10), match='021-123456'>
----
matchObj.group() :  010-12345678
matchObj.group(1) :  010
matchObj.group(2) :  12345678

import java.util.regex.Matcher;
import java.util.regex.Pattern;

// java版本：
public class test {
    public static void main(String[] args) {

//        "^(\d+)(0*)$"
//        正则表达式默认是使用贪婪匹配：尽可能多的向后匹配
        Pattern pattern1 = Pattern.compile("^(\\d+)(0*)$");
        Matcher matcher1 = pattern1.matcher("12300");
        if (matcher1.matches()){
            System.out.println(matcher1.group(1)); // "12300"
            System.out.println(matcher1.group(2)); // ""
        }

        // "^(\d+？)(0*)$"——实现非贪婪匹配
        Pattern pattern2 = Pattern.compile("^(\\d+?)(0*)$");
        Matcher matcher2 = pattern2.matcher("12300");
        if (matcher2.matches()){
            System.out.println(matcher2.group(1)); // "123"
            System.out.println(matcher2.group(2)); // "00"
        }

        // 区分?是0个或者1个还是非贪婪匹配
        // "^(\\d??)(0*)$"：第一个?是0个或者1个，第2个?是非贪婪匹配
        Pattern pattern3 = Pattern.compile("^(\\d??)(0*)$");
        Matcher matcher3 = pattern3.matcher("12300");
        if (matcher3.matches()){
            System.out.println(matcher3.group(1)); // ""
            System.out.println(matcher3.group(2)); // "12300"
        }
    }
}

 

# python版本：
import re

pattern1 = re.compile(r'^(\d+)(0*)$')
match1 = pattern1.match("12300")
if match1:
    print(match1.group(1)) # "12300"
    print(match1.group(2)) # ""

# "^(\d+？)(0*)$"——实现非贪婪匹配
pattern2 = re.compile(r'^(\d+?)(0*)$')
match2 = pattern2.match("12300")
if match2:
    print(match2.group(1)) # "123"
    print(match2.group(2)) # "00"


12300

123
00
import java.util.Arrays;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

// java版本：
public class test {

    public static void main(String[] args) {

        // 使用正则表达式分割字符串：
        // String[] String.split(String regex)
        System.out.println(Arrays.toString("a b c".split("\\s"))); // ["a", "b", "c"]
        System.out.println(Arrays.toString("a b  c".split("\\s"))); // ["a", "b", "", "c"]
        System.out.println(Arrays.toString("a b  c".split("\\s+"))); // ["a", "b", "c"]
        System.out.println(Arrays.toString("a, b ;;  c".split("[\\,\\;\\s]+"))); // ["a", "b", "c"]

        System.out.println("----");
        // 使用正则表达式搜索字符串：
        // Matcher.find()
        // Pattern.CASE_INSENSITIVE：忽略大小写
        String s = "The quick brown fox jumps over the lazy dug.";
//        Pattern p = Pattern.compile("the", Pattern.CASE_INSENSITIVE);
//        Pattern p = Pattern.compile("\\w+", Pattern.CASE_INSENSITIVE); // 提取出每个单词
        Pattern p = Pattern.compile("\\w*o\\w*", Pattern.CASE_INSENSITIVE); // 提取出单词中带有o的单词
        Matcher m = p.matcher(s);
        while (m.find()){
            String sub = s.substring(m.start(), m. end());
            System.out.println(sub+", start="+m.start()+", end="+m.end());
        }

        System.out.println("-----");
        // 使用正则表达式替换字符串：
        // String.replaceAl()
        String s1 = "The    quick brown   fox jumps   over the lazy dug.";
        System.out.println(s1.replaceAll("\\s+"," "));
        // 这里$1会捕获前面的分组"(\\w+)"
        // <b>The<b> <b>quick<b> <b>brown<b> <b>fox<b> <b>jumps<b> <b>over<b> <b>the<b> <b>lazy<b> <b>dug<b>.
        System.out.println(s1.replaceAll("\\s+"," ").replaceAll("(\\w+)", "<b>$1<b>"));
    }
}


[a, b, c]
[a, b, , c]
[a, b, c]
[a, b, c]
----
brown, start=10, end=15
fox, start=16, end=19
over, start=26, end=30
-----
The quick brown fox jumps over the lazy dug.
<b>The<b> <b>quick<b> <b>brown<b> <b>fox<b> <b>jumps<b> <b>over<b> <b>the<b> <b>lazy<b> <b>dug<b>.

# python版本：
import re

# 使用正则表达式分割字符串：
print(re.split(r'\s',("a b c"))) # ["a", "b", "c"]
print(re.split(r'\s',("a b  c"))) # ["a", "b", "", "c"]
print(re.split(r'\s+',("a b  c"))) # ["a", "b", "c"]
print(re.split(r'[\,\;\s]+',("a, b   c"))) # ["a", "b", "c"]

print("----")
# 使用正则表达式搜索字符串：
s = "The quick brown fox jumps over the lazy dug."
p = re.compile(r'\w*o\w*', re.I) # 提取出单词中带有o的单词
m = p.findall(s) #['brown', 'fox', 'over']
print(m)

it = re.finditer(r'\w*o\w*',s, re.I) 
for match in it: 
    print(match.group())

print("-----")
# 使用正则表达式替换字符串：
s1 = "The    quick brown   fox jumps   over the lazy dug."
s2 = re.sub(r'\s+',' ',s1)
print(s2)
# 这里$1会捕获前面的分组"(\\w+)"
# <b>The<b> <b>quick<b> <b>brown<b> <b>fox<b> <b>jumps<b> <b>over<b> <b>the<b> <b>lazy<b> <b>dug<b>.
print(re.sub(r'(\w+)','<b>\g<1><b>',s2))


['a', 'b', 'c']
['a', 'b', '', 'c']
['a', 'b', 'c']
['a', 'b', 'c']
----
['brown', 'fox', 'over']
brown
fox
over
-----
The quick brown fox jumps over the lazy dug.
<b>The<b> <b>quick<b> <b>brown<b> <b>fox<b> <b>jumps<b> <b>over<b> <b>the<b> <b>lazy<b> <b>dug<b>.

 

星空下的那个人影
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
一看就懂：正则表达式
小白一个
03-25 8万+
案例引入 在讲正则表达式前，我们不妨先从一个场景来逐渐引入。 你可能有过这样的经历：我们去某些网站注册帐号，当你在设置密码的时候，网站会提示你密码的长度范围，以及对应的规则限制（如下图）。 根据上图，我们将密码设置规则可以描述为两个条件： （1）长度为6-16位； （2）密码中必须包含数字，大写字母，小写字母，特殊字符（指定字符）； 现在假设我们不知道正则表达式，作为程序员的你，该如何去实现这样一个密码验证呢？ 下面是我写的一个校验方法（样本）： /** * 校验用户密码是否满足..
关于邮箱的正则表达式
热门推荐
weixin_42698221的博客
09-01 4万+
关于邮箱规范的正则表达式
IP 正则表达式验证
12-12
您可能感兴趣的文章:javascript 手机号码正则表达式验证函数JS正则表达式验证数字代码JavaScript正则表达式验证身份证号码是否合法(两种方法)jquery正则表达式验证（手机号、身份证号、中文名称）邮箱地址正则...
正则表达式必知必会v_1.0.pdf
01-02
"正则表达式必知必会" 正则表达式是一种强大的文本处理工具，广泛应用于各个领域。下面是对正则表达式的详细解释： 正则表达式的用途 正则表达式主要用于处理文本，提供了两大主要功能：查找和替换。查找功能允许...
JavaScript正则表达式
01-08
1、正则表达式是描述字符模式的对象，正则表达式用于对字符串模式匹配及检索替换，是对字符串执行模式匹配的强大工具。 2、String和RegExp都定义了使用正则表达式进行强大的模式匹配和文本检索与替换的函数。 3、...
正则表达式汇总-Labview
03-25
正则表达式汇总
运用正则表达式匹配所有表名
12-13
正则表达式，又称正规表示法、常规表示法（英语：Regular Expression，在代码中常简写为regex、regexp或RE），计算机科学的一个概念。正则表达式使用单个字符串来描述、匹配一系列符合某个句法规则的字符串。在很多...
SQL 正则表达式及mybatis中使用正则表达式
12-13
mysql 提供的模式匹配的其他类型是使用扩展正则表达式。 当你对这类模式进行匹配测试时，使用REGEXP和NOT REGEXP操作符(或RLIKE和NOT RLIKE，它们是同义词)。 扩展正则表达式的一些字符是： “.”匹配任何单个的...
匹配中文汉字的正则表达式介绍
12-13
匹配中文字符的正则表达式： [\u4e00-\u9fa5] 或许你也需要匹配双字节字符，中文也是双字节的字符 代码如下: 匹配双字节字符(包括汉字在内)：[^\x00-\xff] 注：可以用来计算字符串的长度（一个双字节字符长度计2，...
正则表达式自动生成（小白可用）
05-05
RegEx Builder可以帮助您比较两个表达式的结果 可以在软件上定义表达式的组数据 可以查看字符的编辑逻辑 如果在测试的时候获得不准确的字符 您可以重复测试多次，直到得到正确的结果 可以在软件上建立正式...
正则表达式入门
12-18
正则表达式入门。正则表达式通常被用来检索、替换那些符合某个模式(规则)的文本。
MySQL正则表达式
03-06
MySQL正则表达式使用方式详细解释 案例分析 资料总结规则 正则表达式 详细内容简介 学习内容 MySQL进阶必学内容
wps表格excel正则工具，excel正则表达式替换/匹配/查找/搜索/提取数字
01-19
让 Office Excel、WPS 表格支持正则表达式的免费插件：「Excel 正则工具」顾名思义，需要使用 “正则表达式（PCRE）” 的知识来进行操作，对于完全没有接触过正则的朋友也许有一定的入门门槛，但正则实在是太过强大...
全球手机号码正则表达式
最新发布
06-22
【全球手机号码正则表达式】 1.格式：JSON 2.例示：{"86":{"regex":"^(86){0,1}1\d{10}$","sn":"CN"}} 3.通过短号例如：86，从json的key中获取正则表达式（regex），国家代码（sn）
javascript正则表达式基础篇
10-27
主要是介绍javascript正则表达式的一些基础知识，主要是介绍javascript的正则书写方法与常用实例，需要的朋友可以参考下
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值