掌握正则表达式轻松应对复杂文本编辑任务提升工作效率从入门到精通实用技巧详解让文本处理变得简单高效

威震华夏关云长

引言

正则表达式（Regular Expression，简称regex）是一种强大而灵活的文本处理工具，它使用特定的模式来匹配、查找、替换和验证文本。无论是数据清洗、日志分析、信息提取还是表单验证，正则表达式都能帮助我们以简洁高效的方式完成复杂的文本处理任务。掌握正则表达式不仅能显著提升工作效率，还能让我们在面对各种文本处理挑战时游刃有余。

本文将从基础概念讲起，逐步深入到高级技巧，通过大量实例和代码演示，帮助读者全面掌握正则表达式的使用方法，让文本处理变得简单高效。

正则表达式基础

什么是正则表达式

正则表达式是由普通字符（如字母、数字）和特殊字符（称为”元字符”）组成的文字模式，它描述了一种字符串匹配的模式。正则表达式可以用来检查一个字符串是否含有某种子串、将匹配的子串替换或者从某个串中取出符合某个条件的子串等。

基本语法

在开始学习正则表达式之前，我们需要了解一些基本语法：

1. 字面量字符：普通字符如字母、数字等，它们会匹配自身。例如，正则表达式cat会匹配字符串中的”cat”。
2. 元字符：具有特殊含义的字符，如.、*、+、?、|、(、)、[、]、{、}、^、$、\等。
3. 转义字符：使用反斜杠\来改变字符的原有含义，例如\.匹配点字符本身，而不是任意字符。

字面量字符：普通字符如字母、数字等，它们会匹配自身。例如，正则表达式cat会匹配字符串中的”cat”。

元字符：具有特殊含义的字符，如.、*、+、?、|、(、)、[、]、{、}、^、$、\等。

转义字符：使用反斜杠\来改变字符的原有含义，例如\.匹配点字符本身，而不是任意字符。

正则表达式的创建方式

在大多数编程语言中，有两种创建正则表达式的方式：

1. 字面量方式（JavaScript示例）：

2. const pattern = /pattern/flags;

复制代码

1. 构造函数方式（JavaScript示例）：

2. const pattern = new RegExp('pattern', 'flags');

复制代码

其中，flags是可选的修饰符，常见的有：

• g：全局匹配
• i：不区分大小写
• m：多行模式

常用元字符详解

字符类

字符类用于匹配一组字符中的任意一个。

1. 简单字符类：使用方括号[]定义，例如[abc]匹配”a”、”b”或”c”中的任意一个。

2. const pattern = /[abc]/;
3. console.log(pattern.test('a')); // true
4. console.log(pattern.test('b')); // true
5. console.log(pattern.test('c')); // true
6. console.log(pattern.test('d')); // false

复制代码

1. 范围字符类：使用连字符-表示范围，例如[a-z]匹配任意小写字母，[0-9]匹配任意数字。

2. const pattern = /[a-z]/;
3. console.log(pattern.test('a')); // true
4. console.log(pattern.test('Z')); // false
5. console.log(pattern.test('5')); // false

复制代码

1. 否定字符类：使用^表示否定，例如[^abc]匹配除”a”、”b”、”c”之外的任意字符。

2. const pattern = /[^abc]/;
3. console.log(pattern.test('a')); // false
4. console.log(pattern.test('d')); // true
5. console.log(pattern.test('5')); // true

复制代码

1. 预定义字符类：\d：匹配任意数字，等同于[0-9]\D：匹配任意非数字，等同于[^0-9]\w：匹配任意单词字符（字母、数字、下划线），等同于[a-zA-Z0-9_]\W：匹配任意非单词字符，等同于[^a-zA-Z0-9_]\s：匹配任意空白字符（空格、制表符、换行符等）\S：匹配任意非空白字符
2. \d：匹配任意数字，等同于[0-9]
3. \D：匹配任意非数字，等同于[^0-9]
4. \w：匹配任意单词字符（字母、数字、下划线），等同于[a-zA-Z0-9_]
5. \W：匹配任意非单词字符，等同于[^a-zA-Z0-9_]
6. \s：匹配任意空白字符（空格、制表符、换行符等）
7. \S：匹配任意非空白字符

• \d：匹配任意数字，等同于[0-9]
• \D：匹配任意非数字，等同于[^0-9]
• \w：匹配任意单词字符（字母、数字、下划线），等同于[a-zA-Z0-9_]
• \W：匹配任意非单词字符，等同于[^a-zA-Z0-9_]
• \s：匹配任意空白字符（空格、制表符、换行符等）
• \S：匹配任意非空白字符

2. const digitPattern = /\d/;
3. const wordPattern = /\w/;
4. const spacePattern = /\s/;
6. console.log(digitPattern.test('5')); // true
7. console.log(digitPattern.test('a')); // false
9. console.log(wordPattern.test('a')); // true
10. console.log(wordPattern.test('5')); // true
11. console.log(wordPattern.test('_')); // true
12. console.log(wordPattern.test('@')); // false
14. console.log(spacePattern.test(' ')); // true
15. console.log(spacePattern.test('\t')); // true
16. console.log(spacePattern.test('a')); // false

