正则表达式[总结]

已于 2023-10-21 15:30:29 修改
阅读量501 收藏 1
点赞数 1
分类专栏： 后端开发基础知识点 文章标签： 正则表达式
于 2023-10-21 15:28:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53125903/article/details/133962006
版权

文章目录

1. 为什么要学习正则表达式

  • 极速体验正则表达式威力

image-20231020145253436

//1. 先创建一个 Pattern 对象 ， 模式对象, 可以理解成就是一个正则表达式对象
//Pattern pattern = Pattern.compile("[a-zA-Z]+");
//Pattern pattern = Pattern.compile("[0-9]+");
//Pattern pattern = Pattern.compile("([0-9]+)|([a-zA-Z]+)");
//Pattern pattern = Pattern.compile("<a target=\"_blank\" title=\"(\\S*)\"");

2. 再提出几个问题？

image-20231020145351946

image-20231020145413068

3. 解决之道-正则表达式

image-20231020145448994

4. 正则表达式基本介绍

image-20231020145521752

5. 正则表达式底层实现(重要)

为让大家对正则表达式底层实现有一个直观的映象，给大家举个实例

给你一段字符串(文本),请找出所有四个数字连在一起的子串， 比如:

应该找到 1998 1999 3443 9889 ===> 分析底层实现 RegTheory.java

package com.xjz.regexp;

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

/**
 * @author xjz_2002
 * @version 1.0
 * 分析 java 的正则表达式的底层实现(重要)
 */
public class RegTheory {
    public static void main(String[] args) {

        String content = "1998 年 12 月 8 日，第二代 Java 平台的企业版 J2EE 发布。1999 年 6 月，Sun 公司发布了" +
                "第二代 Java 平台（简称为 Java2）的 3 个版本：J2ME（Java2 Micro Edition，Java2 平台的微型" +
                "版），应用于移动、无线及有限资源的环境；J2SE（Java 2 Standard Edition，Java 2 平台的" +
                "标准版），应用于桌面环境；J2EE（Java 2Enterprise Edition，Java 2 平台的企业版），应" +
                "用 3443 于基于 Java 的应用服务器。Java 2 平台的发布，是 Java 发展过程中最重要的一个" +
                "里程碑，标志着 Java 的应用开始普及 9889 ";
        //目标：匹配所有的四个数字
        //说明
        //1. \\d 表示一个任意的数字
        String regStr = "(\\d\\d)(\\d\\d)";
        //2. 创建模式对象[即正则表达式对象]
        Pattern pattern = Pattern.compile(regStr);
        //3. 创建匹配器
        //说明：创建匹配器 matcher，按照 正则表达式的规则 去匹配 content 字符串
        Matcher matcher = pattern.matcher(content);

        //4. 开始匹配
        /**
         *
         * matcher.find() 完成的任务 （考虑分组）
         * 什么是分组，比如 (\d\d)(\d\d)，正则表达式中有() 表示分组，第一个()表示第 1组，第2个()表示第 2组..
         * 1. 根据指定的规则，定位满足规则的子字符串(比如(19)(98))
         * 2. 找到后，将 子字符串的开始的索引记录到 matcher 对象的属性 int[] groups;
         *      2.1 groups[0] = 0,把该子字符串的结束的索引+1 的值记录到 groups[1] = 4
         *      2.2 记录 1组()匹配到的字符串 groups[2] = 0  groups[3] = 2
         *      2.3 记录 2组()匹配到的字符串 groups[4] = 2  groups[5] = 4
         *      2.4 如果有更多的分组..
         * 3. 同时记录 oldLast 的值为 子字符串的结束的 索引 +1 的值 即 35，即下次执行 find时，就从 35 开始匹配
         *
         * matcher.group(0) 分析
         * 源码:
         * public String group(int group) {
         *      if (first < 0)
         *          throw new IllegalStateException("No match found");
         *      if (group < 0 || group > groupCount())
         *          throw new IndexOutOfBoundsException("No group " + group);
         *      if ((groups[group*2] == -1) || (groups[group*2+1] == -1))
         *          return null;
         *      return getSubSequence(groups[group * 2], groups[group * 2 + 1]).toString();
         *  }
         *  1. 根据 groups[0]=31 和 groups[1]=35 的记录的位置，从 content 开始截取子字符串返回
         *      就是 [31,35) 包含 31但是不包含索引为 35 的位置
         *
         *  如果再次指向 find 方法，仍然按上面分析来执行
         */

        while (matcher.find()){
            //小结
            //1. 如果正则表达式有()  即分组
            //2. 取出匹配的字符串规则如下
            //3. group(0) 表示匹配到的子字符串
            //4. group(1) 表示匹配到的子字符串的第一组子串
            //5. group(2) 表示匹配到的子字符串的第二组子串
            //6. ... 但是分组的数不能越界.
            System.out.println("找到" + matcher.group(0));
            System.out.println("第 1 组()匹配到的值=" + matcher.group(1));
            System.out.println("第 2 组()匹配到的值=" + matcher.group(2));

        }

    }
}

