package regexp

Import Path
	regexp (on golang.org and go.dev)

Dependency Relation
	imports 9 packages, and imported by 8 packages

Involved Source Files
	    backtrack.go
	    exec.go
	    onepass.go
	d-> regexp.go

Exported Type Names


	 type Regexp (struct)
		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 Longest.

		
			(*T) Copy() *Regexp
			(*T) Expand(dst []byte, template []byte, src []byte, match []int) []byte
			(*T) ExpandString(dst []byte, template string, src string, match []int) []byte
			(*T) Find(b []byte) []byte
			(*T) FindAll(b []byte, n int) [][]byte
			(*T) FindAllIndex(b []byte, n int) [][]int
			(*T) FindAllString(s string, n int) []string
			(*T) FindAllStringIndex(s string, n int) [][]int
			(*T) FindAllStringSubmatch(s string, n int) [][]string
			(*T) FindAllStringSubmatchIndex(s string, n int) [][]int
			(*T) FindAllSubmatch(b []byte, n int) [][][]byte
			(*T) FindAllSubmatchIndex(b []byte, n int) [][]int
			(*T) FindIndex(b []byte) (loc []int)
			(*T) FindReaderIndex(r io.RuneReader) (loc []int)
			(*T) FindReaderSubmatchIndex(r io.RuneReader) []int
			(*T) FindString(s string) string
			(*T) FindStringIndex(s string) (loc []int)
			(*T) FindStringSubmatch(s string) []string
			(*T) FindStringSubmatchIndex(s string) []int
			(*T) FindSubmatch(b []byte) [][]byte
			(*T) FindSubmatchIndex(b []byte) []int
			(*T) LiteralPrefix() (prefix string, complete bool)
			(*T) Longest()
			(*T) Match(b []byte) bool
			(*T) MatchReader(r io.RuneReader) bool
			(*T) MatchString(s string) bool
			(*T) NumSubexp() int
			(*T) ReplaceAll(src, repl []byte) []byte
			(*T) ReplaceAllFunc(src []byte, repl func([]byte) []byte) []byte
			(*T) ReplaceAllLiteral(src, repl []byte) []byte
			(*T) ReplaceAllLiteralString(src, repl string) string
			(*T) ReplaceAllString(src, repl string) string
			(*T) ReplaceAllStringFunc(src string, repl func(string) string) string
			(*T) Split(s string, n int) []string
			(*T) String() string
			(*T) SubexpIndex(name string) int
			(*T) SubexpNames() []string
		
			*T : fmt.Stringer
		
			func Compile(expr string) (*Regexp, error)
			func CompilePOSIX(expr string) (*Regexp, error)
			func MustCompile(str string) *Regexp
			func MustCompilePOSIX(str string) *Regexp
			func (*Regexp).Copy() *Regexp
		
			func gorm.io/gorm/logger.ExplainSQL(sql string, numericPlaceholder *Regexp, escaper string, avars ...interface{}) string

Exported Values


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


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


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


	 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.


	 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.


	 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.