复制代码

量词

量词用于指定前面的字符或字符类出现的次数。

1. *：匹配前面的元素零次或多次。

2. const pattern = /ab*c/;
3. console.log(pattern.test('ac')); // true
4. console.log(pattern.test('abc')); // true
5. console.log(pattern.test('abbc')); // true
6. console.log(pattern.test('aXc')); // false

复制代码

1. +：匹配前面的元素一次或多次。

2. const pattern = /ab+c/;
3. console.log(pattern.test('ac')); // false
4. console.log(pattern.test('abc')); // true
5. console.log(pattern.test('abbc')); // true
6. console.log(pattern.test('aXc')); // false

复制代码

1. ?：匹配前面的元素零次或一次。

2. const pattern = /ab?c/;
3. console.log(pattern.test('ac')); // true
4. console.log(pattern.test('abc')); // true
5. console.log(pattern.test('abbc')); // false
6. console.log(pattern.test('aXc')); // false

复制代码

1. {n}：匹配前面的元素恰好n次。

2. const pattern = /ab{2}c/;
3. console.log(pattern.test('abc')); // false
4. console.log(pattern.test('abbc')); // true
5. console.log(pattern.test('abbbc')); // false

复制代码

1. {n,}：匹配前面的元素至少n次。

2. const pattern = /ab{2,}c/;
3. console.log(pattern.test('abc')); // false
4. console.log(pattern.test('abbc')); // true
5. console.log(pattern.test('abbbc')); // true

复制代码

1. {n,m}：匹配前面的元素至少n次，至多m次。

2. const pattern = /ab{2,3}c/;
3. console.log(pattern.test('abc')); // false
4. console.log(pattern.test('abbc')); // true
5. console.log(pattern.test('abbbc')); // true
6. console.log(pattern.test('abbbbc')); // false

复制代码

边界匹配

边界匹配用于指定匹配位置，而不是字符。

1. ^：匹配字符串的开始。

2. const pattern = /^abc/;
3. console.log(pattern.test('abc def')); // true
4. console.log(pattern.test('def abc')); // false

复制代码

1. $：匹配字符串的结束。

2. const pattern = /abc$/;
3. console.log(pattern.test('def abc')); // true
4. console.log(pattern.test('abc def')); // false

复制代码

1. \b：匹配单词边界。

2. const pattern = /\bcat\b/;
3. console.log(pattern.test('The cat is cute')); // true
4. console.log(pattern.test('The caterpillar is big')); // false

复制代码

1. \B：匹配非单词边界。

2. const pattern = /\Bcat\B/;
3. console.log(pattern.test('The caterpillar is big')); // true
4. console.log(pattern.test('The cat is cute')); // false

复制代码

分组和引用

1. 捕获组：使用圆括号()创建捕获组，可以将多个元素组合为一个单元，并记住匹配的文本。

2. const pattern = /(\d{3})-(\d{2})-(\d{4})/;
3. const match = pattern.exec('123-45-6789');
4. console.log(match[0]); // '123-45-6789' (完整匹配)
5. console.log(match[1]); // '123' (第一个捕获组)
6. console.log(match[2]); // '45' (第二个捕获组)
7. console.log(match[3]); // '6789' (第三个捕获组)

复制代码

1. 非捕获组：使用(?:)创建非捕获组，它组合元素但不创建捕获组。

2. const pattern = /(?:\d{3})-(\d{2})-(\d{4})/;
3. const match = pattern.exec('123-45-6789');
4. console.log(match[0]); // '123-45-6789' (完整匹配)
5. console.log(match[1]); // '45' (第一个捕获组)
6. console.log(match[2]); // '6789' (第二个捕获组)

复制代码

1. 反向引用：使用\n（n是数字）引用前面的捕获组。

2. const pattern = /(\w+)\s+\1/;
3. console.log(pattern.test('hello hello')); // true
4. console.log(pattern.test('hello world')); // false

复制代码

选择符

使用竖线|表示选择，匹配多个可能的模式之一。

2. const pattern = /cat|dog|bird/;
3. console.log(pattern.test('I have a cat')); // true
4. console.log(pattern.test('I have a dog')); // true
5. console.log(pattern.test('I have a bird')); // true
6. console.log(pattern.test('I have a fish')); // false

复制代码

实用技巧与模式

电子邮件验证

2. const emailPattern = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
3. console.log(emailPattern.test('user@example.com')); // true
4. console.log(emailPattern.test('user.name@example.co.uk')); // true
5. console.log(emailPattern.test('user@example')); // false
6. console.log(emailPattern.test('user.example.com')); // false

复制代码

URL验证

