学习笔记

Appearance

正则表达式教程 ​

学习正则表达式是理解和利用文本处理和搜索的重要工具之一。以下是一个简单的学习大纲，可以帮助你逐步掌握正则表达式的基础知识和进阶应用：

  • 初级阶段

  1. 了解正则表达式的基本概念

    • 什么是正则表达式？
    • 为什么要使用正则表达式？
    • 正则表达式的作用和应用场景

  2. 掌握基本语法和元字符

    • 学习常见的元字符（如.、*、+、?等）的含义和用法
    • 了解字符类[]和排除字符字类[^]的使用
    • 理解元字符的贪婪匹配和非贪婪匹配

  3. 学习基本的匹配模式

    • 使用.匹配任意字符
    • 使用字符类[]匹配指定范围的字符
    • 使用元字符*、+、?进行重复匹配
    • 使用锚点^和$匹配行的开头和结尾

  4. 练习和实践

    • 在在线工具或文本编辑器中练习编写简单的正则表达式，如匹配邮箱地址、电话号码等。
  • 中级阶段

  1. 深入理解分组和捕获

    • 学习如何使用小括号()进行分组(#学习如何使用小括号进行分组)。
    • 理解捕获组的概念和用法(#理解捕获组的概念和用法)。
    • 学习如何引用捕获组(#学习如何引用捕获组)。

  2. 掌握常用的预定义字符类

    • 学习如何使用\d、\w、\s等预定义字符类匹配数字、字母、空白字符等

  3. 了解量词的贪婪与非贪婪

    • 深入理解量词*、+、?的贪婪匹配和非贪婪匹配

  4. 学习反向引用

    • 掌握如何使用\1、\2等反向引用捕获组
  • 高级阶段

  1. 学习零宽断言

    • 了解零宽断言的概念和分类（如正向先行断言、负向先行断言等）。
    • 学习如何在正则表达式中应用零宽断言。

  2. 掌握更复杂的匹配模式

    • 学习如何处理重复出现的子模式，如匹配嵌套结构等。

  3. 了解并使用模式修饰符

    • 学习如何在正则表达式中使用修饰符，如忽略大小写、多行模式等。

  4. 练习和实践

    • 在实际项目中应用正则表达式，如日志分析、数据清洗等场景。
  • 进阶阶段

  1. 学习优化和性能调优

    • 了解正则表达式的性能影响因素。
    • 学习如何优化复杂正则表达式以提高性能。

  2. 了解其他编程语言中的正则表达式支持

    • 探索其他编程语言（如Python、JavaScript、Java等）中正则表达式的语法和特性。

  3. 实践项目

    • 参与实际项目并利用正则表达式解决实际问题，如网站爬虫、文本分析等。

  4. 持续学习与实践

    • 跟踪正则表达式技术的最新发展和应用，不断扩展和提升自己的技能。

以上是一个大致的学习路线，你可以根据自己的学习进度和需求来安排学习计划，并结合实际项目进行练习和实践，以更好地掌握正则表达式的应用。

初级阶段 ​

了解正则表达式的基本概念 ​

什么是正则表达式？ ​

正则表达式（Regular Expression，简称 Regex 或 RegExp）是一种用于描述字符模式的强大工具。它是由普通字符（例如字母、数字、空格等）和特殊字符（称为元字符）组成的字符串，用来匹配和搜索文本中的特定模式或字符序列。

正则表达式在文本处理、搜索和替换等领域有着广泛的应用，它可以用来实现各种文本处理任务，包括验证输入的格式、提取特定的信息、过滤文本等。通过灵活地组合普通字符和元字符，可以构建出复杂的匹配规则，使得正则表达式成为处理文本的强大工具。

举例来说，一个简单的正则表达式 \d{3}-\d{3}-\d{4} 可以用来匹配美国的电话号码格式，其中 \d 表示匹配任意数字，{3} 表示匹配前面的模式恰好三次，- 表示匹配破折号。因此，这个正则表达式可以匹配形如 "123-456-7890" 的电话号码。

总之，正则表达式是一种强大而灵活的工具，可以帮助程序员和数据处理人员轻松地处理和操纵文本数据。

为什么要使用正则表达式？ ​

使用正则表达式有以下几个主要原因：

  1. 灵活性和强大性： 正则表达式提供了一种灵活、强大且高效的文本匹配和处理机制。通过正则表达式，可以描述和匹配各种复杂的文本模式，从而实现各种文本处理任务。

  2. 文本搜索和替换： 正则表达式可以用于在文本中搜索指定的模式，并对匹配的文本进行替换、删除、提取等操作。这在处理大量文本数据时非常有用，可以提高搜索和替换的效率。

  3. 格式验证和数据提取： 正则表达式可以用于验证输入的格式是否符合指定的要求，例如邮箱地址、电话号码、身份证号码等。同时，也可以从文本中提取出符合特定模式的信息，如提取网页中的链接、提取日志中的关键信息等。

  4. 跨平台和多语言支持： 正则表达式是一种通用的文本处理工具，几乎所有主流的编程语言和操作系统都提供了对正则表达式的支持。因此，无论你使用哪种编程语言或操作系统，都可以方便地使用正则表达式来处理文本数据。

  5. 简洁和高效： 正则表达式通常比手动编写复杂的文本处理代码更加简洁和高效。一行或几行正则表达式就可以实现复杂的文本匹配和处理，大大提高了开发效率和代码可读性。

综上所述，正则表达式是一种强大而灵活的文本处理工具，可以帮助程序员和数据处理人员轻松地处理各种文本数据，提高工作效率和代码质量。

正则表达式的作用和应用场景 ​

正则表达式在各种领域都有广泛的应用，其主要作用和应用场景包括但不限于以下几个方面：

  1. 文本搜索和匹配： 正则表达式可以用于在文本中搜索指定的模式或匹配特定的字符序列。例如，可以使用正则表达式来查找包含特定关键词的文本、匹配邮箱地址、匹配电话号码等。

  2. 数据提取和抽取： 正则表达式可以从文本中提取出符合特定模式的信息。例如，可以使用正则表达式从网页源代码中提取链接、从日志文件中提取关键信息等。

  3. 格式验证和数据清洗： 正则表达式可以用于验证输入的格式是否符合指定的要求，并对数据进行清洗和预处理。例如，可以使用正则表达式验证用户输入的邮箱地址、电话号码、身份证号码等是否合法，并对其进行格式化或修复。

  4. 文本替换和修改： 正则表达式可以对文本进行替换、修改或删除操作。例如，可以使用正则表达式来将文本中的特定字符串替换为其他字符串、删除文本中的空白字符、修复文本中的格式错误等。

  5. 日志分析和数据挖掘： 正则表达式在日志分析和数据挖掘领域也有广泛的应用。例如，可以使用正则表达式从服务器日志中提取访问信息、分析用户行为模式等。

  6. 编程语言中的模式匹配： 许多编程语言（如Python、JavaScript、Java等）都提供了对正则表达式的支持，可以在编程中使用正则表达式来实现模式匹配、字符串搜索和处理等功能。

总的来说，正则表达式是一种强大而灵活的文本处理工具，在各种文本处理、搜索和匹配场景中都有着重要的应用价值。通过合理使用正则表达式，可以提高文本处理的效率和精度，从而更好地满足实际需求。

掌握基本语法和元字符 ​

学习常见的元字符（如.、*、+、?等）的含义和用法 ​

元字符是正则表达式中具有特殊含义的字符，它们用于描述模式的结构和特征。以下是一些常见的元字符及其含义和用法：

  1. .（点号）：匹配任意单个字符，除了换行符 \n 外的任何字符。例如，正则表达式 a.c 可以匹配 "abc"、"a1c"、"a@c" 等。

  2. *（星号）：匹配前面的字符零次或多次。例如，正则表达式 ab* 可以匹配 "a"、"ab"、"abb"、"abbb" 等。

  3. +（加号）：匹配前面的字符一次或多次。例如，正则表达式 ab+ 可以匹配 "ab"、"abb"、"abbb" 等，但不能匹配 "a"。

  4. ?（问号）：匹配前面的字符零次或一次，表示可选。例如，正则表达式 ab? 可以匹配 "a"、"ab"，但不能匹配 "abb"。

  5. ^（脱字符）：匹配输入字符串的开始位置。例如，正则表达式 ^abc 可以匹配以 "abc" 开头的字符串。

  6. $（美元符号）：匹配输入字符串的结束位置。例如，正则表达式 abc$ 可以匹配以 "abc" 结尾的字符串。

  7. []（字符类）：匹配指定范围内的任意一个字符。例如，正则表达式 [abc] 可以匹配 "a"、"b"、"c" 中的任意一个字符。

  8. [^]（排除字符类）：匹配除了指定范围内的任意一个字符以外的字符。例如，正则表达式 [^abc] 可以匹配除了 "a"、"b"、"c" 以外的任意一个字符。

  9. ()（分组）：将多个字符组合成一个单元，可以对其进行量词操作或引用。例如，正则表达式 (ab)+ 可以匹配 "ab"、"abab"、"ababab" 等。

  10. \（反斜杠）：用于转义特殊字符，使其失去特殊含义。例如，正则表达式 \.com 可以匹配 ".com"，而不是匹配任意字符后跟着 "com"。

以上是一些常见的元字符及其含义和用法，掌握它们能够帮助你构建更加灵活和强大的正则表达式，用于实现各种文本匹配和处理任务。

了解字符类[]和排除字符字类[^]的使用 ​

字符类 [] 和排除字符类 [^] 是正则表达式中用于匹配指定范围内字符的特殊构造。

  1. 字符类 []：
    • 字符类用于匹配方括号内的任意一个字符。
    • 可以指定单个字符，也可以指定字符范围。
    • 如果在字符类中使用连字符 -，它会表示一个字符范围。
    • 字符类中的元字符失去特殊含义，只匹配自身字符。

示例：

  • [abc]：匹配 "a"、"b"、"c" 中的任意一个字符。
  • [a-z]：匹配从 "a" 到 "z" 之间的任意一个小写字母。
  1. 排除字符类 [^]：
    • 排除字符类用于匹配除了方括号内指定的字符之外的任意一个字符。
    • 在字符类的开头使用插入符 ^ 表示排除字符类。
    • 排除字符类中的元字符失去特殊含义，只匹配自身字符。

示例：

  • [^abc]：匹配除了 "a"、"b"、"c" 之外的任意一个字符。
  • [^a-z]：匹配除了小写字母之外的任意一个字符。

使用示例：

  • [aeiou]：匹配任意一个元音字母。
  • [0-9]：匹配任意一个数字字符。
  • [^0-9]：匹配除了数字字符之外的任意一个字符。
  • [A-Za-z]：匹配任意一个大小写字母。

总之，字符类 [] 和排除字符类 [^] 是正则表达式中用于匹配指定范围内字符的重要工具，它们可以帮助你更精确地匹配目标字符，从而实现各种文本处理任务。

理解元字符的贪婪匹配和非贪婪匹配 ​

在正则表达式中，量词元字符（如 *、+、?、{}）通常具有贪婪匹配和非贪婪匹配两种匹配模式。

  1. 贪婪匹配：
    • 贪婪匹配是默认的匹配模式。
    • 贪婪匹配尽可能多地匹配文本，直到无法继续匹配为止。
    • 在量词元字符后加上 ? 可以将其转换为非贪婪匹配模式。

示例：

  • 对于正则表达式 a+，在文本 "aaaa" 中进行匹配时，贪婪匹配会尽可能匹配更多的 "a"，结果会匹配整个字符串 "aaaa"。
  • 对于正则表达式 a+?，在相同的文本 "aaaa" 中进行匹配时，非贪婪匹配只会匹配尽可能少的 "a"，结果会匹配一个 "a"。
  1. 非贪婪匹配（懒惰匹配）：
    • 非贪婪匹配尽可能少地匹配文本，以满足匹配条件为止。
    • 在量词元字符后加上 ? 就可以将其转换为非贪婪匹配模式。
    • 非贪婪匹配也被称为懒惰匹配或最小匹配。

示例：

  • 对于正则表达式 a*，在文本 "aaaa" 中进行匹配时，贪婪匹配会匹配整个字符串 "aaaa"，而非贪婪匹配会匹配空字符串，因为它尽可能少地匹配 "a"。
  • 对于正则表达式 a*?，在相同的文本 "aaaa" 中进行匹配时，非贪婪匹配会匹配尽可能少的 "a"，结果会匹配空字符串。

总之，贪婪匹配和非贪婪匹配是正则表达式中量词元字符的两种匹配模式，可以根据实际需求选择合适的模式来匹配目标文本。

学习基本的匹配模式 ​

使用 . 匹配任意字符 ​

使用.可以匹配任意单个字符，除了换行符 \n 之外的任何字符。下面是一些示例：

  1. 正则表达式：.

    • 匹配：任意单个字符，除了换行符。
    • 示例：a. 可以匹配 "ab"、"ac"，但不能匹配 "a\n"。

  2. 正则表达式：a.b

    • 匹配：一个 "a" 后面跟着任意单个字符，然后再跟着一个 "b"。
    • 示例：a.b 可以匹配 "axb"、"a1b"，但不能匹配 "a\nb"。

  3. 正则表达式：.*

    • 匹配：任意数量（包括零个）的任意字符。
    • 示例：.* 可以匹配任何字符串，包括空字符串。

  4. 正则表达式：a.*b

    • 匹配：以 "a" 开头，以 "b" 结尾，中间包含任意数量的任意字符的字符串。
    • 示例：a.*b 可以匹配 "axxxxxb"、"a1b"、"ab"，但不能匹配 "a\nb"。

总之，. 是一个匹配任意单个字符的元字符，除了换行符 \n 之外的任何字符。

使用字符类[]匹配指定范围的字符 ​

字符类 [] 可以用来匹配指定范围内的任意一个字符。下面是一些示例：

  1. 正则表达式：[abc]

    • 匹配：任意一个字符，可以是 "a"、"b" 或 "c" 中的任意一个。
    • 示例：[abc] 可以匹配 "a"、"b"、"c"。

  2. 正则表达式：[a-z]

    • 匹配：任意一个小写字母。
    • 示例：[a-z] 可以匹配 "a"、"b"、"c"、...、"z"。

  3. 正则表达式：[A-Z]

    • 匹配：任意一个大写字母。
    • 示例：[A-Z] 可以匹配 "A"、"B"、"C"、...、"Z"。

  4. 正则表达式：[0-9]

    • 匹配：任意一个数字字符。
    • 示例：[0-9] 可以匹配 "0"、"1"、"2"、...、"9"。

  5. 正则表达式：[a-zA-Z]

    • 匹配：任意一个字母，可以是小写字母或大写字母。
    • 示例：[a-zA-Z] 可以匹配 "a"、"b"、...、"z" 和 "A"、"B"、...、"Z"。

  6. 正则表达式：[0-9a-fA-F]

    • 匹配：任意一个十六进制字符，可以是数字 0-9 或小写字母 a-f 或大写字母 A-F。
    • 示例：[0-9a-fA-F] 可以匹配 "0"、"1"、...、"9"、"a"、"b"、...、"f"、"A"、"B"、...、"F"。

总之，字符类 [] 可以用于匹配指定范围内的任意一个字符，你可以根据需要灵活地使用它来匹配目标字符。

使用元字符*、+、?进行重复匹配 ​

元字符 *、+ 和 ? 都是用于表示重复匹配的量词，它们可以指定前面的字符或子表达式的重复次数，具体如下：

  1. *（星号）：匹配前面的字符或子表达式零次或多次。

    • 示例：
      • 正则表达式 ab* 匹配一个 "a" 后面跟着零个或多个 "b"，因此可以匹配 "a"、"ab"、"abb"、"abbb" 等。

  2. +（加号）：匹配前面的字符或子表达式一次或多次。

    • 示例：
      • 正则表达式 ab+ 匹配一个 "a" 后面跟着至少一个 "b"，因此可以匹配 "ab"、"abb"、"abbb" 等，但不能匹配 "a"。

  3. ?（问号）：匹配前面的字符或子表达式零次或一次，表示可选。

    • 示例：
      • 正则表达式 ab? 匹配一个 "a" 后面跟着零个或一个 "b"，因此可以匹配 "a"、"ab"，但不能匹配 "abb"。

这些量词元字符可以用于构建复杂的匹配规则，你可以根据实际需求选择合适的量词来匹配目标字符串。

使用锚点^和$匹配行的开头和结尾 ​

锚点 ^ 和 $ 分别用于匹配行的开头和结尾。

  • ^（脱字符）：匹配输入字符串的开始位置。
  • $（美元符号）：匹配输入字符串的结束位置。

这些锚点可以用于限制匹配的位置，确保匹配发生在输入字符串的特定位置。以下是一些示例：

  1. 正则表达式 ^Hello：

    • 匹配：以 "Hello" 开头的字符串。
    • 示例：^Hello 可以匹配 "Hello, world!" 中的 "Hello"，但不能匹配 "Hi, Hello" 中的 "Hello"。

  2. 正则表达式 world!$：

    • 匹配：以 "world!" 结尾的字符串。
    • 示例：world!$ 可以匹配 "Hello, world!" 中的 "world!"，但不能匹配 "world! Hello" 中的 "world!"。

  3. 正则表达式 ^Hello, world!$：

    • 匹配：完全匹配 "Hello, world!" 的字符串。
    • 示例：^Hello, world!$ 只能匹配 "Hello, world!"，不匹配其他字符串。

  4. 正则表达式 ^$：

    • 匹配：空字符串。
    • 示例：^$ 只能匹配空字符串。

这些锚点非常有用，可以用于确保匹配发生在字符串的指定位置，从而实现更精确的匹配。

中级阶段 ​

深入理解分组和捕获 ​

学习如何使用小括号()进行分组 ​

小括号 () 在正则表达式中用于创建一个子表达式，也称为分组。分组可以将多个字符或子表达式组合成一个单元，从而可以对这个单元进行量词操作、引用等。

下面是使用小括号 () 进行分组的一些示例和说明：

  1. 分组示例：

    • 正则表达式 (\d{3})-\d{3}-\d{4} 匹配电话号码，并将区号部分 \d{3} 放在第一个分组中。

  2. 量词操作：

    • 可以对整个分组进行量词操作，例如 (\d{3}){2} 表示匹配两次区号。
    • 正则表达式 (ab)+ 匹配一个或多个连续的 "ab"。

  3. 引用：

    • 可以通过反向引用来引用分组，例如 \1 表示引用第一个分组。
    • 正则表达式 (\w+)\s\1 可以用来匹配重复的单词，例如 "hello hello"。

  4. 捕获组：

    • 分组还可以作为捕获组，匹配的内容可以在匹配后进行提取和使用。
    • 在一些编程语言中，捕获组的匹配结果可以通过索引或命名进行访问。

分组可以使正则表达式更加灵活和强大，你可以根据实际需求合理地使用分组来构建更复杂的匹配规则。

理解捕获组的概念和用法 ​

捕获组是正则表达式中的一种特性，它允许你将匹配到的子字符串单独提取出来，并在匹配后进行访问和使用。当你使用小括号 () 将一个部分包围起来时，这个部分就成为了一个捕获组。捕获组在很多编程语言和正则表达式引擎中都有广泛的支持。

  • 捕获组的用法：

  1. 提取匹配的内容： 捕获组允许你在匹配后从原始字符串中提取出你感兴趣的部分。这对于从文本中提取特定信息非常有用，比如从电话号码中提取区号。

  2. 引用捕获组： 在正则表达式中，你可以使用反向引用来引用捕获组。这意味着你可以在同一正则表达式中引用之前匹配到的内容，从而实现更复杂的匹配规则。例如，你可以匹配重复的单词或重复的数字。

  3. 在匹配后使用捕获组： 一旦正则表达式匹配成功，你可以使用编程语言的正则表达式相关函数来访问捕获组中的内容，并在程序中进一步处理或使用这些内容。不同的编程语言提供了不同的方式来访问捕获组中的内容，通常是通过索引或命名来访问。

  • 示例：

假设我们有一个字符串 "My email address is example@example.com"，我们想要提取出其中的邮箱地址。

使用正则表达式 /(\w+@\w+\.\w+)/，其中 (\w+@\w+\.\w+) 是一个捕获组，可以匹配一个邮箱地址，并提取出来。

在编程中，你可以使用正则表达式引擎提供的相关函数，比如在 Python 中使用 re.match() 或 re.search()，来匹配字符串，并访问捕获组中的内容。

总之，捕获组是正则表达式中一种非常有用的特性，可以帮助你从文本中提取出你感兴趣的内容，并在程序中进一步处理和使用。

学习如何引用捕获组 ​

在正则表达式中，引用捕获组是指在同一个正则表达式中使用已经匹配到的捕获组的内容。这种引用通常使用反向引用来实现。下面是一些关于如何引用捕获组的基本知识和示例：

  1. 使用反向引用来引用捕获组：

在正则表达式中，可以使用 \数字 来引用之前定义的捕获组，其中数字表示捕获组的索引，从 1 开始计数。

例如，假设我们有一个正则表达式 (\w+)\s\1，其中 (\w+) 是第一个捕获组，匹配一个或多个单词字符，\s 匹配一个空白字符，\1 表示引用第一个捕获组。这个正则表达式将匹配重复的单词。

示例：

考虑字符串 "hello hello"，我们想要匹配其中重复的单词。

  • 正则表达式：(\w+)\s\1
    • (\w+)：第一个捕获组，匹配一个或多个单词字符。
    • \s：匹配一个空白字符。
    • \1：引用第一个捕获组。
  • 匹配结果：匹配到 "hello hello"，因为第一个 "hello" 被捕获到了，然后 \1 引用了第一个捕获组，所以它要求匹配到的内容必须与第一个捕获组相同，于是第二个 "hello" 也被匹配到了。
  1. 在代码中引用捕获组：

在使用正则表达式进行匹配的编程语言中，通常提供了相应的函数来访问捕获组的内容。你可以使用这些函数来获取捕获组中的内容，并在程序中进一步处理。

以 Python 为例，可以使用 re 模块中的 match() 或 search() 函数来进行正则表达式匹配，并使用 group() 方法来访问捕获组中的内容。

python
import re

text = "hello hello"
pattern = r"(\w+)\s\1"
match = re.search(pattern, text)
if match:
    print("Match found:", match.group(0))  ## 打印整个匹配到的内容
    print("Captured group:", match.group(1))  ## 打印第一个捕获组的内容

总之，引用捕获组是一种在正则表达式中使用已经匹配到的内容的强大技术，可以帮助你构建更复杂和灵活的匹配规则。

掌握常用的预定义字符类 ​

学习如何使用\d、\w、\s等预定义字符类匹配数字、字母、空白字符等 ​

在正则表达式中，\d、\w、\s 等是预定义字符类，用于匹配特定类型的字符。它们的含义如下：

  • \d：匹配任意一个数字字符，相当于字符类 [0-9]。
  • \w：匹配任意一个字母、数字或下划线字符（即单词字符），相当于字符类 [A-Za-z0-9_]。
  • \s：匹配任意一个空白字符，包括空格、制表符、换行符等。

以下是一些示例，演示如何使用这些预定义字符类：

  1. 匹配一个数字字符：

    • 正则表达式：\d
    • 匹配：任意一个数字字符，包括 "0" 到 "9" 之间的任意一个数字。

  2. 匹配一个字母、数字或下划线字符：

    • 正则表达式：\w
    • 匹配：任意一个字母、数字或下划线字符，包括大写字母、小写字母、数字和下划线。

  3. 匹配一个空白字符：

    • 正则表达式：\s
    • 匹配：任意一个空白字符，包括空格、制表符、换行符等。

示例代码（使用 Python 的 re 模块）：

python
import re

text = "The number is 123, and the word is hello world."
pattern_digit = r"\d"
pattern_word = r"\w"
pattern_space = r"\s"

## 匹配数字字符
matches_digit = re.findall(pattern_digit, text)
print("Digits:", matches_digit)

## 匹配字母、数字或下划线字符
matches_word = re.findall(pattern_word, text)
print("Words:", matches_word)

## 匹配空白字符
matches_space = re.findall(pattern_space, text)
print("Spaces:", matches_space)

输出结果会分别显示匹配到的数字字符、字母、数字或下划线字符以及空白字符。

了解量词的贪婪与非贪婪 ​

深入理解量词*、+、?的贪婪匹配和非贪婪匹配 ​

理解量词 *、+ 和 ? 的贪婪匹配和非贪婪匹配是使用正则表达式时非常重要的概念。

  1. 贪婪匹配：

    • 默认情况下，*、+ 和 ? 都是贪婪的，它们会尽可能多地匹配目标文本，直到不能匹配为止。
    • 在贪婪模式下，正则表达式引擎会尝试匹配尽可能长的字符串。
    • 贪婪匹配的量词会尽可能多地匹配符合条件的文本，而且不会考虑后续可能的匹配情况。

  2. 非贪婪匹配（懒惰匹配）：

    • 在量词后面添加 ? 可以将贪婪匹配转换为非贪婪匹配。
    • 非贪婪匹配会尽可能少地匹配目标文本，直到满足匹配条件为止。
    • 非贪婪匹配会尽可能少地匹配符合条件的文本，以便为后续的匹配留下更多的机会。
  • 示例：

考虑正则表达式 .*，它表示匹配任意数量（包括零个）的任意字符。

  • 在贪婪模式下，正则表达式引擎会尽可能多地匹配文本，因此会匹配尽可能长的字符串。
  • 在非贪婪模式下，添加 ? 后，正则表达式引擎会尽可能少地匹配文本，因此会匹配尽可能短的字符串。
plaintext
目标文本：abcdefg
正则表达式：.*

贪婪匹配结果：abcdefg
非贪婪匹配结果：a

在贪婪模式下，.* 匹配了整个目标文本 "abcdefg"，而在非贪婪模式下，.*? 只匹配了目标文本的第一个字符 "a"。

总之，理解量词 *、+ 和 ? 的贪婪匹配和非贪婪匹配可以帮助你编写更加精确和有效的正则表达式，从而实现各种文本匹配和处理任务。

学习反向引用 ​

掌握如何使用\1、\2等反向引用捕获组 ​

反向引用捕获组是指在正则表达式中引用已经匹配到的捕获组的内容。在大多数编程语言和正则表达式引擎中，你可以使用 \数字 来引用捕获组，其中数字表示捕获组的索引，从 1 开始计数。

以下是一些关于如何使用反向引用捕获组的基本知识和示例：

  • 使用反向引用：

  1. 在正则表达式中，使用 \数字 来引用之前定义的捕获组。

  2. 数字表示捕获组的索引，从 1 开始计数，即第一个捕获组的索引是 1，第二个捕获组的索引是 2，依此类推。

  3. 在正则表达式中，可以在需要引用捕获组的地方使用 \数字，例如替换字符串中、在匹配模式中等。

  • 示例：

假设我们有一个字符串 "hello hello"，我们想要匹配其中重复的单词，并将重复的单词替换为单个单词。

  1. 正则表达式：(\w+)\s\1
    • (\w+)：第一个捕获组，匹配一个或多个单词字符。
    • \s：匹配一个空白字符。
    • \1：引用第一个捕获组。
  2. 替换字符串：\1
    • 将匹配到的重复单词替换为第一个捕获组的内容。

在代码中，我们可以使用编程语言提供的正则表达式替换函数，如 Python 中的 re.sub()，来实现这个功能。

  • 示例代码（Python）：
python
import re

text = "hello hello"
pattern = r"(\w+)\s\1"
replacement = r"\1"

result = re.sub(pattern, replacement, text)
print(result)  ## 输出 "hello"

在这个示例中，正则表达式 (\w+)\s\1 匹配了重复的单词，并使用 \1 将重复的单词替换为第一个捕获组的内容，最终输出结果为 "hello"。

高级阶段和进阶阶段用不到

最后更新于:

MIT License.

Copyright © 2024-present wardenxyz