regexp package - regexp - Go Packages (original) (raw)

Package regexp implements regular expression search.

The syntax of the regular expressions accepted is the same general syntax used by Perl, Python, and other languages. More precisely, it is the syntax accepted by RE2 and described athttps://golang.org/s/re2syntax, except for \C. For an overview of the syntax, see the regexp/syntax package.

The regexp implementation provided by this package is guaranteed to run in time linear in the size of the input. (This is a property not guaranteed by most open source implementations of regular expressions.) For more information about this property, see https://swtch.com/~rsc/regexp/regexp1.htmlor any book about automata theory.

All characters are UTF-8-encoded code points. Following utf8.DecodeRune, each byte of an invalid UTF-8 sequence is treated as if it encoded utf8.RuneError (U+FFFD).

There are 16 methods of Regexp that match a regular expression and identify the matched text. Their names are matched by this regular expression:

Find(All)?(String)?(Submatch)?(Index)?

If 'All' is present, the routine matches successive non-overlapping matches of the entire expression. Empty matches abutting a preceding match are ignored. The return value is a slice containing the successive return values of the corresponding non-'All' routine. These routines take an extra integer argument, n. If n >= 0, the function returns at most n matches/submatches; otherwise, it returns all of them.

If 'String' is present, the argument is a string; otherwise it is a slice of bytes; return values are adjusted as appropriate.

If 'Submatch' is present, the return value is a slice identifying the successive submatches of the expression. Submatches are matches of parenthesized subexpressions (also known as capturing groups) within the regular expression, numbered from left to right in order of opening parenthesis. Submatch 0 is the match of the entire expression, submatch 1 is the match of the first parenthesized subexpression, and so on.

If 'Index' is present, matches and submatches are identified by byte index pairs within the input string: result[2*n:2*n+2] identifies the indexes of the nth submatch. The pair for n==0 identifies the match of the entire expression. If 'Index' is not present, the match is identified by the text of the match/submatch. If an index is negative or text is nil, it means that subexpression did not match any string in the input. For 'String' versions an empty string means either no match or an empty match.

There is also a subset of the methods that can be applied to text read from an io.RuneReader: Regexp.MatchReader, Regexp.FindReaderIndex,Regexp.FindReaderSubmatchIndex.

This set may grow. Note that regular expression matches may need to examine text beyond the text returned by a match, so the methods that match text from an io.RuneReader may read arbitrarily far into the input before returning.

(There are a few other methods that do not match this pattern.)

package main

import ( "fmt" "regexp" )

func main() { // Compile the expression once, usually at init time. // Use raw strings to avoid having to quote the backslashes. var validID = regexp.MustCompile(^[a-z]+\[[0-9]+\]$)

fmt.Println(validID.MatchString("adam[23]"))
fmt.Println(validID.MatchString("eve[7]"))
fmt.Println(validID.MatchString("Job[48]"))
fmt.Println(validID.MatchString("snakey"))

}

Output:

true true false false

This section is empty.

This section is empty.

Match reports whether the byte slice b contains any match of the regular expression pattern. More complicated queries need to use Compile and the full Regexp interface.

package main

import ( "fmt" "regexp" )