2. const urlPattern = /^(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*\/?$/;
3. console.log(urlPattern.test('https://www.example.com')); // true
4. console.log(urlPattern.test('http://subdomain.example.com/path/page.html')); // true
5. console.log(urlPattern.test('www.example.com')); // true
6. console.log(urlPattern.test('example')); // false

复制代码

电话号码验证

2. // 美国电话号码格式
3. const phonePattern = /^\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}$/;
4. console.log(phonePattern.test('(123) 456-7890')); // true
5. console.log(phonePattern.test('123-456-7890')); // true
6. console.log(phonePattern.test('123.456.7890')); // true
7. console.log(phonePattern.test('1234567890')); // true
8. console.log(phonePattern.test('123-456')); // false

复制代码

日期格式验证

2. // YYYY-MM-DD 格式
3. const datePattern = /^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$/;
4. console.log(datePattern.test('2023-05-15')); // true
5. console.log(datePattern.test('2023-13-15')); // false (无效月份)
6. console.log(datePattern.test('2023-02-30')); // false (无效日期，虽然格式正确)

复制代码

HTML标签提取

2. const html = '<div><p>Paragraph 1</p><p>Paragraph 2</p></div>';
3. const tagPattern = /<(\w+)>/g;
4. let match;
5. while ((match = tagPattern.exec(html)) !== null) {
6.   console.log(match[1]); // 输出: 'div', 'p', 'p'
7. }

复制代码

密码强度验证

2. // 至少8个字符，至少1个大写字母，1个小写字母，1个数字和1个特殊字符
3. const passwordPattern = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/;
4. console.log(passwordPattern.test('Password123!')); // true
5. console.log(passwordPattern.test('password')); // false
6. console.log(passwordPattern.test('PASSWORD123!')); // false
7. console.log(passwordPattern.test('Password123')); // false

复制代码

移除多余空格

2. function removeExtraSpaces(str) {
3.   return str.replace(/\s+/g, ' ').trim();
4. }
5. console.log(removeExtraSpaces('Hello    world!  How   are you?')); // 'Hello world! How are you?'

复制代码

驼峰命名转换

2. // 将连字符或下划线分隔的字符串转换为驼峰命名
3. function toCamelCase(str) {
4.   return str.replace(/[-_\s]+(.)?/g, (match, char) => char ? char.toUpperCase() : '');
5. }
6. console.log(toCamelCase('background-color')); // 'backgroundColor'
7. console.log(toCamelCase('font_size')); // 'fontSize'
8. console.log(toCamelCase('border width')); // 'borderWidth'

复制代码

提取文本中的数字

2. function extractNumbers(str) {
3.   return str.match(/\d+\.?\d*/g) || [];
4. }
5. console.log(extractNumbers('The price is $19.99 and the discount is 5.5%')); // ['19.99', '5.5']
6. console.log(extractNumbers('There are no numbers here')); // []

复制代码

在不同编程语言中的应用

JavaScript

在JavaScript中，正则表达式可以通过RegExp对象或字面量方式创建。

2. // 创建正则表达式
3. const pattern1 = new RegExp('pattern', 'gi');
4. const pattern2 = /pattern/gi;
6. // 常用方法
7. const str = 'The quick brown fox jumps over the lazy dog.';
9. // test() - 测试字符串是否匹配模式
10. console.log(/fox/.test(str)); // true
12. // exec() - 执行匹配，返回结果数组
13. const result = /fox/.exec(str);
14. console.log(result[0]); // 'fox'
15. console.log(result.index); // 16
17. // match() - 返回匹配结果数组
18. console.log(str.match(/the/gi)); // ['The', 'the']
20. // search() - 返回匹配位置的索引
21. console.log(str.search(/fox/)); // 16
23. // replace() - 替换匹配的文本
24. console.log(str.replace(/fox/, 'cat')); // 'The quick brown cat jumps over the lazy dog.'
26. // split() - 使用正则表达式分割字符串
27. console.log(str.split(/\s+/)); // ['The', 'quick', 'brown', 'fox', 'jumps', 'over', 'the', 'lazy', 'dog.']

复制代码

Python

在Python中，使用re模块处理正则表达式。

2. import re
4. # 编译正则表达式
5. pattern = re.compile(r'pattern')
7. # 常用方法
8. text = 'The quick brown fox jumps over the lazy dog.'
10. # match() - 从字符串开始处匹配
11. result = re.match(r'The', text)
12. print(result.group() if result else 'No match')  # 'The'
14. # search() - 在整个字符串中搜索
15. result = re.search(r'fox', text)
16. print(result.group() if result else 'No match')  # 'fox'
18. # findall() - 查找所有匹配
19. print(re.findall(r'the', text, re.IGNORECASE))  # ['The', 'the']
21. # finditer() - 返回迭代器
22. for match in re.finditer(r'\b\w{4}\b', text):
23.     print(f'Found {match.group()} at position {match.start()}')
25. # sub() - 替换匹配的文本
26. print(re.sub(r'fox', 'cat', text))  # 'The quick brown cat jumps over the lazy dog.'
28. # split() - 使用正则表达式分割字符串
29. print(re.split(r'\s+', text))  # ['The', 'quick', 'brown', 'fox', 'jumps', 'over', 'the', 'lazy', 'dog.']

复制代码

Java

在Java中，使用java.util.regex包处理正则表达式。

