Golang Regexp Named Groups and Submatches

Question

I am trying to match a regular expression and get the capturing group name for the match. This works when the regular expression only matches the string once, but if it matches the string more than once, SubexpNames doesn't return the duplicated names.

Here's an example:

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("(?P<first>[a-zA-Z]+) ")
    fmt.Printf("%q\n", re.SubexpNames())
    fmt.Printf("%q\n", re.FindAllStringSubmatch("Alan Turing ", -1))
}

The output is:

["" "first"]
[["Alan " "Alan"] ["Turing " "Turing"]]

Is it possible to get the capturing group name for each submatch?

score 12 · Accepted Answer · answered Jan 22 '16 at 15:51

12

Group names and positions are fixed:

re := regexp.MustCompile("(?P<first>[a-zA-Z]+) ")
groupNames := re.SubexpNames()
for matchNum, match := range re.FindAllStringSubmatch("Alan Turing ", -1) {
    for groupIdx, group := range match {
        name := groupNames[groupIdx]
        if name == "" {
            name = "*"
        }
        fmt.Printf("#%d text: '%s', group: '%s'\n", matchNum, group, name)
    }
}

answered Jan 22 '16 at 15:51

alex vasi

5,304
28
31

Thanks. That makes sense to me now. – Randy Layman Jan 22 '16 at 19:40

VonC · Answer 2 · 2021-05-27T06:54:03.177

That might be included in Go 1.14 (Q1 2020, not yet confirmed).
See "proposal: regexp: add (*Regexp).SubexpIndex #32420". Update: it has been included with commit 782fcb4 in Go 1.15 (August 2020).

// SubexpIndex returns the index of the first subexpression with the given name,
// or else -1 if there is no subexpression with that name.
//
// Note that multiple subexpressions can be written using the same name, as in
// (?P<bob>a+)(?P<bob>b+), which declares two subexpressions named "bob".
// In this case SubexpIndex returns the index of the leftmost such subexpression
// in the regular expression.
func (*Regexp) SubexpIndex(name string) int

This is discussed in CL 187919.

re := regexp.MustCompile(`(?P<first>[a-zA-Z]+) (?P<last>[a-zA-Z]+)`)
fmt.Println(re.MatchString("Alan Turing"))
matches := re.FindStringSubmatch("Alan Turing")
lastIndex := re.SubexpIndex("last")
fmt.Printf("last => %d\n", lastIndex)
fmt.Println(matches[lastIndex])

// Output:
// true
// last => 2
// Turing

@Niemi Thank you. I have edited the answer accordingly. – VonC Nov 26 '19 at 10:56 — VonC, Nov 26 '19 at 10:56

score 1 · Answer 3 · answered Feb 08 '23 at 05:36

An example of executing ping command under Linux OS with output parsing.

type Result struct {
    AvgTime     time.Duration
    MaxTime     time.Duration
    MinTime     time.Duration
    MDevTime    time.Duration
    Transmitted int
    Received    int
}

func PingHostOrIp(hostOrIp string, pingCount int, timeout time.Duration) (*Result, error) {
    timeoutSec := int(timeout.Seconds())
    outBuff, err := exec.Command("ping", hostOrIp, "-q", fmt.Sprintf("-c %d", pingCount), fmt.Sprintf("-w %d", timeoutSec)).Output()
    if err != nil {
        return nil, err
    }
    out := string(outBuff)
    reg := regexp.MustCompile(`(\d+) packets transmitted, (\d+) received, \d+% packet loss, time .+\nrtt min/avg/max/mdev = ([\d.]+)/([\d.]+)/([\d.]+)/([\d.]+) ms`)
    subMatches := reg.FindStringSubmatch(out)
    if subMatches == nil {
        return nil, errors.New(out)
    }
    res := Result{
        AvgTime:     toDuration(subMatches[4]),
        MaxTime:     toDuration(subMatches[5]),
        MinTime:     toDuration(subMatches[3]),
        MDevTime:    toDuration(subMatches[6]),
        Transmitted: toInt(subMatches[1]),
        Received:    toInt(subMatches[2]),
    }
    return &res, nil
}

func toInt(str string) int {
    i, err := strconv.Atoi(str)
    if err != nil {
        panic(err)
    }
    return i
}

func toDuration(str string) time.Duration {
    f, err := strconv.ParseFloat(str, 32)
    if err != nil {
        panic(err)
    }
    return time.Duration(100*f) * time.Microsecond
}

Golang Regexp Named Groups and Submatches

3 Answers3

Linked