regexp

func Match

1func Match(pattern string, b []byte) (matched bool, err 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.

1matched, err := regexp.Match(`foo.*`, []byte(`seafood`))
2fmt.Println(matched, err)
3matched, err = regexp.Match(`bar.*`, []byte(`seafood`))
4fmt.Println(matched, err)
5matched, err = regexp.Match(`a(b`, []byte(`seafood`))
6fmt.Println(matched, err)

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

func MatchReader

1func MatchReader(pattern string, r io.RuneReader) (matched bool, err error)

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

func MatchString

1func MatchString(pattern string, s string) (matched bool, err 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.

1matched, err := regexp.MatchString(`foo.*`, "seafood")
2fmt.Println(matched, err)
3matched, err = regexp.MatchString(`bar.*`, "seafood")
4fmt.Println(matched, err)
5matched, err = regexp.MatchString(`a(b`, "seafood")
6fmt.Println(matched, err)

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

func QuoteMeta

1func 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.

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

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

func Compile

1func 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 backtracking. For POSIX leftmost-longest matching, see CompilePOSIX.

func CompilePOSIX

1func 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 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.

func MustCompile

1func 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.

func MustCompilePOSIX

1func 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.