2. import java.util.regex.*;
4. public class RegexExample {
5.     public static void main(String[] args) {
6.         // 编译正则表达式
7.         Pattern pattern = Pattern.compile("pattern");
8.         
9.         String text = "The quick brown fox jumps over the lazy dog.";
10.         
11.         // matches() - 测试整个字符串是否匹配
12.         System.out.println(text.matches(".*fox.*"));  // true
13.         
14.         // 查找匹配
15.         Matcher matcher = pattern.matcher(text);
16.         
17.         // find() - 查找下一个匹配
18.         if (matcher.find()) {
19.             System.out.println("Found match: " + matcher.group());
20.         }
21.         
22.         // 使用Pattern和Matcher进行复杂匹配
23.         Pattern wordPattern = Pattern.compile("\\b\\w{4}\\b");
24.         Matcher wordMatcher = wordPattern.matcher(text);
25.         
26.         while (wordMatcher.find()) {
27.             System.out.println("Found word: " + wordMatcher.group() +
28.                               " at position " + wordMatcher.start());
29.         }
30.         
31.         // replaceAll() - 替换所有匹配
32.         String replaced = text.replaceAll("fox", "cat");
33.         System.out.println(replaced);  // 'The quick brown cat jumps over the lazy dog.'
34.         
35.         // split() - 使用正则表达式分割字符串
36.         String[] words = text.split("\\s+");
37.         for (String word : words) {
38.             System.out.println(word);
39.         }
40.     }
41. }

复制代码

PHP

在PHP中，使用PCRE（Perl Compatible Regular Expressions）函数处理正则表达式。

2. <?php
3. $text = 'The quick brown fox jumps over the lazy dog.';
5. // preg_match() - 执行匹配
6. if (preg_match('/fox/', $text, $matches)) {
7.     echo "Found match: " . $matches[0] . "\n";  // 'fox'
8. }
10. // preg_match_all() - 查找所有匹配
11. if (preg_match_all('/\b\w{4}\b/', $text, $matches)) {
12.     print_r($matches[0]);  // Array: [0] => 'quick', [1] => 'brown', [2] => 'over', [3] => 'lazy'
13. }
15. // preg_replace() - 替换匹配的文本
16. $replaced = preg_replace('/fox/', 'cat', $text);
17. echo $replaced . "\n";  // 'The quick brown cat jumps over the lazy dog.'
19. // preg_split() - 使用正则表达式分割字符串
20. $words = preg_split('/\s+/', $text);
21. print_r($words);
23. // preg_grep() - 返回匹配模式的数组元素
24. $array = ['apple', 'banana', 'cherry', 'date'];
25. $result = preg_grep('/^a/', $array);
26. print_r($result);  // Array: [0] => 'apple'
27. ?>

复制代码

Ruby

在Ruby中，正则表达式是语言的一部分，使用//或%r{}创建。

2. text = 'The quick brown fox jumps over the lazy dog.'
4. # =~ - 匹配操作符
5. puts text =~ /fox/  # 16 (匹配位置的索引)
7. # match() - 执行匹配
8. match_data = text.match(/fox/)
9. puts match_data[0] if match_data  # 'fox'
11. # scan() - 查找所有匹配
12. words = text.scan(/\b\w{4}\b/)
13. puts words.inspect  # ["quick", "brown", "over", "lazy"]
15. # gsub() - 全局替换
16. replaced = text.gsub(/fox/, 'cat')
17. puts replaced  # 'The quick brown cat jumps over the lazy dog.'
19. # split() - 使用正则表达式分割字符串
20. words = text.split(/\s+/)
21. puts words.inspect  # ["The", "quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog."]

复制代码

实际案例分析

案例1：日志文件分析

假设我们有一个Web服务器日志文件，需要从中提取特定信息。

2. // 示例日志行
3. const logLine = '192.168.1.1 - - [10/Oct/2023:13:55:36 -0700] "GET /index.html HTTP/1.1" 200 2326 "http://www.example.com/start.html" "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"';
5. // 提取IP地址
6. const ipPattern = /^(\d+\.\d+\.\d+\.\d+)/;
7. const ipMatch = logLine.match(ipPattern);
8. console.log('IP Address:', ipMatch ? ipMatch[1] : 'Not found');
10. // 提取时间戳
11. const timestampPattern = /\[(.*?)\]/;
12. const timestampMatch = logLine.match(timestampPattern);
13. console.log('Timestamp:', timestampMatch ? timestampMatch[1] : 'Not found');
15. // 提取请求方法、URL和协议
16. const requestPattern = /"(\w+) (\S+) (\S+)"/;
17. const requestMatch = logLine.match(requestPattern);
18. if (requestMatch) {
19.   console.log('Method:', requestMatch[1]);
20.   console.log('URL:', requestMatch[2]);
21.   console.log('Protocol:', requestMatch[3]);
22. }
24. // 提取状态码
25. const statusPattern = /" (\d{3}) /;
26. const statusMatch = logLine.match(statusPattern);
27. console.log('Status Code:', statusMatch ? statusMatch[1] : 'Not found');
29. // 提取响应大小
30. const sizePattern = /" \d{3} (\d+)/;
31. const sizeMatch = logLine.match(sizePattern);
32. console.log('Response Size:', sizeMatch ? sizeMatch[1] : 'Not found');
34. // 提取引用页面
35. const referrerPattern = /" (\S+) "/;
36. const referrerMatches = logLine.match(referrerPattern);
37. console.log('Referrer:', referrerMatches && referrerMatches.length > 1 ? referrerMatches[1] : 'Not found');
39. // 提取用户代理
40. const userAgentPattern = /"([^"]+)"$/;
41. const userAgentMatch = logLine.match(userAgentPattern);
42. console.log('User Agent:', userAgentMatch ? userAgentMatch[1] : 'Not found');

