在 Golang 中，

1. regexp

复制代码

包用于处理正则表达式操作。以下是一些常见的正则表达式操作的代码示例：

1. 简单匹配（MatchString）

用于检查字符串是否匹配某个正则表达式。

1. package main
   
2. 
   
3. import (
   
4.         "fmt"
   
5.         "regexp"
   
6. )
   
7. 
   
8. func main() {
   
9.         pattern := `^hello`
   
10.         text := "hello world"
    
11. 
    
12.         match, _ := regexp.MatchString(pattern, text)
    
13.         fmt.Println("Matched:", match) // 输出: Matched: true
    
14. }

复制代码

2. 编译正则表达式（Compile 和 MustCompile）

通过

1. regexp.Compile

复制代码

或

1. regexp.MustCompile

复制代码

编译正则表达式以提高性能。

1. package main
   
2. 
   
3. import (
   
4.         "fmt"
   
5.         "regexp"
   
6. )
   
7. 
   
8. func main() {
   
9.         // Compile 返回 error，如果正则无效
   
10.         re, err := regexp.Compile(`\d+`)
    
11.         if err != nil {
    
12.                 fmt.Println("Error compiling regex:", err)
    
13.                 return
    
14.         }
    
15. 
    
16.         text := "Order number 12345"
    
17.         fmt.Println("Matched:", re.MatchString(text)) // 输出: Matched: true
    
18. 
    
19.         // MustCompile 会 panic，如果正则无效
    
20.         re2 := regexp.MustCompile(`\d+`)
    
21.         fmt.Println("Matched:", re2.MatchString(text)) // 输出: Matched: true
    
22. }

复制代码

3. 查找字符串中的第一个匹配项（FindString 和 FindStringSubmatch）

• 1. FindString

  复制代码
  返回第一个匹配的字符串。
  
• 1. FindStringSubmatch

  复制代码
  返回第一个匹配的字符串以及捕获的子组。
  

1. package main
   
2. 
   
3. import (
   
4.         "fmt"
   
5.         "regexp"
   
6. )
   
7. 
   
8. func main() {
   
9.         re := regexp.MustCompile(`(\d+)-(\d+)-(\d+)`)
   
10.         text := "Today's date is 2025-01-25."
    
11. 
    
12.         // 找到第一个匹配的字符串
    
13.         match := re.FindString(text)
    
14.         fmt.Println("Found:", match) // 输出: Found: 2025-01-25
    
15. 
    
16.         // 找到第一个匹配及其子组
    
17.         submatches := re.FindStringSubmatch(text)
    
18.         fmt.Println("Submatches:", submatches) // 输出: Submatches: [2025-01-25 2025 01 25]
    
19. }

复制代码

4. 查找所有匹配项（FindAllString 和 FindAllStringSubmatch）

• 1. FindAllString

  复制代码
  返回所有匹配的字符串。
  
• 1. FindAllStringSubmatch

  复制代码
  返回所有匹配的字符串及其子组。
  

1. package main
   
2. 
   
3. import (
   
4.         "fmt"
   
5.         "regexp"
   
6. )
   
7. 
   
8. func main() {
   
9.         re := regexp.MustCompile(`\d+`)
   
10.         text := "Numbers: 123, 456, and 789."
    
11. 
    
12.         // 找到所有匹配的字符串
    
13.         matches := re.FindAllString(text, -1)
    
14.         fmt.Println("Matches:", matches) // 输出: Matches: [123 456 789]
    
15. 
    
16.         // 限制返回的匹配数量
    
17.         limitedMatches := re.FindAllString(text, 2)
    
18.         fmt.Println("Limited Matches:", limitedMatches) // 输出: Limited Matches: [123 456]
    
19. }

复制代码

5. 替换字符串（ReplaceAllString）

用于替换所有匹配的字符串。

1. package main
   
2. 
   
3. import (
   
4.         "fmt"
   
5.         "regexp"
   
6. )
   
7. 
   
8. func main() {
   
9.         re := regexp.MustCompile(`\d+`)
   
10.         text := "Order 123, 456, and 789."
    
11. 
    
12.         // 替换所有匹配的数字为 XXX
    
13.         result := re.ReplaceAllString(text, "XXX")
    
14.         fmt.Println("Replaced:", result) // 输出: Replaced: Order XXX, XXX, and XXX.
    
15. }

