const (
None RegexOptions = 0x0
IgnoreCase = 0x0001 // "i"
Multiline = 0x0002 // "m"
ExplicitCapture = 0x0004 // "n"
Compiled = 0x0008 // "c"
Singleline = 0x0010 // "s"
IgnorePatternWhitespace = 0x0020 // "x"
RightToLeft = 0x0040 // "r"
Debug = 0x0080 // "d"
ECMAScript = 0x0100 // "e"
RE2 = 0x0200 // RE2 (regexp package) compatibility mode
Unicode = 0x0400 // "u"
)
const DefaultClockPeriod = 100 * time.Millisecond
Default timeout used when running regexp matches -- "forever"
var DefaultMatchTimeout = time.Duration(math.MaxInt64)
func Escape(input string) string
Escape adds backslashes to any special characters in the input string
func SetTimeoutCheckPeriod(d time.Duration)
SetTimeoutPeriod is a debug function that sets the frequency of the timeout goroutine's sleep cycle. Defaults to 100ms. The only benefit of setting this lower is that the 1 background goroutine that manages timeouts may exit slightly sooner after all the timeouts have expired. See Github issue #63
func StopTimeoutClock()
StopTimeoutClock should only be used in unit tests to prevent the timeout clock goroutine from appearing like a leaking goroutine
func Unescape(input string) (string, error)
Unescape removes any backslashes from previously-escaped special characters in the input string
Capture is a single capture of text within the larger original string
type Capture struct {
// the position in the original string where the first character of
// captured substring was found.
Index int
// the length of the captured substring.
Length int
// contains filtered or unexported fields
}
func (c *Capture) Runes() []rune
Runes returns the captured text as a rune slice
func (c *Capture) String() string
String returns the captured text as a String
Group is an explicit or implit (group 0) matched group within the pattern
type Group struct {
Capture // the last capture of this group is embeded for ease of use
Name string // group name
Captures []Capture // captures of this group
}
Match is a single regex result match that contains groups and repeated captures
-Groups -Capture
type Match struct {
Group //embeded group 0
// contains filtered or unexported fields
}
func (m *Match) GroupByName(name string) *Group
GroupByName returns a group based on the name of the group, or nil if the group name does not exist
func (m *Match) GroupByNumber(num int) *Group
GroupByNumber returns a group based on the number of the group, or nil if the group number does not exist
func (m *Match) GroupCount() int
GroupCount returns the number of groups this match has matched
func (m *Match) Groups() []Group
Groups returns all the capture groups, starting with group 0 (the full match)
MatchEvaluator is a function that takes a match and returns a replacement string to be used
type MatchEvaluator func(Match) string
RegexOptions impact the runtime and parsing behavior for each specific regex. They are setable in code as well as in the regex pattern itself.
type RegexOptions int32
Regexp is the representation of a compiled regular expression. A Regexp is safe for concurrent use by multiple goroutines.
type Regexp struct {
// A match will time out if it takes (approximately) more than
// MatchTimeout. This is a safety check in case the match
// encounters catastrophic backtracking. The default value
// (DefaultMatchTimeout) causes all time out checking to be
// suppressed.
MatchTimeout time.Duration
// contains filtered or unexported fields
}
func Compile(expr string, opt RegexOptions) (*Regexp, error)
Compile parses a regular expression and returns, if successful, a Regexp object that can be used to match against text.
func MustCompile(str string, opt RegexOptions) *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 (re *Regexp) Debug() bool
func (re *Regexp) FindNextMatch(m *Match) (*Match, error)
FindNextMatch returns the next match in the same input string as the match parameter. Will return nil if there is no next match or if given a nil match.
func (re *Regexp) FindRunesMatch(r []rune) (*Match, error)
FindRunesMatch searches the input rune slice for a Regexp match
func (re *Regexp) FindRunesMatchStartingAt(r []rune, startAt int) (*Match, error)
FindRunesMatchStartingAt searches the input rune slice for a Regexp match starting at the startAt index
func (re *Regexp) FindStringMatch(s string) (*Match, error)
FindStringMatch searches the input string for a Regexp match
func (re *Regexp) FindStringMatchStartingAt(s string, startAt int) (*Match, error)
FindStringMatchStartingAt searches the input string for a Regexp match starting at the startAt index
func (re *Regexp) GetGroupNames() []string
GetGroupNames Returns the set of strings used to name capturing groups in the expression.
func (re *Regexp) GetGroupNumbers() []int
GetGroupNumbers returns the integer group numbers corresponding to a group name.
func (re *Regexp) GroupNameFromNumber(i int) string
GroupNameFromNumber retrieves a group name that corresponds to a group number. It will return "" for and unknown group number. Unnamed groups automatically receive a name that is the decimal string equivalent of its number.
func (re *Regexp) GroupNumberFromName(name string) int
GroupNumberFromName returns a group number that corresponds to a group name. Returns -1 if the name is not a recognized group name. Numbered groups automatically get a group name that is the decimal string equivalent of its number.
func (re *Regexp) MatchRunes(r []rune) (bool, error)
MatchRunes return true if the runes matches the regex error will be set if a timeout occurs
func (re *Regexp) MatchString(s string) (bool, error)
MatchString return true if the string matches the regex error will be set if a timeout occurs
func (re *Regexp) Replace(input, replacement string, startAt, count int) (string, error)
Replace searches the input string and replaces each match found with the replacement text. Count will limit the number of matches attempted and startAt will allow us to skip past possible matches at the start of the input (left or right depending on RightToLeft option). Set startAt and count to -1 to go through the whole string
func (re *Regexp) ReplaceFunc(input string, evaluator MatchEvaluator, startAt, count int) (string, error)
ReplaceFunc searches the input string and replaces each match found using the string from the evaluator Count will limit the number of matches attempted and startAt will allow us to skip past possible matches at the start of the input (left or right depending on RightToLeft option). Set startAt and count to -1 to go through the whole string.
func (re *Regexp) RightToLeft() bool
func (re *Regexp) String() string
String returns the source text used to compile the regular expression.