image-20231020153953160

6. 正则表达式语法

6.1 基本介绍

image-20231020155314949

6.2 元字符(Metacharacter)-转义号 \\

image-20231020155406581

package com.xjz.regexp;

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

/**
* @author xjz_2002
* @version 1.0
* 演示转义字符的使用
*/
public class RegExp02 {
   public static void main(String[] args) {
       String content = "abc$(a.bc(123()";
       //匹配( --> \\(
       //匹配. --> \\.
       //String regStr = "\\(";
       //String regStr = "\\.";
       //String regStr = "\\d\\d\\d";
       String regStr = "\\d{3}"; // \\d\\d\\d == \\d{3}
       Pattern pattern = Pattern.compile(regStr);
       Matcher matcher = pattern.matcher(content);

       while (matcher.find()){
           System.out.println("找到 " + matcher.group(0));
       }
   }
}

image-20231020160144231

6.3 元字符-字符匹配符

image-20231020160208089

image-20231020160226286

package com.xjz.regexp;

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

/**
 * @author xjz_2002
 * @version 1.0
 * 演示字符匹配符 的使用
 */
public class RegExp03 {
    public static void main(String[] args) {

        String content = "a11c8abc _ABCy @";
        //String regStr = "[a-z]";//匹配 a-z 之间任意一个字符
        //String regStr = "[A-Z]";//匹配 A-Z 之间任意一个字符
        //String regStr = "abc";//匹配 abc 字符串[默认区分大小写]
        //String regStr = "(?i)abc";//匹配 abc 字符串[不区分大小写]
        //String regStr = "[0-9]";//匹配  0-9 之间任意一个字符
        //String regStr = "[^a-z]";//匹配 不在 a-z 之间任意一个字符
        //String regStr = "[^0-9]";//匹配 不在 0-9 之间任意一个字符
        //String regStr = "[abcd]";//匹配 在 abcd中任意一个字符
        //String regStr = "\\D";//匹配 不在 0-9 的任意一个字符
        //String regStr = "\\w";//匹配 大小写英文字法、数字、下划线
        //String regStr = "\\W";//匹配 等价于[^a-zA-Z0-9_]
        // \\s 匹配任何空白字符(空格、制表符等)
        //String regStr = "\\s";
        // \\S 匹配任何非空白字符串，和\\s刚好相反
        //String regStr = "\\S";
        //. 匹配出 \n 之外的所有字符，如果要匹配 .本身则需要使用 \\.
        String regStr = ".";

        //说明
        //1. 当创建 Pattern 对象时，指定 Pattern CASE_INSENSITIVE,表示匹配是不区分字符大小写
        Pattern pattern = Pattern.compile(regStr/*,Pattern.CASE_INSENSITIVE*/);
        Matcher matcher = pattern.matcher(content);

        while (matcher.find()) {
            System.out.println("找到 " + matcher.group(0));
        }

    }
}

6.4 元字符-选择匹配符

image-20231020163359346

package com.xjz.regexp;

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

/**
 * @author xjz_2002
 * @version 1.0
 * 选择匹配符 |
 */
public class RegExp04 {
    public static void main(String[] args) {

        String content = "liyunlong 李 栗子";
        String regStr = "li|李|栗";

        Pattern pattern = Pattern.compile(regStr/*,Pattern.CASE_INSENSITIVE*/);
        Matcher matcher = pattern.matcher(content);

        while (matcher.find()){
            System.out.println("找到 " + matcher.group(0));
        }
    }
}
  • 运行结果

image-20231020163838213

