regexp
import "regexp"
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 at https://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 ...
Go 1.26.1
Functions
func Compile(expr string) (*Regexp, error)
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 backt...
regexp/regexp.go:130
func CompilePOSIX(expr string) (*Regexp, error)
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 b...
regexp/regexp.go:153
func Match(pattern string, b []byte) (bool, error)
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.
regexp/regexp.go:541
func MatchReader(pattern string, r io.RuneReader) (bool, error)
MatchReader reports whether the text returned by the [io.RuneReader] contains any match of the regular expression pattern. More complicated queries need to use [Compile] and the full [Regexp] interface.
regexp/regexp.go:519
func MatchString(pattern string, s string) (bool, error)
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.
regexp/regexp.go:530
func MustCompile(str string) *Regexp
MustCompile is like [Compile] but panics if the expression cannot be parsed. It simplifies safe initialization of global variables holding compiled regular expressions.
regexp/regexp.go:310
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.
regexp/regexp.go:321
func QuoteMeta(s string) string
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.
regexp/regexp.go:702
Types
type Regexp struct {
// contains filtered or unexported fields
}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].
regexp/regexp.go:80
func (re *Regexp) AppendText(b []byte) ([]byte, error)
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.
regexp/regexp.go:1266
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.
regexp/regexp.go:115
func (re *Regexp) Expand(dst []byte, template []byte, src []byte, match []int) []byte
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 by [Regexp.FindSubmatchIndex]. In the template, a variable is denoted by a substring of the form $name or ${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 capt...
regexp/regexp.go:895
func (re *Regexp) ExpandString(dst []byte, template string, src string, match []int) []byte
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.
regexp/regexp.go:902
func (re *Regexp) Find(b []byte) []byte
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.
regexp/regexp.go:798
func (re *Regexp) FindAll(b []byte, n int) [][]byte
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.
regexp/regexp.go:1057
func (re *Regexp) FindAllIndex(b []byte, n int) [][]int
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.
regexp/regexp.go:1075
func (re *Regexp) FindAllString(s string, n int) []string
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.
regexp/regexp.go:1093
func (re *Regexp) FindAllStringIndex(s string, n int) [][]int
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.
regexp/regexp.go:1111
func (re *Regexp) FindAllStringSubmatch(s string, n int) [][]string
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.
regexp/regexp.go:1171
func (re *Regexp) FindAllStringSubmatchIndex(s string, n int) [][]int
FindAllStringSubmatchIndex is the 'All' version of [Regexp.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.
regexp/regexp.go:1196
func (re *Regexp) FindAllSubmatch(b []byte, n int) [][][]byte
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.
regexp/regexp.go:1129
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.
regexp/regexp.go:1153
func (re *Regexp) FindIndex(b []byte) []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.
regexp/regexp.go:811
func (re *Regexp) FindReaderIndex(r io.RuneReader) []int
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.
regexp/regexp.go:850
func (re *Regexp) FindReaderSubmatchIndex(r io.RuneReader) []int
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.
regexp/regexp.go:1047
func (re *Regexp) FindString(s string) string
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.
regexp/regexp.go:824
func (re *Regexp) FindStringIndex(s string) []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.
regexp/regexp.go:837
func (re *Regexp) FindStringSubmatch(s string) []string
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.
regexp/regexp.go:1018
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.
regexp/regexp.go:1038
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.
regexp/regexp.go:863
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.
regexp/regexp.go:1009
func (re *Regexp) LiteralPrefix() (string, 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.
regexp/regexp.go:494
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.
regexp/regexp.go:163
func (re *Regexp) MarshalText() ([]byte, error)
MarshalText implements [encoding.TextMarshaler]. The output matches that of calling the [Regexp.AppendText] method. See [Regexp.AppendText] for more information.
regexp/regexp.go:1274
func (re *Regexp) Match(b []byte) bool
Match reports whether the byte slice b contains any match of the regular expression re.
regexp/regexp.go:512
func (re *Regexp) MatchReader(r io.RuneReader) bool
MatchReader reports whether the text returned by the [io.RuneReader] contains any match of the regular expression re.
regexp/regexp.go:500
func (re *Regexp) MatchString(s string) bool
MatchString reports whether the string s contains any match of the regular expression re.
regexp/regexp.go:506
func (re *Regexp) NumSubexp() int
NumSubexp returns the number of parenthesized subexpressions in this [Regexp].
regexp/regexp.go:337
func (re *Regexp) ReplaceAll(src []byte, repl []byte) []byte
ReplaceAll returns a copy of src, replacing matches of the [Regexp] with the replacement text repl. Inside repl, $ signs are interpreted as in [Regexp.Expand].
regexp/regexp.go:651
func (re *Regexp) ReplaceAllFunc(src []byte, repl func(...)) []byte
ReplaceAllFunc returns a copy of src in which all matches of the [Regexp] 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].
regexp/regexp.go:679
func (re *Regexp) ReplaceAllLiteral(src []byte, repl []byte) []byte
ReplaceAllLiteral returns a copy of src, replacing matches of the [Regexp] with the replacement bytes repl. The replacement repl is substituted directly, without using [Regexp.Expand].
regexp/regexp.go:669
func (re *Regexp) ReplaceAllLiteralString(src string, repl string) string
ReplaceAllLiteralString returns a copy of src, replacing matches of the [Regexp] with the replacement string repl. The replacement repl is substituted directly, without using [Regexp.Expand].
regexp/regexp.go:566
func (re *Regexp) ReplaceAllString(src string, repl string) string
ReplaceAllString returns a copy of src, replacing matches of the [Regexp] with the replacement string repl. Inside repl, $ signs are interpreted as in [Regexp.Expand].
regexp/regexp.go:552
func (re *Regexp) ReplaceAllStringFunc(src string, repl func(...)) string
ReplaceAllStringFunc returns a copy of src in which all matches of the [Regexp] 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].
regexp/regexp.go:576
func (re *Regexp) Split(s string, n int) []string
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...
regexp/regexp.go:1226
func (re *Regexp) String() string
String returns the source text used to compile the regular expression.
regexp/regexp.go:103
func (re *Regexp) SubexpIndex(name string) int
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 (?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.
regexp/regexp.go:357
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.
regexp/regexp.go:346
func (re *Regexp) UnmarshalText(text []byte) error
UnmarshalText implements [encoding.TextUnmarshaler] by calling [Compile] on the encoded value.
regexp/regexp.go:1280