复制代码

案例2：数据清洗

假设我们有一个包含用户信息的CSV文件，但数据格式不一致，需要清洗。

2. // 原始数据
3. const rawData = [
4.   'John,Doe,john@example.com, (555) 123-4567',
5.   'Jane Smith, jane.smith@test.com, 555.987.6543',
6.   '  Bob Johnson  ,bob@domain.com,,',
7.   'Alice Williams, alice@test.org, 555-234-5678'
8. ];
10. // 清洗函数
11. function cleanUserData(rawData) {
12.   const cleanedData = [];
13.   
14.   for (const line of rawData) {
15.     // 提取姓名（可能包含逗号）
16.     const namePattern = /^([^,]+?),\s*([^,]+?)\s*,/;
17.     const nameMatch = line.match(namePattern);
18.    
19.     let firstName = '';
20.     let lastName = '';
21.    
22.     if (nameMatch) {
23.       firstName = nameMatch[1].trim();
24.       lastName = nameMatch[2].trim();
25.     } else {
26.       // 如果没有逗号分隔的姓名，尝试其他格式
27.       const simpleNamePattern = /^([^,]+?)\s*,/;
28.       const simpleNameMatch = line.match(simpleNamePattern);
29.       if (simpleNameMatch) {
30.         const fullName = simpleNameMatch[1].trim();
31.         const nameParts = fullName.split(/\s+/);
32.         firstName = nameParts[0] || '';
33.         lastName = nameParts.slice(1).join(' ') || '';
34.       }
35.     }
36.    
37.     // 提取电子邮件
38.     const emailPattern = /([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,})/;
39.     const emailMatch = line.match(emailPattern);
40.     const email = emailMatch ? emailMatch[1] : '';
41.    
42.     // 提取电话号码
43.     const phonePattern = /(\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4})/;
44.     const phoneMatch = line.match(phonePattern);
45.     let phone = phoneMatch ? phoneMatch[1] : '';
46.    
47.     // 标准化电话号码格式
48.     if (phone) {
49.       phone = phone.replace(/[^\d]/g, '');
50.       if (phone.length === 10) {
51.         phone = `(${phone.substring(0, 3)}) ${phone.substring(3, 6)}-${phone.substring(6)}`;
52.       }
53.     }
54.    
55.     cleanedData.push({
56.       firstName,
57.       lastName,
58.       email,
59.       phone
60.     });
61.   }
62.   
63.   return cleanedData;
64. }
66. const cleanedData = cleanUserData(rawData);
67. console.log(cleanedData);
68. /*
69. 输出:
70. [
71.   {
72.     firstName: 'John',
73.     lastName: 'Doe',
74.     email: 'john@example.com',
75.     phone: '(555) 123-4567'
76.   },
77.   {
78.     firstName: 'Jane',
79.     lastName: 'Smith',
80.     email: 'jane.smith@test.com',
81.     phone: '(555) 987-6543'
82.   },
83.   {
84.     firstName: 'Bob',
85.     lastName: 'Johnson',
86.     email: 'bob@domain.com',
87.     phone: ''
88.   },
89.   {
90.     firstName: 'Alice',
91.     lastName: 'Williams',
92.     email: 'alice@test.org',
93.     phone: '(555) 234-5678'
94.   }
95. ]
96. */

复制代码

案例3：HTML解析与提取

虽然正则表达式不是解析HTML的最佳工具（HTML解析器更合适），但在某些简单场景下，我们可以使用正则表达式提取特定信息。