6.5 元字符-限定符

用于指定其前面的字符和组合项连续出现多少次

image-20231020163942831

image-20231020163950460

应用案例

package com.xjz.regexp;

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

/**
 * @author xjz_2002
 * @version 1.0
 * 演示限定符的作用
 */
public class RegExp05 {
    public static void main(String[] args) {

        String content = "a211111aaaaaahello";

        //a{3}, 1{4}, \\d{2}
        //String regStr = "a{3}";// 表示匹配 aaa
        //String regStr = "1{4}";// 表示匹配 1111
        //String regStr = "\\d{2}";// 表示匹配 两位的任意数字字符

        //a{3,4}, 1{4,5}, \\d{2,5}

        //细节：java 匹配默认贪婪匹配，即 尽可能匹配多的
        //String regStr = "a{3,4}";//表示匹配 aaa 或者 aaaa
        //String regStr = "a{4,5}";//表示匹配 1111 或者 11111
        //String regStr = "\\d{2,5}";//表示匹配 2位数或者 3,4,5位的数字0-9

        //1+
        //String regStr = "1+";//匹配一个 1 或者多个 1
        //String regStr = "\\d+";//匹配一个数字或者多个数字

        //1*
        //String regStr = "1*";//匹配 0个1 或者多个1

        //演示 ? 的使用，遵守贪婪匹配
        String regStr = "a1?";//匹配 a 或者 a1
        Pattern pattern = Pattern.compile(regStr/*,Pattern.CASE_INSENSITIVE*/);
        Matcher matcher = pattern.matcher(content);

        while (matcher.find()){
            System.out.println("找到 " + matcher.group(0));
        }
    }
}

6.6 元字符-定位符

定位符, 规定要匹配的字符串出现的位置，比如在字符串的开始还是在结束的位置，这个也是相当有用的，必须掌握

RegExp06.java

package com.xjz.regexp;

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

/**
 * @author xjz_2002
 * @version 1.0
 * 演示定位符的使用
 */
public class RegExp06 {
    public static void main(String[] args) {

        String content = "xujinzhuo xuspxu nnxu";
        //String content = "123-abc";
        //以至少 1个数字开头，后接任意个小写字母的字符串
        //String regStr = "^[0-9]+[a-z]*";
        //以至少 1个数字开头，必须以至少一个小写字符结束
        //String regStr = "^[0-9]+\\-[a-z]+$";

        //表示匹配边界的 xu[这里的边界是指：被匹配的字符串最后，
        // 也可以是空格字符串的前面]
        //String regStr = "xu\\b";

        //和\\b的含义刚刚相反[被匹配的字符串最前面，也可以是空掉的字符串的后面]
        String regStr = "xu\\B";

        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);

        while (matcher.find()){
            System.out.println("找到=" + matcher.group(0));
        }

    }
}

6.7 分组

image-20231020181522799

image-20231020181534504

RegExp07.java

package com.xjz.regexp;

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

/**
 * @author xjz_2002
 * @version 1.0
 * 分组：
 */
public class RegExp07 {
    public static void main(String[] args) {

        String content = "xujinzhuo s7789 nn1189xu";

        //下面就是非命名分组
        //说明
        // 1. matcher.group(0) 得到匹配到的字符串
        // 2. matcher.group(1) 得到匹配到的字符串的第 1 个分组内容
        // 3. matcher.group(2) 得到匹配到的字符串的第 2 个分组内容

        //String regStr = "(\\d\\d)(\\d\\d)";//匹配 4 个数字的字符串

        //命名分组：即可以给分组取名
        String regStr = "(?<g1>\\d\\d)(?<g2>\\d\\d)";//匹配 4 个数字的字符串

        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);

        while (matcher.find()){
            System.out.println("找到=" + matcher.group(0));
            System.out.println("第 1 个分组内容=" +matcher.group(1));
            System.out.println("第 1 个分组内容[通过组名]=" +matcher.group("g1"));
            System.out.println("第 2 个分组内容=" +matcher.group(2));
            System.out.println("第 2 个分组内容[通过组名]=" +matcher.group("g2"));
        }
    }
}

RegExp08.java

package com.xjz.regexp;

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

/**
 * @author xjz_2002
 * @version 1.0
 * 演示非捕获分组，语法比较奇怪
 */
