​

一、正则表达式入门​

正则表达式本质上是一串字符序列，用于定义一个文本模式。通过这个模式，我们可以指定要匹配的文本特征。例如，如果你想匹配一个以 “abc” 开头的字符串，正则表达式可以写作 “^abc”，其中 “^” 表示匹配字符串的开头。​

（一）基本字符匹配​

在正则表达式中，普通字符（如字母、数字）通常表示它们自身。例如，正则表达式 “abc” 可以匹配文本中的 “abc” 序列。如果文本是 “abcdef”，那么 “abc” 会匹配成功；但如果文本是 “defabc”，那么匹配失败，因为正则表达式是从左到右进行匹配的。​

案例（JavaScript）：​

const text1 = "abcdef";​const regex1 = /abc/;​console.log(regex1.test(text1)); // 输出: true​​const text2 = "defabc";​const regex2 = /abc/;​console.log(regex2.test(text2)); // 输出: false​

​

在上述代码中，/abc/是一个正则表达式字面量，test方法用于测试给定的字符串是否包含匹配正则表达式的文本。​

（二）特殊字符​

正则表达式中有一些特殊字符，它们具有特殊的含义。例如：​

“.”（点号）：匹配任意单个字符（除了换行符）。例如，“a.c” 可以匹配 “abc”、“adc” 等，但不能匹配 “ac”。​
“”（星号）：表示前面的字符可以出现零次或多次。例如，“abc” 可以匹配 “ac”、“abc”、“abbc” 等。​
“+”（加号）：表示前面的字符至少出现一次。例如，“ab+c” 可以匹配 “abc”、“abbc” 等，但不能匹配 “ac”。​
“？”（问号）：表示前面的字符可以出现零次或一次。例如，“ab？c” 可以匹配 “ac” 和 “abc”。​
“^{”（脱字符）：用于匹配字符串的开头。例如，“}abc” 表示匹配以 “abc” 开头的字符串。​
“​

” 表示匹配以 “abc” 结尾的字符串。​

​

// “.”的案例​const text3 = "a1c a2c a c";​const regex3 = /a.c/;​console.log(text3.match(regex3)); // 输出: ["a1c"]，注意：match方法默认只返回第一个匹配结果​​// “*”的案例​const text4 = "ac abc abbc abbbc";​const regex4 = /ab*c/;​console.log(text4.match(regex4)); // 输出: ["abbbc"]​​// “+”的案例​const text5 = "abc abbc abbbc";​const regex5 = /ab+c/;​console.log(text5.match(regex5)); // 输出: ["abbbc"]​​// “?”的案例​const text6 = "ac abc";​const regex6 = /ab?c/;​console.log(text6.match(regex6)); // 输出: ["abc"]​​// “^”的案例​const text7 = ["abcdef", "defabc", "abc"];​const regex7 = /^abc/;​text7.forEach(str => {​console.log(regex7.test(str)); ​// 输出: true, false, true​});​​// “$”的案例​const text8 = ["abc", "defabc", "abcd"];​const regex8 = /abc$/;​text8.forEach(str => {​console.log(regex8.test(str)); ​// 输出: true, true, false​});​

​

在这些案例中，match方法用于在字符串中查找所有匹配正则表达式的子字符串，并返回一个数组。如果没有找到匹配项，则返回null。test方法则用于判断字符串是否与正则表达式匹配，返回true或false。​

（三）字符集​

字符集用于匹配一组特定的字符。例如，“[abc]” 可以匹配 “a”、“b” 或 “c”。字符集还可以使用范围表示法，如 “[a-z]” 表示匹配任意一个小写字母，“[0-9]” 表示匹配任意一个数字。​

// 匹配元音字母​const text9 = "apple banana cherry";​const regex9 = /[aeiou]/g;​console.log(text9.match(regex9)); ​// 输出: ["a", "e", "a", "a", "e"]，这里的“g”标志表示全局匹配，即找到所有匹配项​​// 匹配数字​const text10 = "123abcABC";​const regex10 = /[0-9]/g;​console.log(text10.match(regex10)); // 输出: ["1", "2", "3"]​​// 匹配字母​const text11 = "123abcABC";​const regex11 = /[a-zA-Z]/g;​console.log(text11.match(regex11)); // 输出: ["a", "b", "c", "A", "B", "C"]​

​

在上述代码中，正则表达式中的 “g” 标志是非常重要的，它使得match方法能够返回所有匹配的结果，而不仅仅是第一个。​

（四）分组​

分组是通过圆括号 “（）” 来实现的。它可以将多个字符组合在一起，作为一个整体进行匹配。例如，“(abc)+” 表示匹配一个或多个 “abc” 序列。​

const text12 = "abcabcabc abcab ab";​const regex12 = /(abc)+/g;​console.log(text12.match(regex12)); ​// 输出: ["abcabcabc", "abcab"]​​