2. // 示例HTML
3. const html = `
4. <html>
5. <head>
6.   <title>Sample Page</title>
7.   <meta name="description" content="This is a sample page">
8.   <meta name="keywords" content="sample, page, example">
9. </head>
10. <body>
11.   <h1>Welcome to the Sample Page</h1>
12.   <div class="content">
13.     <p>This is the first paragraph.</p>
14.     <p>This is the second paragraph with a <a href="https://example.com">link</a>.</p>
15.     <img src="image.jpg" alt="Sample image">
16.   </div>
17.   <div class="footer">
18.     <p>Contact us at <a href="mailto:info@example.com">info@example.com</a></p>
19.   </div>
20. </body>
21. </html>
22. `;
24. // 提取页面标题
25. const titlePattern = /<title>(.*?)<\/title>/;
26. const titleMatch = html.match(titlePattern);
27. console.log('Page Title:', titleMatch ? titleMatch[1] : 'Not found');
29. // 提取所有链接
30. const linkPattern = /<a\s+(?:[^>]*?\s+)?href="([^"]*)"/g;
31. const links = [];
32. let linkMatch;
33. while ((linkMatch = linkPattern.exec(html)) !== null) {
34.   links.push(linkMatch[1]);
35. }
36. console.log('Links:', links);
38. // 提取所有图片
39. const imagePattern = /<img\s+(?:[^>]*?\s+)?src="([^"]*)"/g;
40. const images = [];
41. let imageMatch;
42. while ((imageMatch = imagePattern.exec(html)) !== null) {
43.   images.push(imageMatch[1]);
44. }
45. console.log('Images:', images);
47. // 提取meta标签内容
48. const metaPattern = /<meta\s+name="([^"]*)"\s+content="([^"]*)"/g;
49. const metaTags = {};
50. let metaMatch;
51. while ((metaMatch = metaPattern.exec(html)) !== null) {
52.   metaTags[metaMatch[1]] = metaMatch[2];
53. }
54. console.log('Meta Tags:', metaTags);
56. // 提取特定div的内容
57. const contentPattern = /<div class="content">(.*?)<\/div>/s;
58. const contentMatch = html.match(contentPattern);
59. console.log('Content Div:', contentMatch ? contentMatch[1].trim() : 'Not found');
61. // 提取所有段落文本
62. const paragraphPattern = /<p>(.*?)<\/p>/g;
63. const paragraphs = [];
64. let paragraphMatch;
65. while ((paragraphMatch = paragraphPattern.exec(html)) !== null) {
66.   paragraphs.push(paragraphMatch[1]);
67. }
68. console.log('Paragraphs:', paragraphs);

复制代码

案例4：代码重构

假设我们有一段JavaScript代码，需要将其中的函数调用从回调风格转换为Promise风格。

2. // 原始代码（回调风格）
3. const originalCode = `
4. function fetchData(callback) {
5.   setTimeout(() => {
6.     callback(null, { data: 'Some data' });
7.   }, 1000);
8. }
10. function processData(data, callback) {
11.   setTimeout(() => {
12.     callback(null, { processedData: data.data.toUpperCase() });
13.   }, 500);
14. }
16. function saveData(processedData, callback) {
17.   setTimeout(() => {
18.     callback(null, { success: true });
19.   }, 800);
20. }
22. fetchData((err, data) => {
23.   if (err) throw err;
24.   processData(data, (err, processedData) => {
25.     if (err) throw err;
26.     saveData(processedData, (err, result) => {
27.       if (err) throw err;
28.       console.log('Data saved successfully');
29.     });
30.   });
31. });
32. `;
34. // 转换为Promise风格
35. function convertToPromises(code) {
36.   // 1. 转换函数定义
37.   let convertedCode = code.replace(
38.     /function\s+(\w+)\s*\(([^)]*),\s*callback\s*\)\s*{([^}]+)callback\s*\(\s*null,\s*([^)]+)\s*\)\s*;?\s*}/g,
39.     (match, functionName, params, body, result) => {
40.       return `function ${functionName}(${params}) {
41.   return new Promise((resolve, reject) => {
42.     ${body}resolve(${result});
43.   });
44. }`;
45.     }
46.   );
47.   
48.   // 2. 转换函数调用
49.   convertedCode = convertedCode.replace(
50.     /(\w+)\(([^)]+)\)\s*{\s*if\s+\(err\)\s+throw\s+err\s*;\s*([^}]+)\s*}/g,
51.     (match, functionName, params, nextCall) => {
52.       return `${functionName}(${params})
53.   .then(${nextCall})`;
54.     }
55.   );
56.   
57.   // 3. 转换最外层调用
58.   convertedCode = convertedCode.replace(
59.     /(\w+)\(([^)]+)\)\s*=>\s*{\s*if\s+\(err\)\s+throw\s+err\s*;\s*([^}]+)\s*}/g,
60.     (match, functionName, params, nextCall) => {
61.       return `${functionName}(${params})
62.   .then(${nextCall})`;
63.     }
64.   );
65.   
66.   // 4. 转换最后的回调
67.   convertedCode = convertedCode.replace(
68.     /\.then\(\s*([^)]+)\s*=>\s*{\s*if\s+\(err\)\s+throw\s+err\s*;\s*console\.log\(([^)]+)\)\s*;\s*}\s*\)/,
69.     '.then($1 => {\n    console.log($2);\n  })'
70.   );
71.   
72.   return convertedCode;
73. }
75. const convertedCode = convertToPromises(originalCode);
76. console.log(convertedCode);
77. /*
78. 输出:
79. function fetchData() {
80.   return new Promise((resolve, reject) => {
81.     setTimeout(() => {
82.       resolve({ data: 'Some data' });
83.     }, 1000);
84.   });
85. }
87. function processData(data) {
88.   return new Promise((resolve, reject) => {
89.     setTimeout(() => {
90.       resolve({ processedData: data.data.toUpperCase() });
91.     }, 500);
92.   });
93. }
95. function saveData(processedData) {
96.   return new Promise((resolve, reject) => {
97.     setTimeout(() => {
98.       resolve({ success: true });
99.     }, 800);
100.   });
101. }
103. fetchData()
104.   .then(data => processData(data))
105.   .then(processedData => saveData(processedData))
106.   .then(result => {
107.     console.log('Data saved successfully');
108.   });
109. */