public class RegExp08 {
    public static void main(String[] args) {

        String content = "hello 李云龙团长 jack 李云龙营长 李云龙同志 hello";

        // 找到 李云龙团长、李云龙营长、李云龙同志 子字符串
        //String regStr = "李云龙团长|李云龙营长|李云龙同志";
        //上面的写法可以等价非捕获分组，注意：不能 matcher group(1)
        //String regStr = "李云龙(?:团长|营长|同志)";

        //找到 韩顺平 这个关键字,但是要求只是查找李云龙团长和 李云龙营长 中包含有的李云龙
        //下面也是非捕获分组，不能使用 matcher.group(1)
        String regStr = "李云龙(?=团长|营长)";

        //找到 李云龙 这个关键字,但是要求只是查找 不是 (李云龙团长 和 李云龙营长) 中包含有的李云龙
        //下面也是非捕获分组，不能使用 matcher.group(1)
        //String regStr = "李云龙(?!团长|营长)";

        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);

        while (matcher.find()){
            System.out.println("找到：" + matcher.group(0));
        }
    }
}

6.8 非贪婪匹配

?

package com.xjz.regexp;

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

/**
 * @author xjz_2002
 * @version 1.0
 * 非贪婪匹配 ?
 */
public class RegExp09 {
    public static void main(String[] args) {

        String content = "tom111111jack";

        //String regStr = "\\d+";//默认贪婪匹配
        String regStr = "\\d+?";// 非 贪婪匹配

        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);

        while (matcher.find()) {
            System.out.println("找到=" + matcher.group(0));
        }
    }

}

运行结果

image-20231021115202765

7. 应用实例

image-20231021114046239

package com.xjz.regexp;

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

/**
 * @author xjz_2002
 * @version 1.0
 * 正则表达式的应用实例
 */
public class RegExp10 {
    public static void main(String[] args) {
        String content = "13588889999";
        //  汉字
        //String regStr = "^[\u0391-\uffe5]+$";

        // 邮政编码
        // 要求：是 1-9 开头的一个六位数. 比如：123890
        //String regStr = "^[1-9]\\d{5}$";

        // QQ 号码
        // 要求: 是 1-9 开头的一个(5 位数-10 位数) 比如: 12389 , 1345687 , 187698765
        //String regStr = "^[1-9]\\d{4,9}$";

        // 手机号码
        // 要求: 必须以 13,14,15,18 开头的 11 位数 , 比如 13588889999
        String regStr = "^1[3|4|5|8]\\d{9}$";

        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);
        if (matcher.find()) {
            System.out.println("满足格式");
        } else {
            System.out.println("不满足格式");
        }

    }
}

package com.xjz.regexp;

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

/**
 * @author xjz_2002
 * @version 1.0
 * 演示正则表达式的使用
 */
public class RegExp11 {
    public static void main(String[] args) {

        String content = "https://www.bilibili.com/video/BV1eu4y1W7PL/?spm_id_from=333.1007.tianma.2-1-4.click&vd_source=c5907cbcddead65ce568e72fc5ad5385";

        /**
         * 思路
         * 1. 先确定 url 的开始部分 https://
         * 2. 然后通过 ([\w-]+\.)+[\w-] 匹配  www.bilibili.com
         *
         */

        //多写多练，多总结
        String regStr = "^((http|https)://)?([\\w-]+\\.)+[\\w-]+(\\/[\\w-?=/.&]*)?$";

        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);
        if(matcher.find()) {
            System.out.println("满足格式");
        } else {
            System.out.println("不满足格式");
        }

        //这里如果使用 Pattern 的 matches 整体匹配 比较简洁
        System.out.println(Pattern.matches(regStr, content));//
    }
}

8. 正则表达式三个常用类

image-20231021123342273

package com.xjz.regexp;

import java.util.regex.Pattern;

/**
 * @author xjz_2002
 * @version 1.0
 * 演示  matches 方法，用于 整体匹配，在验证输入的字符串是否满足条件使用
 */
public class PatternMethod {

    public static void main(String[] args) {
        String content = "hello world 雪豹";
//        String regStr = "hello";
        String regStr = "hello.*";

        boolean matches = Pattern.matches(regStr, content);
        System.out.println("整体匹配=" + matches);
    }
}

image-20231021125107145

package com.xjz.regexp;

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