在这个例子中，通过分组我们能够准确匹配由一个或多个 “abc” 序列组成的子字符串。​

二、正则表达式的进阶应用​

（一）匹配特定格式的文本​

正则表达式可以用来匹配各种特定格式的文本，如日期、电话号码、电子邮件地址等。例如，一个简单的电子邮件地址匹配正则表达式可以写作 “[a-zA-Z0-9_.±]+@[a-zA-Z0-9-]+.[a-zA-Z0-9-.]+”。这个表达式通过字符集和分组的方式，确保了电子邮件地址的基本格式。​

// 日期匹配​const text13 = "今天是2023-10-15，明天是2023-10-16";​const regex13 = /\d{4}-\d{2}-\d{2}/g;​console.log(text13.match(regex13)); ​// 输出: ["2023-10-15", "2023-10-16"]​​// 电话号码匹配​const text14 = "联系电话：13800138000";​const regex14 = /1\d{10}/;​console.log(text14.match(regex14)); // 输出: ["13800138000"]​​// 电子邮件地址匹配​const text15 = "我的邮箱是example@example.com，另一个是test_123@test-company.co.uk";​const regex15 = /[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+/g;​console.log(text15.match(regex15)); ​// 输出: ["example@example.com", "test_123@test-company.co.uk"]​​

这些案例展示了如何使用正则表达式在 JavaScript 中准确匹配常见的特定格式文本。​

（二）捕获与替换​

正则表达式不仅可以用于匹配文本，还可以用于捕获和替换文本。通过分组和捕获功能，我们可以提取文本中的特定部分，并进行替换操作。例如，在文本编辑器中，我们可以使用正则表达式查找所有以 “http://” 开头的链接，并将其替换为 “https://”。​

// 捕获域名部分并替换链接协议​const text16 = "请访问链接：http://example.com和http://test.com";​const regex16 = /http://([a-zA-Z0-9-.]+)/g;​const newText16 = text16.replace(regex16, "https://$1");​console.log(newText16); ​// 输出: 请访问链接：https://example.com和https://test.com​​// 提取价格部分​const text17 = "苹果价格是10元，香蕉价格是5元";​const regex17 = /价格是 (\d+) 元/g;​const prices = text17.match(regex17);​if (prices) {​prices.forEach(price => {​const num = price.match(/\d+/)[0];​console.log(parseInt(num)); ​// 输出: 10, 5​});​}​

​

在第一个替换案例中，replace方法接受一个正则表达式和一个替换字符串，其中 “$1” 表示引用第一个捕获组的内容。在第二个提取案例中，我们先通过正则表达式找到包含价格的子字符串，然后再进一步提取其中的数字。​

（三）贪婪与非贪婪匹配​

在正则表达式中，贪婪模式会尽可能多地匹配字符，而非贪婪模式则会尽可能少地匹配字符。例如，“ab” 是一个贪婪模式，它会匹配 “aabb” 中的 “aabb”；而 “a?b” 是一个非贪婪模式，它会匹配 “aabb” 中的 “ab” 和 “abb”。​

// 贪婪模式案例​const text18 = "aaaab";​const regex18 = /a*b/;​console.log(text18.match(regex18)); // 输出: ["aaaab"]​​// 非贪婪模式案例​const text19 = "aaaab";​const regex19 = /a*?b/;​console.log(text19.match(regex19)); // 输出: ["ab"]​​// 提取HTML标签内内容的案例​const text20 = "<div>content1</div><div>content2</div>";​const greedyRegex = /<div>.*</div>/;​const nonGreedyRegex = /<div>.*?</div>/g;​console.log(text20.match(greedyRegex)); ​// 输出: ["<div>content1</div><div>content2</div>"]​console.log(text20.match(nonGreedyRegex)); ​// 输出: ["<div>content1</div>", "<div>content2</div>"]​​

通过这些案例，可以清晰地看到贪婪模式和非贪婪模式在匹配行为上的差异。​

三、正则表达式的高级技巧​

（一）前瞻与后顾​

前瞻（Lookahead）和后顾（Lookbehind）是正则表达式中的高级功能。它们允许我们在匹配时考虑后面的或前面的字符，但不将其包含在匹配结果中。例如，“(?=abc) def” 表示匹配 “def”，但前提是它后面跟着 “abc”。​

// 正向前瞻案例​const text21 = "defabc defxyz";​const regex21 = /(?=abc)def/;​console.log(text21.match(regex21)); // 输出: ["def"]​​// 正向后顾案例​const text22 = "abcdef xyzdef";​const regex22 = /(?<=abc)def/;​console.log(text22.match(regex22)); // 输出: ["def"]​​

在 JavaScript 中，正向后顾在某些环境（如 Chrome 浏览器）中支持有限，上述代码在支持正向后顾的环境中运行。​

（二）递归匹配​