复制代码

高级技巧和性能优化

贪婪与懒惰匹配

默认情况下，量词是”贪婪”的，会匹配尽可能多的字符。有时我们需要”懒惰”匹配，匹配尽可能少的字符。

2. const text = '<div>Content 1</div><div>Content 2</div>';
4. // 贪婪匹配
5. const greedyPattern = /<div>.*<\/div>/;
6. console.log(text.match(greedyPattern)[0]); // '<div>Content 1</div><div>Content 2</div>'
8. // 懒惰匹配（使用?）
9. const lazyPattern = /<div>.*?<\/div>/;
10. console.log(text.match(lazyPattern)[0]); // '<div>Content 1</div>'

复制代码

前瞻和后顾

前瞻和后顾用于匹配某些条件满足或不满足的位置，而不消耗字符。

1. 正向前瞻：(?=pattern)- 匹配后面跟着pattern的位置

2. const text = 'I have 100 dollars and 200 euros.';
3. const pattern = /\d+(?=\s+dollars)/;
4. console.log(text.match(pattern)[0]); // '100'

复制代码

1. 负向前瞻：(?!pattern)- 匹配后面不跟着pattern的位置

2. const text = 'I have 100 dollars and 200 euros.';
3. const pattern = /\d+(?!\s+dollars)/;
4. console.log(text.match(pattern)[0]); // '200'

复制代码

1. 正向后顾：(?<=pattern)- 匹配前面是pattern的位置（ES2018支持）

2. const text = 'Price: $100, Total: $200';
3. const pattern = /(?<=\$)\d+/;
4. console.log(text.match(pattern)[0]); // '100'

复制代码

1. 负向后顾：(?<!pattern)- 匹配前面不是pattern的位置（ES2018支持）

2. const text = '100 dollars, 200 euros';
3. const pattern = /(?<!\$)\d+/;
4. console.log(text.match(pattern)[0]); // '100'

复制代码

原子组

原子组(?>...)一旦匹配就不会回溯，可以提高性能并防止某些回溯问题。

2. // 普通组（会回溯）
3. const text = 'abcde';
4. const pattern1 = /(a\w+)(a\w+)/;
5. console.log(pattern1.exec(text)); // null，因为第一个组会匹配整个字符串，然后回溯
7. // 原子组（不会回溯）
8. const pattern2 = /(?>a\w+)(a\w+)/;
9. console.log(pattern2.exec(text)); // null，更快失败

复制代码

回溯控制

回溯是正则表达式引擎尝试匹配的过程，但过多的回溯会导致性能问题。

2. // 可能导致灾难性回溯的模式
3. const text = 'aaaaaaaaaaaaaaaaaaaaaaaaX';
4. const badPattern = /^(a+)+$/;
5. console.log(badPattern.test(text)); // 非常慢
7. // 优化后的模式
8. const goodPattern = /^a+$/;
9. console.log(goodPattern.test(text)); // 快速

复制代码

性能优化技巧

1. 避免嵌套量词：如(a+)*可能导致灾难性回溯。
2. 使用具体字符类：如\d比[0-9]更快，.比\d\D更快。
3. 使用非捕获组：(?:...)比捕获组(...)更快，因为不需要保存匹配。
4. 避免过度回溯：使用原子组或占有量词*+,++,?+,{n,m}+来防止回溯。
5. 锚定模式：使用^和$锚定模式，避免不必要的搜索。
6. 预编译正则表达式：在循环中重复使用时，预编译正则表达式可以提高性能。

避免嵌套量词：如(a+)*可能导致灾难性回溯。

使用具体字符类：如\d比[0-9]更快，.比\d\D更快。

使用非捕获组：(?:...)比捕获组(...)更快，因为不需要保存匹配。

避免过度回溯：使用原子组或占有量词*+,++,?+,{n,m}+来防止回溯。

锚定模式：使用^和$锚定模式，避免不必要的搜索。

预编译正则表达式：在循环中重复使用时，预编译正则表达式可以提高性能。

2. // 不好的做法（每次循环都重新编译）
3. const strings = ['test1', 'test2', 'test3'];
4. for (const str of strings) {
5.   console.log(/test\d/.test(str));
6. }
8. // 好的做法（预编译正则表达式）
9. const pattern = /test\d/;
10. for (const str of strings) {
11.   console.log(pattern.test(str));
12. }

复制代码

调试正则表达式

调试复杂的正则表达式可能很困难，以下是一些技巧：

1. 使用在线工具：如Regex101、Debuggex等，可以可视化正则表达式的匹配过程。
2. 分解复杂模式：将复杂的正则表达式分解为多个简单部分，分别测试。
3. 添加注释：使用x标志（在某些语言中）可以添加注释和空白，使正则表达式更易读。