/**
 * @author xjz_2002
 * @version 1.0
 * Matcher 类的常用方法
 */
public class MatcherMethod {
    public static void main(String[] args) {
        String content = "hello edu jack xjz2002 hello smith hello xjz2002 xjz2002";
        String regStr = "hello";

        Pattern pattern = Pattern.compile(regStr);
        Matcher matcher = pattern.matcher(content);

        while (matcher.find()) {
            System.out.println("==========================");
            System.out.println(matcher.start());
            System.out.println(matcher.end());
            System.out.println("找到："+content.substring(matcher.start(), matcher.end()));
        }

        //整体匹配方法，常用于，去校验某个字符串是否满足某个规则
        System.out.println("整体匹配=" + matcher.matches());

        //完成如果 content 有 xjz2002 替换成 老鼠爱大米
        regStr = "xjz2002";
        pattern = Pattern.compile(regStr);
        matcher = pattern.matcher(content);
        //注意： 返回的字符串才是替换后的字符串 原来的 content 不变化
        String newContent = matcher.replaceAll("老鼠爱大米");
        System.out.println("newContent=" + newContent);
        System.out.println("content=" + content);
    }
}

9. 分组、捕获、反向引用

9.1 提出需求

image-20231021125154547

9.2 介绍

image-20231021125225492

9.3 看几个小案例

image-20231021125441152

9.4 经典的结巴程序

package com.xjz.regexp;

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

/**
 * @author xjz_2002
 * @version 1.0
 */
public class RegExp13 {
    public static void main(String[] args) {
        String content = "我...我要....学学学学..编程java！";

        //1. 去掉所有的.
        Pattern pattern = Pattern.compile("\\.");
        Matcher matcher = pattern.matcher(content);

        content = matcher.replaceAll("");

//        System.out.println("content=" + content);

        //2. 去掉重复的字  我我要学学学学编程java！
        // 思路
        //(1) 使用 (.)\\1+
        //(2) 使用 反向引用 $1 来替换匹配到的内容
        // 注意：因为正则表达式变化，所以需要重置 matcher
//        pattern = Pattern.compile("(.)\\1+");
//        matcher = pattern.matcher(content);
//        while (matcher.find()){
//            System.out.println("找到=" + matcher.group(0));
//        }
//
//        //使用 反向引用$1 来替换匹配到的内容
//        content = matcher.replaceAll("$1");
//        System.out.println("content=" + content);


        //3. 使用一条语句 去掉重复的字 我我要学学学学编程java！
        content = Pattern.compile("(.)\\1+").matcher(content).replaceAll("$1");

        System.out.println("content=" + content);
    }

}

10. String 类中使用正则表达式

10.1 替换功能

String 类 public String replaceAll(String regex,String replacement)

10.2 判断功能

String 类 public boolean matches(String regex){} **//**使用 Pattern 和 Matcher 类

10.3 分割功能

String 类 public String[] split(String regex)

StringReg.java 代码如下：

package com.xjz.regexp;

/**
 * @author xjz_2002
 * @version 1.0
 */
public class StringReg {