复制代码

6. 替换字符串（ReplaceAllStringFunc）

通过一个函数动态替换匹配的字符串。

1. package main
   
2. 
   
3. import (
   
4.         "fmt"
   
5.         "regexp"
   
6.         "strings"
   
7. )
   
8. 
   
9. func main() {
   
10.         re := regexp.MustCompile(`[a-z]+`)
    
11.         text := "hello world GO!"
    
12. 
    
13.         // 将匹配的字符串替换为大写
    
14.         result := re.ReplaceAllStringFunc(text, strings.ToUpper)
    
15.         fmt.Println("Replaced:", result) // 输出: Replaced: HELLO WORLD GO!
    
16. }

复制代码

7. 分割字符串（Split）

使用正则表达式分割字符串。

1. package main
   
2. 
   
3. import (
   
4.         "fmt"
   
5.         "regexp"
   
6. )
   
7. 
   
8. func main() {
   
9.         re := regexp.MustCompile(`\s+`) // 匹配空白字符
   
10.         text := "Split   this     string!"
    
11. 
    
12.         // 分割字符串
    
13.         parts := re.Split(text, -1)
    
14.         fmt.Println("Parts:", parts) // 输出: Parts: [Split this string!]
    
15. }

复制代码

8. 提取子组并命名（Named Captures）

通过命名捕获组提取特定的子组。

1. package main
   
2. 
   
3. import (
   
4.         "fmt"
   
5.         "regexp"
   
6. )
   
7. 
   
8. func main() {
   
9.         re := regexp.MustCompile(`(?P<Year>\d{4})-(?P<Month>\d{2})-(?P<Day>\d{2})`)
   
10.         text := "Date: 2025-01-25."
    
11. 
    
12.         // 提取所有子组
    
13.         submatches := re.FindStringSubmatch(text)
    
14.         fmt.Println("Submatches:", submatches) // 输出: Submatches: [2025-01-25 2025 01 25]
    
15. 
    
16.         // 提取命名的子组
    
17.         names := re.SubexpNames()
    
18.         for i, name := range names {
    
19.                 if name != "" {
    
20.                         fmt.Printf("%s: %s\n", name, submatches[i])
    
21.                 }
    
22.         }
    
23.         // 输出:
    
24.         // Year: 2025
    
25.         // Month: 01
    
26.         // Day: 25
    
27. }

复制代码

9. 检查字符串起始位置匹配（MatchString 和 Match）

• 1. MatchString

  复制代码
  检查整个字符串。
  
• 1. Match

  复制代码
  检查字节切片。
  

1. package main
   
2. 
   
3. import (
   
4.         "fmt"
   
5.         "regexp"
   
6. )
   
7. 
   
8. func main() {
   
9.         re := regexp.MustCompile(`^hello`)
   
10. 
    
11.         text := "hello world"
    
12.         bytes := []byte("hello bytes")
    
13. 
    
14.         fmt.Println("String Match:", re.MatchString(text)) // 输出: String Match: true
    
15.         fmt.Println("Bytes Match:", re.Match(bytes))      // 输出: Bytes Match: true
    
16. }

复制代码

10. 替换字节切片（ReplaceAll）

与字符串操作类似，但作用于字节切片。

1. package main
   
2. 
   
3. import (
   
4.         "fmt"
   
5.         "regexp"
   
6. )
   
7. 
   
8. func main() {
   
9.         re := regexp.MustCompile(`\d+`)
   
10.         text := []byte("Order 123, 456, and 789.")
    
11. 
    
12.         // 替换所有匹配的数字为 XXX
    
13.         result := re.ReplaceAll(text, []byte("XXX"))
    
14.         fmt.Println("Replaced:", string(result)) // 输出: Replaced: Order XXX, XXX, and XXX.
    
15. }

复制代码

到此这篇关于Go中regexp包常见的正则表达式操作的文章就介绍到这了,更多相关Go regexp正则表达式操作内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

来源：互联网
免责声明：如果侵犯了您的权益，请联系站长（1277306191@qq.com），我们会及时删除侵权内容，谢谢合作！