golang正则表达式构建器插件库rex的使用

Golang正则表达式构建器插件库Rex的使用

Rex是一个为Gopher设计的正则表达式构建器库！它通过人性化的构建方式提高了代码可读性，并帮助构建正则表达式。

为什么使用Rex？

它使代码更易读，并帮助使用人性化的结构构建正则表达式。此外，它允许注释和重用块，提高了代码质量。它提供了一种便捷的方式来使用参数化模式。可以轻松实现自定义模式或使用其他模式的组合。

它只是一个构建器，所以返回标准的*regexp.Regexp。

示例代码

示例1：验证someid[#]格式

re := rex.New(
    rex.Chars.Begin(), // `^`
    // ID应以小写字符开头
    rex.Chars.Lower().Repeat().OneOrMore(), // `[a-z]+`
    // ID应包含在括号中的数字[#]
    rex.Group.NonCaptured( // (?:)
        rex.Chars.Single('['),                   // `[`
        rex.Chars.Digits().Repeat().OneOrMore(), // `[0-9]+`
        rex.Chars.Single(']'),                   // `]`
    ),
    rex.Chars.End(), // `$`
).MustCompile()

示例2：匹配-111.99到1111.99之间的数字

re := rex.New(
    rex.Common.Raw(`^`),
    rex.Helper.NumberRange(-111, 1111),
    rex.Common.RawVerbose(`
        # RawVerbose是Raw的同义词，
        # 但忽略注释、空格和换行
        \.        # 小数点分隔符
        [0-9]{2}  # 仅两位数字
        $         # 结束
    `),
).MustCompile()

// 生成:
// ^((?:\x2D(?:0|(?:[1-9])|(?:[1-9][0-9])|(?:10[0-9])|(?:11[0-1])))|(?:0|(?:[1-9])|(?:[1-9][0-9])|(?:[1-9][0-9][0-9])|(?:10[0-9][0-9])|(?:110[0-9])|(?:111[0-1])))\.[0-9]{2}$

示例3：混合使用原始正则表达式

rex.New(
    rex.Chars.Begin(),
    rex.Group.Define(
        // `Raw`可以放在任何块中
        rex.Common.Raw(`[a-z]+\d+[A-Z]*`),
    ),
    rex.Chars.End(),
)

示例4：带注释的原始正则表达式

rex.Common.RawVerbose(`
    ^                # 行开始
    [a-zA-Z0-9]+     # 本地部分
    @                # 分隔符
    [a-zA-Z0-9\.]+   # 域名部分
    $                # 行结束
`)

功能特性

常见问题

  1. 代码太冗长了

    • 更多但更简单的代码，更少的错误
    • 仍然可以使用原始正则表达式语法与助手结合

  2. 需要了解正则表达式吗？

    • 最好了解它们以最有效地使用此库
    • 但不是严格必需的

  3. 是否依赖语言？可以转移到其他语言吗？

    • 只能在Go中使用此库
    • 如果想在其他地方使用任何部分，只需调用rex.New(...).String()并复制粘贴生成的正则表达式

  4. 关于我最喜欢的DSL？

    • 每个IDE都有方便的语言自动完成功能
    • 因此，该库的所有助手都很容易开箱即用
    • 也更容易创建自定义参数化助手

  5. 稳定吗？

    • 是的，从v1.0.0开始

  6. 我有其他问题/发现问题/有功能请求/想贡献


更多关于golang正则表达式构建器插件库rex的使用的实战教程也可以访问 https://www.itying.com/category-94-b0.html

1 回复

更多关于golang正则表达式构建器插件库rex的使用的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


Golang 正则表达式构建器 rex 库使用指南

rex 是一个 Go 语言的正则表达式构建器库，它提供了一种更直观、更易读的方式来构建复杂的正则表达式。

安装 rex

go get github.com/hedzr/rex

基本用法

1. 简单匹配

package main

import (
	"fmt"
	"github.com/hedzr/rex"
)

func main() {
	// 构建一个匹配 "hello" 的正则表达式
	regex := rex.New().Text("hello").MustCompile()

	fmt.Println(regex.MatchString("hello world")) // true
	fmt.Println(regex.MatchString("hi there"))    // false
}

2. 组合匹配

// 匹配 "hello" 后跟任意数量的空白字符，然后是 "world"
regex := rex.New().
    Text("hello").
    Whitespaces().Min(0).Max(-1). // 0到无限个空白字符
    Text("world").
    MustCompile()

fmt.Println(regex.MatchString("helloworld"))    // true
fmt.Println(regex(regex.MatchString("hello world")) // true

3. 字符类

// 匹配一个数字后跟一个小写字母
regex := rex.New().
    Digit(). // 等价于 [0-9]
    Chars("a-z"). // 等价于 [a-z]
    MustCompile()

fmt.Println(regex.MatchString("1a")) // true
fmt.Println(regex.MatchString("a1")) // false

4. 量词

// 匹配3到5个字母a
regex := rex.New().
    Text("a").Min(3).Max(5).
    MustCompile()

fmt.Println(regex.MatchString("aaa"))   // true
fmt.Println(regex.MatchString("aaaaa")) // true
fmt.Println(regex.MatchString("aa"))    // false

5. 分组和捕获

// 捕获用户名和域名
regex := rex.New().
    BeginCapture(). // 开始捕获组
    WordChars().Min(1).Max(20). // 1-20个单词字符
    EndCapture(). // 结束捕获组
    Text("@").
    BeginCapture().
    WordChars().Min(1).Max(50).
    EndCapture().
    MustCompile()

matches := regex.FindStringSubmatch("user@example.com")
fmt.Println(matches[1]) // "user"
fmt.Println(matches[2]) // "example.com"

6. 选择分支

// 匹配 "cat" 或 "dog"
regex := rex.New().
    Either(
        rex.New().Text("cat"),
        rex.New().Text("dog"),
    ).
    MustCompile()

fmt.Println(regex.MatchString("cat")) // true
fmt.Println(regex.MatchString("dog")) // true
fmt.Println(regex.MatchString("fox")) // false

7. 边界匹配

// 匹配以http或https开头的URL
regex := rex.New().
    StartOfLine().
    Either(
        rex.New().Text("http"),
        rex.New().Text("https"),
    ).
    Text("://").
    MustCompile()

fmt.Println(regex.MatchString("http://example.com"))  // true
fmt.Println(regex.MatchString("https://example.com")) // true
fmt.Println(regex.MatchString("ftp://example.com"))   // false

高级用法

1. 构建复杂正则表达式

// 匹配日期格式 YYYY-MM-DD
regex := rex.New().
    StartOfLine().
    Digit().Repeat(4). // 4位数字
    Text("-").
    Digit().Repeat(2). // 2位数字
    Text("-").
    Digit().Repeat(2). // 2位数字
    EndOfLine().
    MustCompile()

fmt.Println(regex.MatchString("2023-05-15")) // true
fmt.Println(regex.MatchString("2023/05/15")) // false

2. 重用模式

// 定义可重用的数字模式
digits := func(min, max int) *rex.R {
    return rex.New().Digit().Min(min).Max(max)
}

// 匹配时间 HH:MM:SS
regex := rex.New().
    StartOfLine().
    Add(digits(2, 2)). // 小时
    Text(":").
    Add(digits(2, 2)). // 分钟
    Text(":").
    Add(digits(2, 2)). // 秒
    EndOfLine().
    MustCompile()

fmt.Println(regex.MatchString("12:34:56")) // true
fmt.Println(regex.MatchString("1:2:3"))    // false

性能考虑

虽然 rex 提供了更友好的 API，但最终它还是会编译成标准的正则表达式。对于性能敏感的场景，建议：

  1. 预编译正则表达式（使用 MustCompile 或 Compile）
  2. 复用编译后的正则对象
  3. 对于简单匹配，考虑使用 strings 包中的函数

总结

rex 库为 Go 语言提供了更直观的正则表达式构建方式，特别适合构建复杂的正则模式。通过链式调用和清晰的语义，可以大大提高正则表达式的可读性和可维护性。

对于简单的匹配需求，标准库的 regexp 可能更直接，但对于复杂的正则表达式构建，rex 是一个很好的选择。

回到顶部