使用在线工具：如Regex101、Debuggex等，可以可视化正则表达式的匹配过程。

分解复杂模式：将复杂的正则表达式分解为多个简单部分，分别测试。

添加注释：使用x标志（在某些语言中）可以添加注释和空白，使正则表达式更易读。

2. // 使用x标志（JavaScript不支持，但其他语言如PHP、Python支持）
3. // 这里仅作示例
4. const pattern = /
5.   \b      # 单词边界
6.   (\w+)   # 捕获单词
7.   \s      # 空白字符
8.   (\w+)   # 捕获另一个单词
9.   \b      # 单词边界
10. /x;

复制代码

1. 使用命名捕获组：给捕获组命名，使代码更易读和维护。

2. const text = 'John Doe, age: 30';
3. const pattern = /(?<name>\w+\s+\w+),\s+age:\s+(?<age>\d+)/;
4. const match = text.match(pattern);
5. if (match) {
6.   console.log('Name:', match.groups.name); // 'John Doe'
7.   console.log('Age:', match.groups.age);   // '30'
8. }

复制代码

总结与进阶学习资源

正则表达式是一种强大而灵活的文本处理工具，掌握它可以显著提高文本处理的效率和准确性。从基本的字符匹配到复杂的模式提取，正则表达式在各种编程语言和文本处理场景中都有广泛应用。

关键要点回顾

1. 基础语法：掌握字面量字符、元字符、字符类、量词和边界匹配等基本概念。
2. 高级特性：理解捕获组、非捕获组、反向引用、前瞻和后顾等高级特性。
3. 实用模式：熟悉常见的正则表达式模式，如电子邮件验证、URL验证、电话号码验证等。
4. 性能优化：了解如何编写高效的正则表达式，避免灾难性回溯和性能问题。
5. 多语言应用：掌握正则表达式在不同编程语言中的使用方法和差异。

基础语法：掌握字面量字符、元字符、字符类、量词和边界匹配等基本概念。

高级特性：理解捕获组、非捕获组、反向引用、前瞻和后顾等高级特性。

实用模式：熟悉常见的正则表达式模式，如电子邮件验证、URL验证、电话号码验证等。

性能优化：了解如何编写高效的正则表达式，避免灾难性回溯和性能问题。

多语言应用：掌握正则表达式在不同编程语言中的使用方法和差异。

进阶学习资源

1. 书籍：《精通正则表达式》（Mastering Regular Expressions）- Jeffrey E.F. Friedl《正则表达式必知必会》（Regular Expressions Cookbook）- Jan Goyvaerts, Steven Levithan
2. 《精通正则表达式》（Mastering Regular Expressions）- Jeffrey E.F. Friedl
3. 《正则表达式必知必会》（Regular Expressions Cookbook）- Jan Goyvaerts, Steven Levithan
4. 在线工具：Regex101 (https://regex101.com/) - 正则表达式测试和调试工具Debuggex (https://www.debuggex.com/) - 可视化正则表达式调试工具RegExr (https://regexr.com/) - 学习、构建和测试正则表达式
5. Regex101 (https://regex101.com/) - 正则表达式测试和调试工具
6. Debuggex (https://www.debuggex.com/) - 可视化正则表达式调试工具
7. RegExr (https://regexr.com/) - 学习、构建和测试正则表达式
8. 教程和文档：MDN Web Docs - JavaScript正则表达式指南Python官方文档 - re模块文档Java官方文档 - Pattern类文档
9. MDN Web Docs - JavaScript正则表达式指南
10. Python官方文档 - re模块文档
11. Java官方文档 - Pattern类文档
12. 练习网站：RegexOne (https://regexone.com/) - 交互式正则表达式教程Regex Crossword (https://regexcrossword.com/) - 通过解谜学习正则表达式
13. RegexOne (https://regexone.com/) - 交互式正则表达式教程
14. Regex Crossword (https://regexcrossword.com/) - 通过解谜学习正则表达式

书籍：

• 《精通正则表达式》（Mastering Regular Expressions）- Jeffrey E.F. Friedl
• 《正则表达式必知必会》（Regular Expressions Cookbook）- Jan Goyvaerts, Steven Levithan

在线工具：

• Regex101 (https://regex101.com/) - 正则表达式测试和调试工具
• Debuggex (https://www.debuggex.com/) - 可视化正则表达式调试工具
• RegExr (https://regexr.com/) - 学习、构建和测试正则表达式

教程和文档：

• MDN Web Docs - JavaScript正则表达式指南
• Python官方文档 - re模块文档
• Java官方文档 - Pattern类文档

练习网站：

• RegexOne (https://regexone.com/) - 交互式正则表达式教程
• Regex Crossword (https://regexcrossword.com/) - 通过解谜学习正则表达式

通过不断练习和应用，你将能够熟练掌握正则表达式，轻松应对各种复杂的文本处理任务，显著提升工作效率。记住，正则表达式是一门需要实践才能掌握的技能，多写多用才能真正精通。