Go语言爬虫系列教程4：使用正则表达式解析HTML内容
正则表达式（Regular Expression，简称RegEx）是处理文本数据的利器。在网络爬虫中，我们经常需要从HTML页面中提取特定的信息，正则表达式就像一个智能的"文本筛子"，能够精确地找到我们需要的内容。
想象你在一本厚厚的电话簿中找所有以"138"开头的手机号码。如果用人工查找会很累，但如果有一个魔法筛子，你告诉它"找所有138开头的11位数字"，它就能快速找出所有符合条件的号码。正则表达式就是这样的"魔法筛子"。
一、简单演示
package main
import (
"fmt"
"regexp"
)
// 演示基础正则表达式语法
func main(
) {
// 1\. 字面量匹配（最简单的情况）
text1 := "Hello World"
pattern1 := "Hello"
matched, _ := regexp.MatchString(pattern1, text1)
fmt.Printf("文本: %s\n模式: %s\n匹配结果: %t\n\n"
, text1, pattern1, matched)输出结果：
文本: Hello World
模式: Hello
匹配结果: true这个代码演示的是最简单的字面量匹配
二、基础语法
正则表达式由两种基本元素组成：
- 字面量：直接匹配文本中的字符
- 元字符：具有特殊含义的字符，用于描述模式
2.1 字面量匹配 - 最简单的精确匹配
text1 := "Hello World"
pattern1 := "Hello"
matched, _ := regexp.MatchString(pattern1, text1)
fmt.Printf("文本: %s\n模式: %s\n匹配结果: %t\n\n"
, text1, pattern1, matched)运行结果：
文本: Hello World
模式: Hello
匹配结果: true作用：直接匹配指定的字符串，不使用任何特殊符号
2.2 点号(.) - 万能字符匹配器
text2 := "cat bat hat"
pattern2 := ".at" // 匹配任意字符+at
re2 := regexp.MustCompile(pattern2)
matches2 := re2.FindAllString(text2, -1
)
fmt.Printf("文本: %s\n模式: %s (点号匹配任意字符)\n匹配结果: %v\n\n"
, text2, pattern2, matches2)运行结果：
文本: cat bat hat
模式: .at (点号匹配任意字符)
匹配结果: [cat bat hat]作用：点号.是一个特殊字符，可以匹配除换行符外的任意单个字符
.at匹配"任意字符+at"的模式- 在文本中找到了：
cat(c+at)、bat(b+at)、hat(h+at) - 所有三个单词都符合模式
2.3 星号(*) - 贪婪的重复匹配
text3 := "goooooogle"
pattern3 := "go*gle" // g + 0个或多个o + gle
matched3, _ := regexp.MatchString(pattern3, text3)
fmt.Printf("文本: %s\n模式: %s (星号表示0次或多次)\n匹配结果: %t\n\n"
, text3, pattern3, matched3)运行结果：
文本: goooooogle
模式: go*gle (星号表示0次或多次)
匹配结果: true作用：星号*表示前面的字符可以出现0次或多次
go*gle意思是：g + (0个或多个o) + gle- "goooooogle"中有g + 5个o + gle，符合模式
- 这个模式也能匹配"ggle"(0个o)、“google”(2个o)等
2.4 加号(+) - 至少一次的重复匹配
text4 := "ggle google gooogle"
pattern4 := "go+gle" // g + 1个或多个o + gle
re4 := regexp.MustCompile(pattern4)
matches4 := re4.FindAllString(text4, -1
)
fmt.Printf("文本: %s\n模式: %s (加号表示1次或多次)\n匹配结果: %v\n\n"
, text4, pattern4, matches4)运行结果：
文本: ggle google gooogle
模式: go+gle (加号表示1次或多次)
匹配结果: [google gooogle]作用：加号+表示前面的字符必须出现1次或多次
go+gle意思是：g + (1个或多个o) + gle- "ggle"不匹配（没有o）
- "google"匹配（2个o）
- "gooogle"匹配（3个o）
2.5 问号(?) - 可选字符匹配
text5 := "color colour"
pattern5 := "colou?r" // colou + 0个或1个r
re5 := regexp.MustCompile(pattern5)
matches5 := re5.FindAllString(text5, -1
)
fmt.Printf("文本: %s\n模式: %s (问号表示0次或1次)\n匹配结果: %v\n\n"
, text5, pattern5, matches5)运行结果：
文本: color colour
模式: colou?r (问号表示0次或1次)
匹配结果: [color colour]作用：问号?表示前面的字符可以出现0次或1次（可选）
colou?r意思是：colou + (0个或1个u) + r- "color"匹配（0个u）
- "colour"匹配（1个u）
2.6 方括号[] - 字符集合匹配
text1 := "cat bat rat mat"
pattern1 := "[cbr]at" // 匹配cat、bat或rat运行结果：
文本: cat bat rat mat
模式: [cbr]at ([cbr]匹配c、b或r中的一个)
匹配结果: [cat bat rat]作用：方括号[]定义一个字符集合，匹配其中任意一个字符
[cbr]at表示：(c或b或r) + at- 匹配到：
cat、bat、rat - 不匹配：
mat（因为m不在[cbr]中）
2.7 范围表示法 - 连续字符的简写
text2 := "a1 b2 c3 d4"
pattern2 := "[a-c][1-3]" // 匹配a-c中的一个字母 + 1-3中的一个数字运行结果：
文本: a1 b2 c3 d4
模式: [a-c][1-3] ([a-c]匹配a到c，[1-3]匹配1到3)
匹配结果: [a1 b2 c3]作用：用连字符-表示字符范围，避免逐个列举
[a-c]等同于[abc][1-3]等同于[123]- 匹配到：
a1、b2、c3 - 不匹配：
d4（d不在a-c范围，4不在1-3范围）
常用范围：
[a-z]：小写字母[A-Z]：大写字母[0-9]：数字[a-zA-Z0-9]：字母和数字
2.8 否定字符类[^] - 排除匹配
text3 := "cat bat rat mat"
pattern3 := "[^m]at" // 匹配不是m开头的at运行结果：
文本: cat bat rat mat
模式: [^m]at ([^m]匹配除了m以外的字符)
匹配结果: [cat bat rat]作用：^在方括号内表示否定，匹配除了指定字符外的任意字符
[^m]at表示：(除了m以外的任意字符) + at- 匹配到：
cat、bat、rat - 不匹配：
mat（因为开头是m）
2.9 预定义字符类 - 常用模式的简写
text4 := "abc 123 XYZ !@#"
patterns :=
map[string]string{
`\d`: "匹配数字 [0-9]"
,
`\w`: "匹配单词字符 [a-zA-Z0-9_]"
,
`\s`: "匹配空白字符"
,
`\D`: "匹配非数字字符"
,
`\W`: "匹配非单词字符"
,
`\S`: "匹配非空白字符"
,
}2.10 精确量词{n} - 确切次数匹配
text1 := "1 12 123 1234"
pattern1 := `\d{3}` // 匹配恰好3个数字运行结果：
文本: 1 12 123 1234
模式: \d{3} (恰好3个数字)
匹配结果: [123 123]作用：{n}表示前面的字符或模式必须出现恰好n次
\d{3}匹配恰好3个连续数字- 在"1234"中找到"123"（前3位）
- 注意：会优先匹配较长的数字串中的前3位
2.11 范围量词{n,m} - 区间次数匹配
text2 := "1 12 123 1234 12345"
pattern2 := `\d{2,4}` // 匹配2到4个数字运行结果：
文本: 1 12 123 1234 12345
模式: \d{2,4} (2到4个数字)
匹配结果: [12 123 1234 1234]作用：{n,m}表示前面的字符出现n到m次（包含n和m）
- 匹配2-4个连续数字
- "1"不匹配（只有1个数字）
- “12345"中匹配前4个"1234”（贪婪匹配，取最大值）
2.12 最少量词{n,} - 至少n次匹配
text3 := "a aa aaa aaaa"
pattern3 := `a{3,}` // 匹配3个或更多的a运行结果：
文本: a aa aaa aaaa
模式: a{3,} (3个或更多的a)
匹配结果: [aaa aaaa]作用：{n,}表示前面的字符至少出现n次，没有上限
- "a"和"aa"不匹配（少于3个）
- "aaa"和"aaaa"匹配（3个或更多）
2.13 行边界^和$ - 位置匹配
text4 := "hello world\nworld hello\nhello"
// 匹配行开始的hello
pattern4a := `^hello`
// 运行结果: [hello hello]
// 匹配行结束的hello
pattern4b := `hello$`
// 运行结果: [hello hello]作用：
^：匹配行的开始位置 ，^hello匹配每行开头的"hello"$：匹配行的结束位置 ，hello$匹配每行结尾的"hello"
2.14 单词边界\b - 完整单词匹配
text5 := "cat catch catch22"
pattern5 := `\bcat\b` // 完整的单词cat运行结果：
文本: cat catch catch22
模式: \bcat\b (完整单词cat)
匹配结果: [cat]作用：\b表示单词边界，确保匹配完整的单词
\bcat\b只匹配作为独立单词的"cat"- "catch"中的"cat"不匹配（后面还有字母ch）
- "catch22"中的"cat"也不匹配
三、regexp包常用方法介绍
3.1 regexp包的核心结构
package main
import (
"fmt"
"regexp"
"strings"
)
// RegexpDemo 正则表达式演示结构体
type RegexpDemo struct {
name string
pattern string
text string
}
// 演示regexp包的主要方法
func demonstrateRegexpPackage(
) {
fmt.Println("=== regexp包方法演示 ==="
)
// 1\. 编译正则表达式的两种方式
fmt.Println("1\. 编译正则表达式:"
)
// 方式1：Compile - 返回错误
pattern := `\d+`
re1, err := regexp.Compile(pattern)
if err != nil {
fmt.Printf("编译错误: %v\n"
, err)
return
}
fmt.Printf("Compile成功: %v\n"
, re1)
// 方式2：MustCompile - 编译失败会panic（适合确定正确的模式）
re2 := regexp.MustCompile(pattern)
fmt.Printf("MustCompile成功: %v\n\n"
, re2)
// 2\. 基本匹配方法
text := "我的电话是138-1234-5678，朋友的是139-8765-4321"
phonePattern := `1[3-9]\d-\d{4}-\d{4}`
phoneRe := regexp.MustCompile(phonePattern)
// 2.1 MatchString - 检查是否匹配
fmt.Println("2\. 基本匹配方法:"
)
matched := phoneRe.MatchString(text)
fmt.Printf("MatchString: %t\n"
, matched)
// 2.2 FindString - 找到第一个匹配
firstMatch := phoneRe.FindString(text)
fmt.Printf("FindString: %s\n"
, firstMatch)
// 2.3 FindAllString - 找到所有匹配
allMatches := phoneRe.FindAllString(text, -1
) // -1表示找到所有
fmt.Printf("FindAllString: %v\n"
, allMatches)
// 2.4 FindStringIndex - 找到第一个匹配的位置
firstIndex := phoneRe.FindStringIndex(text)
fmt.Printf("FindStringIndex: %v\n"
, firstIndex)
if firstIndex != nil {
fmt.Printf("第一个匹配的内容: %s\n"
, text[firstIndex[0]:firstIndex[1]]
)
}
// 2.5 FindAllStringIndex - 找到所有匹配的位置
allIndexes := phoneRe.FindAllStringIndex(text, -1
)
fmt.Printf("FindAllStringIndex: %v\n\n"
, allIndexes)
}3.2 分组和捕获
// 演示分组和捕获
func demonstrateGroupsAndCapture(
) {
fmt.Println("=== 分组和捕获演示 ==="
)
// 1\. 基本分组()
text := "张三的邮箱是zhangsan@example.com，李四的邮箱是lisi@gmail.com"
// 使用分组捕获邮箱的用户名和域名
emailPattern := `(\w+)@(\w+\.\w+)`
emailRe := regexp.MustCompile(emailPattern)
// FindStringSubmatch - 返回第一个匹配及其分组
firstSubmatch := emailRe.FindStringSubmatch(text)
fmt.Printf("邮箱分组匹配:\n"
)
if len(firstSubmatch) >
0 {
fmt.Printf("完整匹配: %s\n"
, firstSubmatch[0]
)
fmt.Printf("用户名: %s\n"
, firstSubmatch[1]
)
fmt.Printf("域名: %s\n"
, firstSubmatch[2]
)
}
fmt.Println(
)
// FindAllStringSubmatch - 返回所有匹配及其分组
allSubmatches := emailRe.FindAllStringSubmatch(text, -1
)
fmt.Printf("所有邮箱分组匹配:\n"
)
for i, submatch :=
range allSubmatches {
fmt.Printf("第%d个邮箱:\n"
, i+1
)
fmt.Printf(" 完整匹配: %s\n"
, submatch[0]
)
fmt.Printf(" 用户名: %s\n"
, submatch[1]
)
fmt.Printf(" 域名: %s\n"
, submatch[2]
)
}
fmt.Println(
)
// 2\. 命名分组(?P<name>pattern)
urlText := "访问我们的网站：https://www.example.com:8080/path?query=value"
urlPattern := `(?P<protocol>https?)://(?P<domain>[\w.]+):?(?P<port>\d*)/(?P<path>[\w/]*)\??(?P<query>.*)`
urlRe := regexp.MustCompile(urlPattern)
matches := urlRe.FindStringSubmatch(urlText)
names := urlRe.SubexpNames(
)
fmt.Printf("URL命名分组匹配:\n"
)
for i, name :=
range names {
if i != 0 && name != "" && i <
len(matches) {
fmt.Printf("%s: %s\n"
, name, matches[i]
)
}
}
fmt.Println(
)
// 3\. 非捕获分组(?:pattern) - 分组但不捕获
text3 := "电话: 010-12345678 或 021-87654321"
// 使用非捕获分组匹配区号格式，但只捕获完整号码
phonePattern2 := `(?:010|021)-(\d{8})`
phoneRe2 := regexp.MustCompile(phonePattern2)
allPhoneMatches := phoneRe2.FindAllStringSubmatch(text3, -1
)
fmt.Printf("非捕获分组示例:\n"
)
for i, match :=
range allPhoneMatches {
fmt.Printf("第%d个匹配:\n"
, i+1
)
fmt.Printf(" 完整匹配: %s\n"
, match[0]
)
fmt.Printf(" 后8位号码: %s\n"
, match[1]
)
}
}3.3 替换操作
// 演示替换操作
func demonstrateReplacement(
) {
fmt.Println("=== 替换操作演示 ==="
)
// 1\. ReplaceAllString - 简单替换
text1 := "今天是2023年12月25日，明天是2023年12月26日"
datePattern := `\d{4}年\d{1,2}月\d{1,2}日`
dateRe := regexp.MustCompile(datePattern)
replaced1 := dateRe.ReplaceAllString(text1, "[日期]"
)
fmt.Printf("原文: %s\n"
, text1)
fmt.Printf("替换后: %s\n\n"
, replaced1)
// 2\. ReplaceAllStringFunc - 使用函数替换
text2 := "苹果5元，香蕉3元，橙子8元"
pricePattern := `(\w+)(\d+)元`
priceRe := regexp.MustCompile(pricePattern)
replaced2 := priceRe.ReplaceAllStringFunc(text2,
func(match string
) string {
// 可以在这里做复杂的处理
return "[商品价格]"
}
)
fmt.Printf("原文: %s\n"
, text2)
fmt.Printf("函数替换后: %s\n\n"
, replaced2)
// 3\. 使用分组进行替换
text3 := "联系人：张三，电话：138-1234-5678"
contactPattern := `联系人：(\w+)，电话：([\d-]+)`
contactRe := regexp.MustCompile(contactPattern)
// $1, $2引用捕获的分组
replaced3 := contactRe.ReplaceAllString(text3, "姓名: $1, 手机: $2"
)
fmt.Printf("原文: %s\n"
, text3)
fmt.Printf("分组替换后: %s\n\n"
, replaced3)
// 4\. 复杂的分组替换 - 格式化电话号码
text4 := "电话号码：13812345678, 15987654321, 18611112222"
phonePattern3 := `(\d{3})(\d{4})(\d{4})`
phoneRe3 := regexp.MustCompile(phonePattern3)
formatted := phoneRe3.ReplaceAllString(text4, "$1-$2-$3"
)
fmt.Printf("原文: %s\n"
, text4)
fmt.Printf("格式化后: %s\n"
, formatted)
}3.4 常用方法表
| 方法名 | 功能描述 | 性能建议 |
|---|---|---|
MatchString | 直接判断是否匹配，内部自动编译正则表达式 | 适用于单次匹配，频繁调用需预编译 |
Compile / MustCompile | 预编译正则表达式，返回可重复使用的*Regexp对象 | 必须用于高频匹配场景 |
FindString / FindAllString | 查找匹配的子串，不捕获分组内容 | 简单查找场景 |
FindStringSubmatch / FindAllStringSubmatch | 查找匹配的子串并捕获分组内容 | 需要提取分组时使用 |
ReplaceAllString / ReplaceAllStringFunc | 替换匹配的子串，支持静态替换或函数式动态替换 | 替换场景通用方法 |
Split | 按正则表达式分割字符串 | 替代strings.Split处理复杂分隔符 |
标志位(?i)(?s)(?m) | 修改正则表达式匹配规则（不区分大小写、点号匹配换行、多行模式） | 复杂文本匹配时使用 |
四、常见的正则表达式
以下是一些常见的正则表达式示例，用于匹配不同类型的文本。
注意：这些示例是基于常见的文本格式，可能需要根据实际需求进行调整。
1. 匹配邮箱
^[a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{
2
,
}$2. 匹配手机号（以中国大陆为例）
^1[3-9][0-9]{
9
}$3. 匹配身份证号（中国18位）
^\d{
6
}(18|19|20
)?\d{
2
}(0[1-9]|1[0-2]
)(0[1-9]|[12][0-9]|3[01]
)\d{
3
}(\d|X|x)$4. 匹配URL
^https?://[^\s/$.?#].[^\s]*$5. 匹配IP地址（IPv4）
^(?:[0-9]{
1
,3
}\.
){
3
}[0-9]{
1
,3
}$⚠️注意：上面的正则没有严格验证0-255，可用下面更严格的版本：
^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$6. 匹配数字字符串
^\d+$7. 匹配仅包含字母（不区分大小写）
^[a-zA-Z]+$8. 匹配密码复杂性（8-20位，包含字母和数字）
^(?=.*[A-Za-z]
)(?=.*\d)[A-Za-z\d]{
8
,20
}$9. 匹配日期（YYYY-MM-DD）
^\d{
4
}-(0[1-9]|1[0-2]
)-(0[1-9]|[12]\d|3[01]
)$10. 匹配正整数
^[1-9]\d*$11. 匹配负整数
^-[1-9]\d*$12. 匹配浮点数（正负均可）
^-?\d+(\.\d+
)?$13. 匹配由字母、数字和下划线组成的字符串
^\w+$14. 匹配中文字符
[\p{
Han
}]+需要 go 1.13+ 支持，更通用。
15. 匹配邮政编码（中国6位）
^\d{
6
}$16. 匹配含有 HTML 标签的文本
<
([a-zA-Z][a-zA-Z0-9]*
)\b[^>
]*>
(.*?)<
/\1>17. 匹配空白行
^\s*$18. 匹配 MAC 地址
^([0-9A-Fa-f]{
2
}[:-]
){
5
}([0-9A-Fa-f]{
2
}
)$19. 匹配单行注释
^//.*$20. 匹配多行注释
(?s)/\*.*?\*/4厄3
五、实战演示
package main
import (
"fmt"
"regexp"
"strings"
)
// Link 链接结构体
type Link struct {
URL string
Text string
}
// String 返回链接的字符串表示
func (l Link) String(
) string {
return fmt.Sprintf("URL: %s, 文本: %s"
, l.URL, l.Text)
}
// HTMLDataExtractor HTML数据提取器
type HTMLDataExtractor struct {
patterns map[string]*regexp.Regexp
}
// NewHTMLDataExtractor 创建HTML数据提取器，带错误处理
func NewHTMLDataExtractor(
) (*HTMLDataExtractor, error
) {
extractor := &HTMLDataExtractor{
patterns: make(
map[string]*regexp.Regexp)
,
}
// 编译正则表达式并处理错误
if err := extractor.compilePatterns(
)
; err != nil {
return nil
, fmt.Errorf("编译正则表达式失败: %w"
, err)
}
return extractor, nil
}
// compilePatterns 编译常用的正则表达式模式，带错误处理
func (e *HTMLDataExtractor) compilePatterns(
) error {
patterns :=
map[string]string{
"title": `<title[^>]*>([^<]+)</title>`
,
// 优化meta标签匹配，支持更灵活的属性顺序和引号
"meta_desc": `(?i)<meta\s+(?:[^>]*\s+)?name\s*=\s*["']description["'][^>]*\s+content\s*=\s*["']([^"']*)["']`
,
// 优化链接匹配，支持单引号/双引号和更多属性格式
"links": `<a[^>]*href\s*=\s*(?:["'])([^"']+)["'][^>]*>([^<]*)</a>`
,
"images": `<img[^>]*src\s*=\s*(?:["'])([^"']+)["'][^>]*>`
,
"emails": `[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}`
,
"phones": `1[3-9]\d{9}`
,
"prices": `¥\s*(\d+(?:\.\d{2})?)`
,
// 修复：使用十六进制范围表示中文汉字
"chinese_text": `[\x{4e00}-\x{9fa5}]+`
,
}
for name, pattern :=
range patterns {
re, err := regexp.Compile(pattern)
if err != nil {
return fmt.Errorf("编译模式 %s 失败: %w"
, name, err)
}
e.patterns[name] = re
}
return nil
}
// ExtractTitle 提取标题
func (e *HTMLDataExtractor) ExtractTitle(html string
) string {
matches := e.patterns["title"].FindStringSubmatch(html)
if len(matches) >
1 {
return strings.TrimSpace(matches[1]
)
}
return ""
}
// ExtractMetaDescription 提取meta描述
func (e *HTMLDataExtractor) ExtractMetaDescription(html string
) string {
matches := e.patterns["meta_desc"].FindStringSubmatch(html)
if len(matches) >
1 {
return strings.TrimSpace(matches[1]
)
}
return ""
}
// ExtractLinks 提取所有链接
func (e *HTMLDataExtractor) ExtractLinks(html string
) []Link {
matches := e.patterns["links"].FindAllStringSubmatch(html, -1
)
var links []Link
for _
, match :=
range matches {
if len(match) >
2 {
links = append(links, Link{
URL: strings.TrimSpace(match[1]
)
,
Text: strings.TrimSpace(match[2]
)
,
}
)
}
}
return links
}
// ExtractImages 提取所有图片URL
func (e *HTMLDataExtractor) ExtractImages(html string
) []string {
matches := e.patterns["images"].FindAllStringSubmatch(html, -1
)
var images []string
for _
, match :=
range matches {
if len(match) >
1 {
images = append(images, strings.TrimSpace(match[1]
)
)
}
}
return images
}
// ExtractEmails 提取所有邮箱地址
func (e *HTMLDataExtractor) ExtractEmails(html string
) []string {
return e.patterns["emails"].FindAllString(html, -1
)
}
// ExtractPhones 提取所有手机号码
func (e *HTMLDataExtractor) ExtractPhones(html string
) []string {
return e.patterns["phones"].FindAllString(html, -1
)
}
// ExtractPrices 提取所有价格
func (e *HTMLDataExtractor) ExtractPrices(html string
) []string {
matches := e.patterns["prices"].FindAllStringSubmatch(html, -1
)
var prices []string
for _
, match :=
range matches {
if len(match) >
1 {
prices = append(prices, match[1]
)
}
}
return prices
}
// ExtractChineseText 提取中文文本
func (e *HTMLDataExtractor) ExtractChineseText(html string
) []string {
return e.patterns["chinese_text"].FindAllString(html, -1
)
}
// 使用示例
func main(
) {
fmt.Println("=== HTML数据提取演示 ===\n"
)
// 示例HTML内容
sampleHTML := `
<!DOCTYPE html>
<html>
<head>
<title>购物网站 - 最优质的商品</title>
<meta NAME="description" content='这是一个专业的购物网站，提供优质商品和服务'>
</head>
<body>
<h1>欢迎来到我们的商店</h1>
<p>联系我们：info@example.com 或者 support@shop.com</p>
<p>客服电话：13812345678，18611112222</p>
<div class="products">
<h2>热门商品</h2>
<div class="product">
<img src='/images/phone.jpg' alt='手机'>
<h3>智能手机</h3>
<p>价格：¥2999.00</p>
<a href='/product/phone' class='btn'>查看详情</a>
</div>
<div class="product">
<img src=/images/laptop.jpg alt=笔记本>
<h3>笔记本电脑</h3>
<p>价格：¥5999.99</p>
<a href='/product/laptop'>立即购买</a>
</div>
</div>
<footer>
<p>更多信息请访问 <a href='https://www.example.com'>我们的官网</a></p>
</footer>
</body>
</html>
`
// 创建提取器并处理错误
extractor, err := NewHTMLDataExtractor(
)
if err != nil {
fmt.Printf("错误: %s\n"
, err)
return
}
// 提取各种数据
fmt.Println("? 页面标题:"
)
fmt.Printf(" %s\n\n"
, extractor.ExtractTitle(sampleHTML)
)
fmt.Println("? 页面描述:"
)
fmt.Printf(" %s\n\n"
, extractor.ExtractMetaDescription(sampleHTML)
)
fmt.Println("? 邮箱地址:"
)
emails := extractor.ExtractEmails(sampleHTML)
for i, email :=
range emails {
fmt.Printf(" %d. %s\n"
, i+1
, email)
}
fmt.Println(
)
fmt.Println("? 手机号码:"
)
phones := extractor.ExtractPhones(sampleHTML)
for i, phone :=
range phones {
fmt.Printf(" %d. %s\n"
, i+1
, phone)
}
fmt.Println(
)
fmt.Println("? 链接:"
)
links := extractor.ExtractLinks(sampleHTML)
for i, link :=
range links {
fmt.Printf(" %d. %s\n"
, i+1
, link)
}
fmt.Println(
)
fmt.Println("?️ 图片:"
)
images := extractor.ExtractImages(sampleHTML)
for i, img :=
range images {
fmt.Printf(" %d. %s\n"
, i+1
, img)
}
fmt.Println(
)
fmt.Println("? 价格:"
)
prices := extractor.ExtractPrices(sampleHTML)
for i, price :=
range prices {
fmt.Printf(" %d. ¥%s\n"
, i+1
, price)
}
fmt.Println(
)
fmt.Println("中文文本片段:"
)
chineseTexts := extractor.ExtractChineseText(sampleHTML)
for i, text :=
range chineseTexts {
if len(text) >
2 {
// 过滤短文本
fmt.Printf(" %d. %s\n"
, i+1
, text)
}
}
}记住：正则表达式是一把双刃剑，用好了事半功倍，用错了可能带来性能问题。关键是要在合适的场景使用合适的工具！
浙公网安备 33010602011771号