递归匹配是一种强大的功能，可以用于匹配嵌套的结构，如括号嵌套。例如，“​

(?>[()]+∣(?R))∗

” 可以匹配嵌套的括号结构。​

const text23 = "((a + b) * (c - d))";​const regex23 = /\((?>[^()]+|(?R))*\)/;​console.log(text23.match(regex23)); ​// 输出: ["((a + b) * (c - d))"]​​const text24 = "((a + b) * (c - d)";​console.log(text24.match(regex23)); ​// 输出: null​

​

这个案例展示了递归匹配在处理嵌套结构时的有效性，以及在括号不完整时匹配失败的情况。​

（三）性能优化​

正则表达式的性能优化非常重要，尤其是在处理大量文本时。避免使用过于复杂的正则表达式，尽量减少回溯次数，可以提高匹配效率。​

// 低效的匹配单词方式​const longText = "这是一篇很长很长的文档，包含了很多单词，比如apple, banana, cherry等等";​const inefficientRegex = /[a-zA-Z]+|[^a-zA-Z]+/g;​console.time("inefficientMatch");​longText.match(inefficientRegex);​console.timeEnd("inefficientMatch"); ​​// 高效的匹配单词方式（先分割）​console.time("efficientMatch");​const words = longText.split(/[^a-zA-Z]+/).filter(word => word.length > 0);​console.timeEnd("efficientMatch"); ​​

在这个案例中，通过console.time和console.timeEnd方法可以对比两种方式的执行时间，明显可以看出先分割的方式在处理大量文本时性能更优。​

四、正则表达式的实践案例​

（一）数据清洗​

在数据处理中，正则表达式可以用于清洗文本数据。例如，去除文本中的多余空格、特殊字符等。​

// 去除多余空格​const text25 = " 你好，世界！ ";​const regex25 = /\s+/g;​const cleanText25 = text25.replace(regex25, " ");​console.log(cleanText25); ​// 输出: 你好，世界！​​// 去除特殊字符​const text26 = "!@#Hello, World$%^";​const regex26 = /[!@#$%^&*(),.?":{}|<>]/g;​const cleanText26 = text26.replace(regex26, "");​console.log(cleanText26); ​// 输出: Hello, World​​

通过这些案例，我们可以看到正则表达式在数据清洗方面的便捷性。​

（二）文本提取​

从网页或文档中提取特定信息，如标题、链接、日期等，正则表达式是一个非常有用的工具。​

// 从网页中提取链接​const htmlText = "<a href=\"http://example1.com\">链接1</a><a href=\"http://example2.com\">链接2</a>";​const linkRegex = /<a href="([^"]+)">/g;​const links = htmlText.match(linkRegex);​if (links) {​links.forEach(link => {​const url = link.match(/"([^"]+)"/)[1];​console.log(url); ​// 输出: http://example1.com, http://example2.com​});​}​​// 从文档中提取标题​const docText = "# 标题1\n内容1\n# 标题2\n内容2";​const titleRegex = /^# (.*)$/gm;​const titles = docText.match(titleRegex);​if (titles) {​titles.forEach(title => {​const titleText = title.match(/# (.*)/)[1];​console.log(titleText); ​// 输出: 标题1, 标题2​});​}​​

这里的 “m” 标志表示多行匹配，使得正则表达式能够匹配每一行以 “# ” 开头的内容。​

（三）代码分析​

在代码编辑器中，正则表达式可以用于高亮显示特定的代码模式，如注释、关键字等。​

const code = "# 这是一个注释\nprint('Hello, World!')";​const commentRegex = /#.*$/gm;​const highlightedCode = code.replace(commentRegex, match => `<span style="color: green;">${match}</span>`);​console.log(highlightedCode); ​// 输出: <span style="color: green;"># 这是一个注释</span>​// print('Hello, World!')​​const keywordRegex = /\b(print|def|class|if|else|for|while)\b/g;​const keywordHighlightedCode = highlightedCode.replace(keywordRegex, match​
=> <span style="color: blue;">${match}</span>);​
console.log (keywordHighlightedCode);​
// 输出: # 这是一个注释​
// print('Hello, World!')​
// 匹配函数定义​
const code2 = "def add (a, b):\n    return a + b";​
const functionRegex = /def\s+(\w+)\s*
​
(.∗?)
:/gm;​
const functions = code2.match(functionRegex);​
if (functions) {​
functions.forEach(func => {​
const name = func.match(/def\s+(\w+)\s*
​
(.∗?)
:/)[1];​
console.log(函数名: ${name});​
// 输出：函数名: add​
});​
}​
// 匹配变量声明​
const code3 = "int num = 10;\nstring text = 'Hello';";​
const variableRegex = /\b\w+\s+\w+\s*=/g;​
const variables = code3.match (variableRegex);​
if (variables) {​
console.log (variables);​
// 输出: ["int num =", "string text ="]​
}​​