func main() { matched, err := regexp.Match(foo.*, []byte(seafood)) fmt.Println(matched, err) matched, err = regexp.Match(bar.*, []byte(seafood)) fmt.Println(matched, err) matched, err = regexp.Match(a(b, []byte(seafood)) fmt.Println(matched, err)

}

Output:

true false false error parsing regexp: missing closing ): a(b

MatchReader reports whether the text returned by the io.RuneReadercontains any match of the regular expression pattern. More complicated queries need to use Compile and the full Regexp interface.

MatchString reports whether the string s contains any match of the regular expression pattern. More complicated queries need to use Compile and the full Regexp interface.

package main

import ( "fmt" "regexp" )

func main() { matched, err := regexp.MatchString(foo.*, "seafood") fmt.Println(matched, err) matched, err = regexp.MatchString(bar.*, "seafood") fmt.Println(matched, err) matched, err = regexp.MatchString(a(b, "seafood") fmt.Println(matched, err) }

Output:

true false false error parsing regexp: missing closing ): a(b

QuoteMeta returns a string that escapes all regular expression metacharacters inside the argument text; the returned string is a regular expression matching the literal text.

package main

import ( "fmt" "regexp" )

func main() { fmt.Println(regexp.QuoteMeta(Escaping symbols like: .+*?()|[]{}^$)) }

Output:

Escaping symbols like: .+*?()|[]{}^$

Regexp is the representation of a compiled regular expression. A Regexp is safe for concurrent use by multiple goroutines, except for configuration methods, such as Regexp.Longest.

Compile parses a regular expression and returns, if successful, a Regexp object that can be used to match against text.

When matching against text, the regexp returns a match that begins as early as possible in the input (leftmost), and among those it chooses the one that a backtracking search would have found first. This so-called leftmost-first matching is the same semantics that Perl, Python, and other implementations use, although this package implements it without the expense of backtracking. For POSIX leftmost-longest matching, see CompilePOSIX.

CompilePOSIX is like Compile but restricts the regular expression to POSIX ERE (egrep) syntax and changes the match semantics to leftmost-longest.

That is, when matching against text, the regexp returns a match that begins as early as possible in the input (leftmost), and among those it chooses a match that is as long as possible. This so-called leftmost-longest matching is the same semantics that early regular expression implementations used and that POSIX specifies.

However, there can be multiple leftmost-longest matches, with different submatch choices, and here this package diverges from POSIX. Among the possible leftmost-longest matches, this package chooses the one that a backtracking search would have found first, while POSIX specifies that the match be chosen to maximize the length of the first subexpression, then the second, and so on from left to right. The POSIX rule is computationally prohibitive and not even well-defined. See https://swtch.com/~rsc/regexp/regexp2.html#posix for details.

MustCompile is like Compile but panics if the expression cannot be parsed. It simplifies safe initialization of global variables holding compiled regular expressions.

func MustCompilePOSIX(str string) *Regexp

MustCompilePOSIX is like CompilePOSIX but panics if the expression cannot be parsed. It simplifies safe initialization of global variables holding compiled regular expressions.

AppendText implements encoding.TextAppender. The output matches that of calling the Regexp.String method.

Note that the output is lossy in some cases: This method does not indicate POSIX regular expressions (i.e. those compiled by calling CompilePOSIX), or those for which the Regexp.Longest method has been called.

func (re *Regexp) Copy() *Regexp

Copy returns a new Regexp object copied from re. Calling Regexp.Longest on one copy does not affect another.

Deprecated: In earlier releases, when using a Regexp in multiple goroutines, giving each goroutine its own copy helped to avoid lock contention. As of Go 1.12, using Copy is no longer necessary to avoid lock contention. Copy may still be appropriate if the reason for its use is to make two copies with different Regexp.Longest settings.

func (*Regexp) Expand

Expand appends template to dst and returns the result; during the append, Expand replaces variables in the template with corresponding matches drawn from src. The match slice should have been returned byRegexp.FindSubmatchIndex.

In the template, a variable is denoted by a substring of the form nameorname or nameor{name}, where name is a non-empty sequence of letters, digits, and underscores. A purely numeric name like $1 refers to the submatch with the corresponding index; other names refer to capturing parentheses named with the (?P...) syntax. A reference to an out of range or unmatched index or a name that is not present in the regular expression is replaced with an empty slice.

In the nameform,nameistakentobeaslongaspossible:name form, name is taken to be as long as possible: nameform,nameistakentobeaslongaspossible:1x is equivalent to 1x,not{1x}, not 1x,not{1}x, and, 10isequivalentto10 is equivalent to 10isequivalentto{10}, not ${1}0.

To insert a literal $ in the output, use in the template.

package main

import ( "fmt" "regexp" )

func main() { content := []byte(` # comment line option1: value1 option2: value2

# another comment line
option3: value3

`)

// Regex pattern captures "key: value" pair from the content.
pattern := regexp.MustCompile(`(?m)(?P<key>\w+):\s+(?P<value>\w+)$`)

// Template to convert "key: value" to "key=value" by
// referencing the values captured by the regex pattern.
template := []byte("$key=$value\n")

result := []byte{}

// For each match of the regex in the content.
for _, submatches := range pattern.FindAllSubmatchIndex(content, -1) {
    // Apply the captured submatches to the template and append the output
    // to the result.
    result = pattern.Expand(result, template, content, submatches)
}
fmt.Println(string(result))

}

Output:

option1=value1 option2=value2 option3=value3

func (*Regexp) ExpandString

ExpandString is like Regexp.Expand but the template and source are strings. It appends to and returns a byte slice in order to give the calling code control over allocation.

package main

import ( "fmt" "regexp" )

func main() { content := ` # comment line option1: value1 option2: value2

# another comment line
option3: value3

`

// Regex pattern captures "key: value" pair from the content.
pattern := regexp.MustCompile(`(?m)(?P<key>\w+):\s+(?P<value>\w+)$`)

// Template to convert "key: value" to "key=value" by
// referencing the values captured by the regex pattern.
template := "$key=$value\n"

result := []byte{}

// For each match of the regex in the content.
for _, submatches := range pattern.FindAllStringSubmatchIndex(content, -1) {
    // Apply the captured submatches to the template and append the output
    // to the result.
    result = pattern.ExpandString(result, template, content, submatches)
}
fmt.Println(string(result))

}

Output:

option1=value1 option2=value2 option3=value3

Find returns a slice holding the text of the leftmost match in b of the regular expression. A return value of nil indicates no match.

package main

import ( "fmt" "regexp" )

func main() { re := regexp.MustCompile(foo.?) fmt.Printf("%q\n", re.Find([]byte(seafood fool)))

}

Output:

"food"

FindAll is the 'All' version of Regexp.Find; it returns a slice of all successive matches of the expression, as defined by the 'All' description in the package comment. A return value of nil indicates no match.

package main

import ( "fmt" "regexp" )

func main() { re := regexp.MustCompile(foo.?) fmt.Printf("%q\n", re.FindAll([]byte(seafood fool), -1))

}

Output:

["food" "fool"]

FindAllIndex is the 'All' version of Regexp.FindIndex; it returns a slice of all successive matches of the expression, as defined by the 'All' description in the package comment. A return value of nil indicates no match.

package main

import ( "fmt" "regexp" )

func main() { content := []byte("London") re := regexp.MustCompile(o.) fmt.Println(re.FindAllIndex(content, 1)) fmt.Println(re.FindAllIndex(content, -1)) }

Output:

[[1 3]] [[1 3] [4 6]]

FindAllString is the 'All' version of Regexp.FindString; it returns a slice of all successive matches of the expression, as defined by the 'All' description in the package comment. A return value of nil indicates no match.

package main

import ( "fmt" "regexp" )

func main() { re := regexp.MustCompile(a.) fmt.Println(re.FindAllString("paranormal", -1)) fmt.Println(re.FindAllString("paranormal", 2)) fmt.Println(re.FindAllString("graal", -1)) fmt.Println(re.FindAllString("none", -1)) }

Output:

[ar an al] [ar an] [aa] []

FindAllStringIndex is the 'All' version of Regexp.FindStringIndex; it returns a slice of all successive matches of the expression, as defined by the 'All' description in the package comment. A return value of nil indicates no match.

FindAllStringSubmatch is the 'All' version of Regexp.FindStringSubmatch; it returns a slice of all successive matches of the expression, as defined by the 'All' description in the package comment. A return value of nil indicates no match.

package main

import ( "fmt" "regexp" )

func main() { re := regexp.MustCompile(a(x*)b) fmt.Printf("%q\n", re.FindAllStringSubmatch("-ab-", -1)) fmt.Printf("%q\n", re.FindAllStringSubmatch("-axxb-", -1)) fmt.Printf("%q\n", re.FindAllStringSubmatch("-ab-axb-", -1)) fmt.Printf("%q\n", re.FindAllStringSubmatch("-axxb-ab-", -1)) }

Output:

[["ab" ""]] [["axxb" "xx"]] [["ab" ""] ["axb" "x"]] [["axxb" "xx"] ["ab" ""]]

func (re *Regexp) FindAllStringSubmatchIndex(s string, n int) [][]int

FindAllStringSubmatchIndex is the 'All' version ofRegexp.FindStringSubmatchIndex; it returns a slice of all successive matches of the expression, as defined by the 'All' description in the package comment. A return value of nil indicates no match.

package main

import ( "fmt" "regexp" )

func main() { re := regexp.MustCompile(a(x*)b) // Indices: // 01234567 012345678 // -ab-axb- -axxb-ab- fmt.Println(re.FindAllStringSubmatchIndex("-ab-", -1)) fmt.Println(re.FindAllStringSubmatchIndex("-axxb-", -1)) fmt.Println(re.FindAllStringSubmatchIndex("-ab-axb-", -1)) fmt.Println(re.FindAllStringSubmatchIndex("-axxb-ab-", -1)) fmt.Println(re.FindAllStringSubmatchIndex("-foo-", -1)) }

Output:

[[1 3 2 2]] [[1 5 2 4]] [[1 3 2 2] [4 7 5 6]] [[1 5 2 4] [6 8 7 7]] []

FindAllSubmatch is the 'All' version of Regexp.FindSubmatch; it returns a slice of all successive matches of the expression, as defined by the 'All' description in the package comment. A return value of nil indicates no match.

package main

import ( "fmt" "regexp" )

func main() { re := regexp.MustCompile(foo(.?)) fmt.Printf("%q\n", re.FindAllSubmatch([]byte(seafood fool), -1))

}

Output:

[["food" "d"] ["fool" "l"]]

func (re *Regexp) FindAllSubmatchIndex(b []byte, n int) [][]int

FindAllSubmatchIndex is the 'All' version of Regexp.FindSubmatchIndex; it returns a slice of all successive matches of the expression, as defined by the 'All' description in the package comment. A return value of nil indicates no match.

package main

import ( "fmt" "regexp" )

func main() { content := []byte( # comment line option1: value1 option2: value2) // Regex pattern captures "key: value" pair from the content. pattern := regexp.MustCompile((?m)(?P<key>\w+):\s+(?P<value>\w+)$) allIndexes := pattern.FindAllSubmatchIndex(content, -1) for _, loc := range allIndexes { fmt.Println(loc) fmt.Println(string(content[loc[0]:loc[1]])) fmt.Println(string(content[loc[2]:loc[3]])) fmt.Println(string(content[loc[4]:loc[5]])) } }

Output:

[18 33 18 25 27 33] option1: value1 option1 value1 [35 50 35 42 44 50] option2: value2 option2 value2

func (re *Regexp) FindIndex(b []byte) (loc []int)

FindIndex returns a two-element slice of integers defining the location of the leftmost match in b of the regular expression. The match itself is at b[loc[0]:loc[1]]. A return value of nil indicates no match.

package main

import ( "fmt" "regexp" )

func main() { content := []byte( # comment line option1: value1 option2: value2) // Regex pattern captures "key: value" pair from the content. pattern := regexp.MustCompile((?m)(?P<key>\w+):\s+(?P<value>\w+)$)

loc := pattern.FindIndex(content)
fmt.Println(loc)
fmt.Println(string(content[loc[0]:loc[1]]))

}

Output:

[18 33] option1: value1

FindReaderIndex returns a two-element slice of integers defining the location of the leftmost match of the regular expression in text read from the io.RuneReader. The match text was found in the input stream at byte offset loc[0] through loc[1]-1. A return value of nil indicates no match.

FindReaderSubmatchIndex returns a slice holding the index pairs identifying the leftmost match of the regular expression of text read by the io.RuneReader, and the matches, if any, of its subexpressions, as defined by the 'Submatch' and 'Index' descriptions in the package comment. A return value of nil indicates no match.

FindString returns a string holding the text of the leftmost match in s of the regular expression. If there is no match, the return value is an empty string, but it will also be empty if the regular expression successfully matches an empty string. Use Regexp.FindStringIndex or Regexp.FindStringSubmatch if it is necessary to distinguish these cases.

package main

import ( "fmt" "regexp" )

func main() { re := regexp.MustCompile(foo.?) fmt.Printf("%q\n", re.FindString("seafood fool")) fmt.Printf("%q\n", re.FindString("meat")) }

Output:

"food" ""

func (re *Regexp) FindStringIndex(s string) (loc []int)

FindStringIndex returns a two-element slice of integers defining the location of the leftmost match in s of the regular expression. The match itself is at s[loc[0]:loc[1]]. A return value of nil indicates no match.

package main

import ( "fmt" "regexp" )

func main() { re := regexp.MustCompile(ab?) fmt.Println(re.FindStringIndex("tablett")) fmt.Println(re.FindStringIndex("foo") == nil) }

Output:

[1 3] true

FindStringSubmatch returns a slice of strings holding the text of the leftmost match of the regular expression in s and the matches, if any, of its subexpressions, as defined by the 'Submatch' description in the package comment. A return value of nil indicates no match.

package main

import ( "fmt" "regexp" )

func main() { re := regexp.MustCompile(a(x*)b(y|z)c) fmt.Printf("%q\n", re.FindStringSubmatch("-axxxbyc-")) fmt.Printf("%q\n", re.FindStringSubmatch("-abzc-")) }

Output:

["axxxbyc" "xxx" "y"] ["abzc" "" "z"]

func (re *Regexp) FindStringSubmatchIndex(s string) []int

FindStringSubmatchIndex returns a slice holding the index pairs identifying the leftmost match of the regular expression in s and the matches, if any, of its subexpressions, as defined by the 'Submatch' and 'Index' descriptions in the package comment. A return value of nil indicates no match.

func (re *Regexp) FindSubmatch(b []byte) [][]byte

FindSubmatch returns a slice of slices holding the text of the leftmost match of the regular expression in b and the matches, if any, of its subexpressions, as defined by the 'Submatch' descriptions in the package comment. A return value of nil indicates no match.

package main

import ( "fmt" "regexp" )

func main() { re := regexp.MustCompile(foo(.?)) fmt.Printf("%q\n", re.FindSubmatch([]byte(seafood fool)))

}

Output:

["food" "d"]

func (re *Regexp) FindSubmatchIndex(b []byte) []int

FindSubmatchIndex returns a slice holding the index pairs identifying the leftmost match of the regular expression in b and the matches, if any, of its subexpressions, as defined by the 'Submatch' and 'Index' descriptions in the package comment. A return value of nil indicates no match.

package main

import ( "fmt" "regexp" )

func main() { re := regexp.MustCompile(a(x*)b) // Indices: // 01234567 012345678 // -ab-axb- -axxb-ab- fmt.Println(re.FindSubmatchIndex([]byte("-ab-"))) fmt.Println(re.FindSubmatchIndex([]byte("-axxb-"))) fmt.Println(re.FindSubmatchIndex([]byte("-ab-axb-"))) fmt.Println(re.FindSubmatchIndex([]byte("-axxb-ab-"))) fmt.Println(re.FindSubmatchIndex([]byte("-foo-"))) }

Output:

[1 3 2 2] [1 5 2 4] [1 3 2 2] [1 5 2 4] []

func (re *Regexp) LiteralPrefix() (prefix string, complete bool)

LiteralPrefix returns a literal string that must begin any match of the regular expression re. It returns the boolean true if the literal string comprises the entire regular expression.

func (re *Regexp) Longest()

Longest makes future searches prefer the leftmost-longest match. That is, when matching against text, the regexp returns a match that begins as early as possible in the input (leftmost), and among those it chooses a match that is as long as possible. This method modifies the Regexp and may not be called concurrently with any other methods.

package main

import ( "fmt" "regexp" )

func main() { re := regexp.MustCompile(a(|b)) fmt.Println(re.FindString("ab")) re.Longest() fmt.Println(re.FindString("ab")) }

Output:

a ab

Match reports whether the byte slice b contains any match of the regular expression re.

package main

import ( "fmt" "regexp" )

func main() { re := regexp.MustCompile(foo.?) fmt.Println(re.Match([]byte(seafood fool))) fmt.Println(re.Match([]byte(something else)))

}

Output:

true false

MatchReader reports whether the text returned by the io.RuneReadercontains any match of the regular expression re.

MatchString reports whether the string s contains any match of the regular expression re.

package main

import ( "fmt" "regexp" )

func main() { re := regexp.MustCompile((gopher){2}) fmt.Println(re.MatchString("gopher")) fmt.Println(re.MatchString("gophergopher")) fmt.Println(re.MatchString("gophergophergopher")) }

Output:

false true true

func (re *Regexp) NumSubexp() int

NumSubexp returns the number of parenthesized subexpressions in this Regexp.

package main

import ( "fmt" "regexp" )

func main() { re0 := regexp.MustCompile(a.) fmt.Printf("%d\n", re0.NumSubexp())

re := regexp.MustCompile(`(.*)((a)b)(.*)a`)
fmt.Println(re.NumSubexp())

}

Output:

0 4

func (re *Regexp) ReplaceAll(src, repl []byte) []byte

ReplaceAll returns a copy of src, replacing matches of the Regexpwith the replacement text repl. Inside repl, $ signs are interpreted as in Regexp.Expand.

package main

import ( "fmt" "regexp" )

func main() { re := regexp.MustCompile(a(x*)b) fmt.Printf("%s\n", re.ReplaceAll([]byte("-ab-axxb-"), []byte("T"))) fmt.Printf("%s\n", re.ReplaceAll([]byte("-ab-axxb-"), []byte("$1"))) fmt.Printf("%s\n", re.ReplaceAll([]byte("-ab-axxb-"), []byte("$1W"))) fmt.Printf("%s\n", re.ReplaceAll([]byte("-ab-axxb-"), []byte("${1}W")))

re2 := regexp.MustCompile(`a(?P<1W>x*)b`)
fmt.Printf("%s\n", re2.ReplaceAll([]byte("-ab-axxb-"), []byte("$1W")))
fmt.Printf("%s\n", re2.ReplaceAll([]byte("-ab-axxb-"), []byte("${1}W")))

}

Output:

-T-T- --xx-

-W-xxW- --xx- -W-xxW-

ReplaceAllFunc returns a copy of src in which all matches of theRegexp have been replaced by the return value of function repl applied to the matched byte slice. The replacement returned by repl is substituted directly, without using Regexp.Expand.

func (re *Regexp) ReplaceAllLiteral(src, repl []byte) []byte

ReplaceAllLiteral returns a copy of src, replacing matches of the Regexpwith the replacement bytes repl. The replacement repl is substituted directly, without using Regexp.Expand.

ReplaceAllLiteralString returns a copy of src, replacing matches of the Regexpwith the replacement string repl. The replacement repl is substituted directly, without using Regexp.Expand.

package main

import ( "fmt" "regexp" )

func main() { re := regexp.MustCompile(a(x*)b) fmt.Println(re.ReplaceAllLiteralString("-ab-axxb-", "T")) fmt.Println(re.ReplaceAllLiteralString("-ab-axxb-", "$1")) fmt.Println(re.ReplaceAllLiteralString("-ab-axxb-", "${1}")) }

Output:

-T-T- -$1-$1- -${1}-${1}-

ReplaceAllString returns a copy of src, replacing matches of the Regexpwith the replacement string repl. Inside repl, $ signs are interpreted as in Regexp.Expand.

package main

import ( "fmt" "regexp" )

func main() { re := regexp.MustCompile(a(x*)b) fmt.Println(re.ReplaceAllString("-ab-axxb-", "T")) fmt.Println(re.ReplaceAllString("-ab-axxb-", "$1")) fmt.Println(re.ReplaceAllString("-ab-axxb-", "$1W")) fmt.Println(re.ReplaceAllString("-ab-axxb-", "${1}W"))

re2 := regexp.MustCompile(`a(?P<1W>x*)b`)
fmt.Printf("%s\n", re2.ReplaceAllString("-ab-axxb-", "$1W"))
fmt.Println(re.ReplaceAllString("-ab-axxb-", "${1}W"))

}

Output:

-T-T- --xx-

-W-xxW- --xx- -W-xxW-

ReplaceAllStringFunc returns a copy of src in which all matches of theRegexp have been replaced by the return value of function repl applied to the matched substring. The replacement returned by repl is substituted directly, without using Regexp.Expand.

package main

import ( "fmt" "regexp" "strings" )

func main() { re := regexp.MustCompile([^aeiou]) fmt.Println(re.ReplaceAllStringFunc("seafood fool", strings.ToUpper)) }

Output:

SeaFooD FooL

Split slices s into substrings separated by the expression and returns a slice of the substrings between those expression matches.

The slice returned by this method consists of all the substrings of s not contained in the slice returned by Regexp.FindAllString. When called on an expression that contains no metacharacters, it is equivalent to strings.SplitN.

Example:

s := regexp.MustCompile("a*").Split("abaabaccadaaae", 5) // s: ["", "b", "b", "c", "cadaaae"]

The count determines the number of substrings to return:

package main

import ( "fmt" "regexp" )

func main() { a := regexp.MustCompile(a) fmt.Println(a.Split("banana", -1)) fmt.Println(a.Split("banana", 0)) fmt.Println(a.Split("banana", 1)) fmt.Println(a.Split("banana", 2)) zp := regexp.MustCompile(z+) fmt.Println(zp.Split("pizza", -1)) fmt.Println(zp.Split("pizza", 0)) fmt.Println(zp.Split("pizza", 1)) fmt.Println(zp.Split("pizza", 2)) }

Output:

[b n n ] [] [banana] [b nana] [pi a] [] [pizza] [pi a]

String returns the source text used to compile the regular expression.

SubexpIndex returns the index of the first subexpression with the given name, or -1 if there is no subexpression with that name.

Note that multiple subexpressions can be written using the same name, as in (?Pa+)(?Pb+), which declares two subexpressions named "bob". In this case, SubexpIndex returns the index of the leftmost such subexpression in the regular expression.

package main

import ( "fmt" "regexp" )

func main() { 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

func (re *Regexp) SubexpNames() []string

SubexpNames returns the names of the parenthesized subexpressions in this Regexp. The name for the first sub-expression is names[1], so that if m is a match slice, the name for m[i] is SubexpNames()[i]. Since the Regexp as a whole cannot be named, names[0] is always the empty string. The slice should not be modified.

package main

import ( "fmt" "regexp" )

func main() { re := regexp.MustCompile((?P<first>[a-zA-Z]+) (?P<last>[a-zA-Z]+)) fmt.Println(re.MatchString("Alan Turing")) fmt.Printf("%q\n", re.SubexpNames()) reversed := fmt.Sprintf("${%s} ${%s}", re.SubexpNames()[2], re.SubexpNames()[1]) fmt.Println(reversed) fmt.Println(re.ReplaceAllString("Alan Turing", reversed)) }

Output:

true ["" "first" "last"] last{last} last{first} Turing Alan