    public static void main(String[] args) {
        String content = "2000 年 5 月，JDK1.3、JDK1.4 和 J2SE1.3 相继发布，几周后其" +
                "获得了 Apple 公司 Mac OS X 的工业标准的支持。2001 年 9 月 24 日，J2EE1.3 发" +
                "布。" +
                "2002 年 2 月 26 日，J2SE1.4 发布。自此 Java 的计算能力有了大幅提升";

        //使用正则表达式方式，将 JDK1.3 和 JDK1.4 替换成 JDK
        content = content.replaceAll("JDK1.3|JDK1.4","JDK");
        System.out.println(content);

        //要求：验证一个手机号，要求必须是以 138 139 开头的
        content = "13888899999";
        if (content.matches("1(38|39)\\d{8}")) {
            System.out.println("验证成功");
        } else {
            System.out.println("验证失败");
        }

        //要求 按照 # 或者 - 或者 ~ 或者 数字来分割
        System.out.println("======================================");
        content = "hello#abc-jack12smith~北京";
        String[] split = content.split("#|-|~|\\d+");
        for (String s : split) {
            System.out.println(s);
        }
    }
}
xjz_2002
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
javascript正则表达式总结
11-23
Regexpal是一个在线Javascript正则表达式处理器，地址是:http://www.regexpal.com 学习正则重要的是实践操作，不妨举个栗子： 匹配号码：707-827-7019 字符组匹配 [0-9][0-9][0-9]-[0-9][0-9][0-9]-[0-9][0-9][0-9]...
正则表达式总结
11-04
除非您以前使用过正则表达式，否则您可能不熟悉一此术语。但是，毫无疑问，您已经使用过不涉及脚本的某些正则表达式概念。 例如，您很可能使用 ? 和 * 通配符来查找硬盘上的文件。? 通配符匹配文件名中的单个字符，...
常用正则表达式总结
BugAngel的博客
03-18 107
【代码】常用正则表达式总结。
Python正则表达式(一看就懂)
热门推荐
我的博客
03-30 11万+
哈喽O(∩_∩)O 今天来发一下python正则表达式，其实这个也是比较简单的 什么是正则表达式(⊙_⊙) 目前越来越多的网站、编辑器、编程语言都已支持一种叫“正则表达式”的字符串查找“公式”，有过编程经验的同学都应该了解正则表达式（Regular Expression 简写regex）是什么东西，它是一种字符串匹配的模式（pattern），更像是一种逻辑公式。 简单说，正则表达式是 python中必备的工具，主要是用来查找和匹配字符串的。 正则表达式尤其在python爬虫上用的多。 正则表达
常见正则表达式总结
别告诉我有Bug
12-31 936
(最下方常见正则表达式总结) 一. 正则表达式符号总结 1.限定符 ? ：字符需要出现0次或1次（ab?可匹配a、ab); * ：字符可出现0次以上（ab*c可匹配ac、abc、abbc、abbbc......); +：字符至少出现1次以上（ab+c可匹配abc、abbc、abbbc......不会匹配ac); {}：可以限定匹配的数量（a{6}b匹配aaaaaab;a{1,3}b可匹配ab、aab、aaab,a的数量在1-3之间；a{2,}b可匹配ab、aab...
正则表达式总结与应用
ZYN的博客
09-13 760
惰性匹配是从左侧第一个字符向右匹配，先看是否匹配，若不匹配，就加入右侧下一个字符再次尝试匹配。贪婪匹配是先看整体字符串是否匹配，如果不匹配，它会去掉字符串中的最后一个字符再次尝试匹配。跟在子串后，表示匹配前面的子串1次或0次，即前一字符可以存在也可以不存在，但是存在只能有一次；①正则表达式表示尽可能匹配最长的符合规则的内容，最终返回"")>表示尽可能匹配最短的符合规则的内容，最终返回""② . 与换行符外的字符都匹配，针对单字符。
Python正则表达式总结
Kaiyuan_sjtu的博客
10-30 1714
写在前面 一篇正则小笔记。断断续续看过正则的一些知识，总感觉要记的挺多，每次都随手一写，然后由于使用的机会也不多所以啊永远是看了忘忘了看。 正则表达式是一些由字符和特殊符号组成的字符串，能按照某种模式匹配一系列有相似特征的字符串。Python中通过标准库中的re模块来支持正则表达式。当然，正则表达式并不是python所特有的，在其他语言中也是支持的，其中关于正则表达式的部分是一样的，只是可能...
Python——正则表达式总结
梦码城博客中心
06-19 1507
正则表达式 一，正则表达式介绍 正则表达式是对字符串(包括普通字符(例如,a 到 z 之间的字母)和特殊字符(称为“元字符”))操作的一种逻辑公式,就是用事先定义好的一些特定字符、及这些特定字符的组合,组成一个“规则字符串”,这个“规则字符串”用来表达对字符串的一种过滤逻辑。正则表达式是一种文本模式,该模式描述在搜索文本时要匹配的一个或多个字符串。 使用库 import re 二，re模块下的match方法 匹配单的字符串 字符 功能 . 匹配任意1个字符（除了\n） [
C#正则表达式总结
zengjunjie59的博客
11-30 2247
例子1：”ac“用"a|b"匹配可以匹配出”a“, ”bc“用"a|b"匹配可以匹配出”b“,而“cd”用"a|b"匹配，则无法匹配成功。例子："a&1_"用 \w 匹配，可以匹配出”a"和“1“和“_”，"a&1_"用 \W 匹配，可以匹配出”&"例子："a&1_"用 \d 匹配，可以匹配出“1“，"a&1_"用 \D 匹配，可以匹配出"a"和”&"和”_"例子："a c"用 \s 匹配，可以匹配出“ “，"a c"用 \S 匹配，可以匹配出"a"和”c"b)”匹配可以匹配到"a"，"ab"用"a(?
正则表达式总结，易懂
小白的博客
09-14 476
正则表达式：（使用 test( ) 验证） 1、//之间不需要加引号 2、^的意思是是否以abc开头/^abc/ 3、$的意思是以abc结尾/abc$/ 4、字符类：/[abc]/ 只要包含abc其中一个就返回true 5、/^[abc]$/ abc三选一,只有a只有b 只有c 6、/^[a-z]$/ 26个英文字母任选一,只能有一个 7、/^[a-zA-Z]$/ 26个英文字母大小写任选一 /^[a-zA-Z0-9_-]$/ 8、/^[^a-zA-Z]$/ 如果中括号内有^...
hive sql正则表达式总结
weixin_40659514的博客
09-29 1374
正则表达式
15/18位身份证号码验证的正则表达式总结（详细版）
12-13
开发过程中，常常需要对一些输入信息进行有效性验证，使用正则表达式进行校验是最简单、效率最高的方式了，下面就来看看15/18位身份证号码验证的正则表达式吧。 介绍 xxxxxx yyyy MM dd 375 0 十八位 xxxxxx yy MM...
JS常用正则表达式总结【经典】
10-19
主要介绍了JS常用正则表达式,总结分析了常见的数字、字符、邮箱、身份证、电话等的正则验证技巧,需要的朋友可以参考下
grep中正则表达式
renhl252的专栏
05-05 182
正则表达式式。
Python 正则表达式 (?=...) 和 (?＜=...) 符号
u011699626的博客
05-07 318
内部表达式（匹配的内容）必须是固定长度的，意思就是。注意，以肯定型后视断言开头的正则表达式，匹配项一般不会位于搜索字符串的开头。匹配时，匹配成功，但不消耗字符串中的任何字符。的匹配内容出现在当前位置的左侧，则匹配。这叫做 肯定型后视断言。为了实现这一目标，我们可以采用刚才我们提到的后视和前视。今天遇到了一个比较棘手的问题，于是终于打算要对正则表达式中的。符号可以被替换为任意的符号，这里为了方便说明问题，我们将。字符，但是由于它是前视断言，即向前搜索，而我们的匹配项中。可以看到，此时，结果中包含了两端的。
正则表达式
qq_56104175的博客
05-06 1127
正则表达式是一种可供linux根据过滤文本的自定义模版。linux工具（awk\sed）会在读取数据是使用正则表达式对数据进行模式匹配。如果数据匹配模式，它就会处理，如果数据部匹配模式，他就会被启用。可以在正则表达式中使用不同的特殊字符来定义特定的数据过滤模式。
【Java基础】初识正则表达式
最新发布
qq_43714449的博客
05-08 403
正则表达式只适用于String
正则表达式和扩展正则表达式的区别
03-23
正则表达式（Regular Expression）是一种用于匹配、查找和替换文本的强大工具。它由一系列字符和特殊字符组成，可以用来描述字符串的模式。正则表达式在各种编程语言和文本编辑器中广泛使用。 扩展正则表达式（Extended Regular Expression）是正则表达式的一种扩展形式，它在基本正则表达式的基础上增加了一些功能和语法。扩展正则表达式通常用于更复杂的模式匹配和高级文本处理。 区别如下： 1. 语法：基本正则表达式使用简单的语法，包括字符、元字符和限定符等。而扩展正则表达式引入了更多的元字符和语法，如分组、反向引用、捕获组、零宽断言等。 2. 功能：扩展正则表达式提供了更多的功能，例如支持更复杂的模式匹配、更灵活的替换操作、更精确的字符类定义等。 3. 兼容性：基本正则表达式在不同的编程语言和工具中基本上是通用的，而扩展正则表达式可能会因为不同的实现而有所差异。 总结起来，扩展正则表达式相比基本正则表达式更强大、更灵活，但也更复杂。在实际使用中，可以根据具体需求选择使用基本正则表达式还是扩展正则表达式。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

xjz_2002

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值