Golang正则表达式命名分组匹配与结构体自动解析插件库regroup的使用

regroup是一个简单的库，可以使用结构体标签和自动解析将正则表达式命名分组匹配到Go结构体中。

安装

go get github.com/oriser/regroup

示例

命名分组映射

package main

import (
	"fmt"
	"github.com/oriser/regroup"
)

var re = regroup.MustCompile(`(?P<duration>.*?)\s+(?P<num>\d+)\s+(?P<foo>.*)`)

func main() {
	matches, err := re.Groups("5s 123 bar")
	if err != nil {
		panic(err)
	}
	fmt.Printf("%+v\n", matches)
}

输出:

map[duration:5s foo:bar num:123]

单次匹配

package main

import (
	"fmt"
	"github.com/oriser/regroup"
	"time"
)

var re = regroup.MustCompile(`(?P<duration>.*?)\s+(?P<num>\d+)\s+(?P<foo>.*)`)

type B struct {
	Str string `regroup:"foo"`
}

type A struct {
	Number        int           `regroup:"num"`
	Dur           time.Duration `regroup:"duration"`
	AnotherStruct B
}

func main() {
	a := &A{}
	if err := re.MatchToTarget("5s 123 bar", a); err != nil {
		panic(err)
	}
	fmt.Printf("%+v\n", a)
}

输出:

&{Number:123 Dur:5s AnotherStruct:{Str:bar}}

多次匹配

你可以获取所有匹配项并解析为给定的目标结构体。返回值在这种情况下将是一个接口数组，你应该将其转换为目标类型以访问其字段。

package main

import (
	"fmt"
	"github.com/oriser/regroup"
	"time"
)

var re = regroup.MustCompile(`\s*(?P<duration>.*?)\s+(?P<num>\d+)\s+(?P<foo>.*)`)

type B struct {
	Str string `regroup:"foo"`
}

type A struct {
	Number        int           `regroup:"num"`
	Dur           time.Duration `regroup:"duration"`
	AnotherStruct B
}

func main() {
	a := &A{}
	s := `5s 123 bar1
		  1m 456 bar2
		  10h 789 bar3`
	rets, err := re.MatchAllToTarget(s, -1, a)
	if err != nil {
		panic(err)
	}
	for _, elem := range rets {
		fmt.Printf("%+v\n", elem.(*A))
	}
}

输出:

&{Number:123 Dur:5s AnotherStruct:{Str:bar1}}
&{Number:456 Dur:1m0s AnotherStruct:{Str:bar2}}
&{Number:789 Dur:10h0m0s AnotherStruct:{Str:bar3}}

必填分组

你可以指定某个分组是必填的，意味着它不能为空。如果必填分组为空，将返回一个错误(*regroup.RequiredGroupIsEmpty)。

package main

import (
	"fmt"
	"github.com/oriser/regroup"
	"time"
)

var re = regroup.MustCompile(`(?P<duration>.*?)\s+(?P<num>\d+)\s+(?P<foo>.*)`)

type B struct {
	Str string `regroup:"foo,required"`
}

type A struct {
	Number        int           `regroup:"num"`
	Dur           time.Duration `regroup:"duration"`
	AnotherStruct B
}

func main() {
	a := &A{}
	if err := re.MatchToTarget("5s 123 ", a); err != nil {
		panic(err)
	}
	fmt.Printf("%+v\n", a)
}

将返回错误: required regroup "foo" is empty for field "Str"

存在性匹配分组

你可以使用带有exists标签的bool来检查可选分组是否存在。

package main

type Exist struct {
	IsAdmin bool `regroup:"is_admin,exists"`
}

func main() {
	r := MustCompile(`^(?P<name>\w*)(?:,(?P<is_admin>admin))?$`)
	parsed := &Exist{}
	if err := r.MatchToTarget("bob_smith", parsed); err != nil {
		panic(err)
	}
	fmt.Printf("%t\n", parsed.IsAdmin)
}

这个例子会打印false。但是如果输入是bob_smith,admin，它会打印true。当使用exists标签时，请确保你的正则表达式有一个可选分组并匹配所有预期的输入模式。

支持的结构体字段类型

• time.Duration
• bool
• string
• int
• int8
• int16
• int32
• int64
• uint
• uint8
• uint16
• uint32
• uint64
• float32
• float64

指针和嵌套结构体也支持，包括单次匹配和多次匹配。