Пакет regexp

• import "regexp"
• Обзор
• Указатель
• Примеры
• Подкаталоги

Обзор

Пакет regexp реализует поиск по регулярным выражениям.

Синтаксис принимаемых регулярных выражений соответствует общему синтаксису, используемому в Perl, Python и других языках. Точнее, это синтаксис, принимаемый RE2 и описанный по адресу https://golang.org/s/re2syntax, за исключением \C. Обзор синтаксиса см. в пакете regexp/syntax.

Реализация регулярных выражений, предоставляемая этим пакетом, гарантирует выполнение за время, линейно зависящее от размера входных данных. (Это свойство не гарантируется большинством реализаций регулярных выражений с открытым исходным кодом.) Подробнее об этом свойстве см. по адресу https://swtch.com/~rsc/regexp/regexp1.html или в любой книге по теории автоматов.

Все символы — это кодовые точки в кодировке UTF-8. Согласно utf8.DecodeRune, каждый байт некорректной последовательности UTF-8 рассматривается так, как если бы он кодировал utf8.RuneError (U+FFFD).

У Regexp есть 24 метода, которые сопоставляют регулярное выражение и определяют соответствующий ему текст. Их имена соответствуют следующему регулярному выражению:

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

Варианты ‘All’ возвращают итератор по последовательным неперекрывающимся совпадениям всего выражения. Вместо этого варианты ‘FindAll’ возвращают срез этих совпадений. Пустые совпадения, примыкающие к предыдущему совпадению, игнорируются. Варианты ‘FindAll’ принимают дополнительный целочисленный аргумент n. Если n >= 0, функция возвращает не более n совпадений/подсовпадений; в противном случае она возвращает их все.

Варианты ‘Find’ возвращают только первое совпадение, которое вернул бы вариант All или FindAll.

Если присутствует ‘String’, аргумент имеет тип string; в противном случае он имеет тип []byte.

По умолчанию каждое возвращаемое совпадение представлено подстрокой, соответствующей регулярному выражению; её тип — string или []byte в зависимости от типа аргумента. Если присутствует ‘Submatch’, каждое совпадение вместо этого представлено срезом подстрок, соответствующих подвыражениям регулярного выражения, заключённым в круглые скобки (также называемым захватывающими группами), пронумерованным слева направо в порядке открывающих скобок. Submatch 0 — это совпадение всего выражения, submatch 1 — совпадение первого подвыражения в круглых скобках и так далее. Если присутствует ‘Index’, каждая подстрока вместо этого представлена парой индексов байтов во входной строке. Отрицательный индекс или nil-подстрока означает, что подвыражению не соответствует ни одна строка во входных данных. Для вариантов ‘String’ пустая строка означает либо отсутствие совпадения, либо пустое совпадение.

Некоторые методы можно применять также к тексту, считываемому из io.RuneReader: Regexp.MatchReader, Regexp.FindReaderIndex, Regexp.FindReaderSubmatchIndex. Обратите внимание, что для сопоставления регулярного выражения может потребоваться изучить текст за пределами текста, возвращённого совпадением, поэтому методы, сопоставляющие текст из io.RuneReader, могут прочитать произвольное количество входных данных перед возвратом результата.

(Есть ещё несколько методов, не соответствующих этому шаблону.)

Пример

Код:

// 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"))

Вывод:

true
true
false
false

Указатель

• func Match(pattern string, b []byte) (matched bool, err error)
• func MatchReader(pattern string, r io.RuneReader) (matched bool, err error)
• func MatchString(pattern string, s string) (matched bool, err error)
• func QuoteMeta(s string) string
• type Regexp
• func Compile(expr string) (*Regexp, error)
• func CompilePOSIX(expr string) (*Regexp, error)
• func MustCompile(str string) *Regexp
• func MustCompilePOSIX(str string) *Regexp
• func (re *Regexp) AppendText(b []byte) ([]byte, error)
• func (re *Regexp) Copy() *Regexp
• func (re *Regexp) Expand(dst []byte, template []byte, src []byte, match []int) []byte
• func (re *Regexp) ExpandString(dst []byte, template string, src string, match []int) []byte
• func (re *Regexp) Find(b []byte) []byte
• func (re *Regexp) FindAll(b []byte, n int) [][]byte
• func (re *Regexp) FindAllIndex(b []byte, n int) [][]int
• func (re *Regexp) FindAllString(s string, n int) []string
• func (re *Regexp) FindAllStringIndex(s string, n int) [][]int
• func (re *Regexp) FindAllStringSubmatch(s string, n int) [][]string
• func (re *Regexp) FindAllStringSubmatchIndex(s string, n int) [][]int
• func (re *Regexp) FindAllSubmatch(b []byte, n int) [][][]byte
• func (re *Regexp) FindAllSubmatchIndex(b []byte, n int) [][]int
• func (re *Regexp) FindIndex(b []byte) (m []int)
• func (re *Regexp) FindReaderIndex(r io.RuneReader) (m []int)
• func (re *Regexp) FindReaderSubmatchIndex(r io.RuneReader) []int
• func (re *Regexp) FindString(s string) string
• func (re *Regexp) FindStringIndex(s string) (m []int)
• func (re *Regexp) FindStringSubmatch(s string) []string
• func (re *Regexp) FindStringSubmatchIndex(s string) []int
• func (re *Regexp) FindSubmatch(b []byte) [][]byte
• func (re *Regexp) FindSubmatchIndex(b []byte) []int
• func (re *Regexp) LiteralPrefix() (prefix string, complete bool)
• func (re *Regexp) Longest()
• func (re *Regexp) MarshalText() ([]byte, error)
• func (re *Regexp) Match(b []byte) bool
• func (re *Regexp) MatchReader(r io.RuneReader) bool
• func (re *Regexp) MatchString(s string) bool
• func (re *Regexp) NumSubexp() int
• func (re *Regexp) ReplaceAll(src, repl []byte) []byte
• func (re *Regexp) ReplaceAllFunc(src []byte, repl func([]byte) []byte) []byte
• func (re *Regexp) ReplaceAllLiteral(src, repl []byte) []byte
• func (re *Regexp) ReplaceAllLiteralString(src, repl string) string
• func (re *Regexp) ReplaceAllString(src, repl string) string
• func (re *Regexp) ReplaceAllStringFunc(src string, repl func(string) string) string
• func (re *Regexp) Split(s string, n int) []string
• func (re *Regexp) String() string
• func (re *Regexp) SubexpIndex(name string) int
• func (re *Regexp) SubexpNames() []string
• func (re *Regexp) UnmarshalText(text []byte) error

Файлы пакета

backtrack.go exec.go onepass.go regexp.go

func Match

func Match(pattern string, b []byte) (matched bool, err error)

Match сообщает, содержит ли срез байтов b совпадение с шаблоном регулярного выражения. Для более сложных запросов необходимо использовать Compile и полный интерфейс Regexp.

Пример

Код:

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)

Вывод:

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

func MatchReader

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

MatchReader сообщает, содержит ли текст, возвращаемый io.RuneReader, совпадение с шаблоном регулярного выражения. Для более сложных запросов необходимо использовать Compile и полный интерфейс Regexp.

func MatchString

func MatchString(pattern string, s string) (matched bool, err error)

MatchString сообщает, содержит ли строка s совпадение с шаблоном регулярного выражения. Для более сложных запросов необходимо использовать Compile и полный интерфейс Regexp.

Пример

Код:

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)

Вывод:

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

func QuoteMeta

func QuoteMeta(s string) string

QuoteMeta возвращает строку, в которой экранированы все метасимволы регулярных выражений из текста аргумента; возвращённая строка представляет собой регулярное выражение, совпадающее с исходным текстом буквально.

Пример

Код:

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

Вывод:

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

type Regexp

Regexp — это представление скомпилированного регулярного выражения. Regexp можно безопасно использовать одновременно из нескольких горутин, за исключением методов настройки, таких как Regexp.Longest.

type Regexp struct {
    // contains filtered or unexported fields
}

func Compile

func Compile(expr string) (*Regexp, error)

Compile разбирает регулярное выражение и в случае успеха возвращает объект Regexp, который можно использовать для поиска совпадений в тексте.

При поиске в тексте regexp возвращает совпадение, которое начинается как можно раньше во входных данных (самое левое), а среди таких совпадений выбирает то, которое первым нашёл бы поиск с возвратом. Эта так называемая семантика поиска самого левого совпадения соответствует семантике Perl, Python и других реализаций, хотя этот пакет реализует её без затрат на поиск с возвратом. О поиске самого длинного из самых левых совпадений в стиле POSIX см. CompilePOSIX.

func CompilePOSIX

func CompilePOSIX(expr string) (*Regexp, error)

CompilePOSIX подобен Compile, но ограничивает синтаксис регулярных выражений стандартом POSIX ERE (egrep) и меняет семантику поиска на поиск самого длинного из самых левых совпадений.

То есть при поиске в тексте regexp возвращает совпадение, которое начинается как можно раньше во входных данных (самое левое), а среди таких совпадений выбирает самое длинное. Эта так называемая семантика поиска самого длинного из самых левых совпадений соответствует семантике ранних реализаций регулярных выражений и спецификации POSIX.

Однако самых длинных из самых левых совпадений может быть несколько, и варианты выбора подсовпадений у них могут различаться; в этом случае данный пакет отходит от POSIX. Среди возможных совпадений пакет выбирает то, которое первым нашёл бы поиск с возвратом, тогда как POSIX требует выбирать совпадение, максимизирующее длину первого подвыражения, затем второго и так далее слева направо. Правило POSIX вычислительно слишком затратное и даже не является чётко определённым. Подробности см. на странице https://swtch.com/~rsc/regexp/regexp2.html#posix.

func MustCompile

func MustCompile(str string) *Regexp

MustCompile подобен Compile, но вызывает панику, если выражение невозможно разобрать. Это упрощает безопасную инициализацию глобальных переменных, содержащих скомпилированные регулярные выражения.

func MustCompilePOSIX

func MustCompilePOSIX(str string) *Regexp

MustCompilePOSIX подобен CompilePOSIX, но вызывает панику, если выражение невозможно разобрать. Это упрощает безопасную инициализацию глобальных переменных, содержащих скомпилированные регулярные выражения.

func (*Regexp) AppendText 1.24

func (re *Regexp) AppendText(b []byte) ([]byte, error)

AppendText реализует интерфейс encoding.TextAppender. Результат совпадает с результатом вызова метода Regexp.String.

Обратите внимание, что в некоторых случаях результат содержит потери: этот метод не указывает, является ли регулярное выражение выражением POSIX (то есть было ли оно скомпилировано вызовом CompilePOSIX) и вызывался ли для него метод Regexp.Longest.

func (*Regexp) Copy 1.6

func (re *Regexp) Copy() *Regexp

Copy возвращает новый объект Regexp, скопированный из re. Вызов Regexp.Longest для одной копии не влияет на другую.

Устарело: в предыдущих версиях при использовании Regexp в нескольких горутинах создание отдельной копии для каждой горутины помогало избежать конкуренции за блокировки. Начиная с Go 1.12 использование Copy больше не требуется для предотвращения конкуренции за блокировки. Copy всё ещё может быть уместен, если он нужен для создания двух копий с разными настройками Regexp.Longest.

func (*Regexp) Expand

func (re *Regexp) Expand(dst []byte, template []byte, src []byte, match []int) []byte

Expand добавляет шаблон к dst и возвращает результат; при добавлении Expand заменяет переменные в шаблоне соответствующими совпадениями, полученными из src. Срез совпадений должен быть возвращён методом Regexp.FindSubmatchIndex.

В шаблоне переменная обозначается подстрокой вида $name или ${name}, где name — непустая последовательность букв, цифр и символов подчёркивания. Чисто числовое имя, например $1, обозначает подсовпадение с соответствующим индексом; остальные имена обозначают захватывающие скобки, именованные с помощью синтаксиса (?P<name>...). Ссылка на индекс, выходящий за допустимый диапазон или не соответствующий совпадению, либо на имя, отсутствующее в регулярном выражении, заменяется пустым срезом.

В форме $name имя считается максимально длинным: $1x эквивалентно ${1x}, а не ${1}x; $10 эквивалентно ${10}, а не ${1}0.

Чтобы вставить в результат буквальный символ $, используйте в шаблоне $$.

Пример

Код:

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

Вывод:

option1=value1
option2=value2
option3=value3

func (*Regexp) ExpandString

func (re *Regexp) ExpandString(dst []byte, template string, src string, match []int) []byte

ExpandString подобен Regexp.Expand, но шаблон и источник представлены строками. Метод добавляет данные в срез байтов и возвращает его, чтобы вызывающий код мог управлять выделением памяти.

Пример

Код:

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

Вывод:

option1=value1
option2=value2
option3=value3

func (*Regexp) Find

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

Find возвращает текст самого левого совпадения re в b. Если совпадений нет, возвращается nil.

Пример

Код:

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

Вывод:

"food"

func (*Regexp) FindAll

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

FindAll возвращает все совпадения re в b. Если n >= 0, FindAll возвращает не более n совпадений. Эквивалентную форму итератора см. в [Regexp.All].

Пример

Код:

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

Вывод:

["food" "fool"]

func (*Regexp) FindAllIndex

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

FindAllIndex возвращает позиции всех совпадений re в b. Если n >= 0, FindAllIndex возвращает не более n совпадений. См. [Regexp.AllIndex] для эквивалентной формы с итератором.

Пример

Код:

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

Вывод:

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

func (*Regexp) FindAllString

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

FindAllString возвращает все совпадения re в s. Если n >= 0, FindAllString возвращает не более n совпадений. См. [Regexp.AllString] для эквивалентной формы с итератором.

Пример

Код:

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

Вывод:

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

func (*Regexp) FindAllStringIndex

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

FindAllStringIndex возвращает позиции всех совпадений re в s. Если n >= 0, FindAllStringIndex возвращает не более n совпадений. См. [Regexp.AllStringIndex] для эквивалентной формы с итератором.

func (*Regexp) FindAllStringSubmatch

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

FindAllStringSubmatch возвращает позиции всех совпадений re в s, включая позиции подсовпадений. В каждом возвращённом совпадении m значение m[0] — это полное совпадение, m[1] — первое подсовпадение и так далее. Если n >= 0, FindAllStringSubmatch возвращает не более n совпадений. См. [Regexp.AllStringSubmatch] для эквивалентной формы с итератором.

Пример

Код:

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

Вывод:

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

func (*Regexp) FindAllStringSubmatchIndex

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

FindAllStringSubmatchIndex возвращает позиции всех совпадений re в s, включая позиции подсовпадений. В каждом возвращённом совпадении m полное совпадение — это s[m[0]:m[1]], первое подсовпадение — s[m[2]:m[3]] и так далее. Если n >= 0, FindAllStringSubmatchIndex возвращает не более n совпадений. См. [Regexp.AllStringSubmatchIndex] для эквивалентной формы с итератором.

Пример

Код:

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

Вывод:

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

func (*Regexp) FindAllSubmatch

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

FindAllSubmatch возвращает позиции всех совпадений re в b, включая позиции подсовпадений. В каждом возвращённом совпадении m полное совпадение — это m[0], первое подсовпадение — m[1] и так далее. Если n >= 0, FindAllSubmatch возвращает не более n совпадений. См. [Regexp.AllSubmatch] для эквивалентной формы с итератором.

Пример

Код:

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

Вывод:

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

func (*Regexp) FindAllSubmatchIndex

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

FindAllSubmatchIndex возвращает позиции всех совпадений re в b, включая позиции подсовпадений. В каждом возвращённом совпадении m полное совпадение — это b[m[0]:m[1]], первое подсовпадение — b[m[2]:m[3]] и так далее. Если n >= 0, FindAllSubmatchIndex возвращает не более n совпадений. См. [Regexp.AllSubmatchIndex] для эквивалентной формы с итератором.

Пример

Код:

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]]))
}

Вывод:

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

func (*Regexp) FindIndex

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

FindIndex возвращает позицию самого левого совпадения re в b. Само совпадение находится в b[m[0]:m[1]]. Если совпадений нет, возвращаемое значение равно nil.

Пример

Код:

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]]))

Вывод:

[18 33]
option1: value1

func (*Regexp) FindReaderIndex

func (re *Regexp) FindReaderIndex(r io.RuneReader) (m []int)

FindReaderIndex возвращает позицию самого левого совпадения re в r. Совпадение начинается с байтового индекса m[0] и заканчивается непосредственно перед байтовым индексом m[1]. Если совпадений нет, возвращаемое значение равно nil.

FindReaderIndex может читать произвольно далеко из r, в том числе за пределами возвращённого совпадения.

func (*Regexp) FindReaderSubmatchIndex

func (re *Regexp) FindReaderSubmatchIndex(r io.RuneReader) []int

FindReaderSubmatchIndex возвращает первое совпадение re в r, включая подсовпадения. Полное совпадение занимает байтовые индексы от m[0] до m[1], первое подсовпадение — от m[2] до m[3] и так далее. Если совпадений нет, возвращаемое значение равно nil.

FindReaderSubmatchIndex может читать произвольно далеко из r, в том числе за пределами возвращённого совпадения.

func (*Regexp) FindString

func (re *Regexp) FindString(s string) string

FindString возвращает текст самого левого совпадения re в s. Возвращаемым значением будет пустая строка как при пустом совпадении, так и при отсутствии совпадений. Чтобы различить эти случаи, используйте Regexp.FindStringIndex или Regexp.FindStringSubmatch.

Пример

Код:

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

Вывод:

"food"
""

func (*Regexp) FindStringIndex

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

FindStringIndex возвращает позицию самого левого совпадения re в s. Само совпадение находится в s[m[0]:m[1]]. Если совпадений нет, возвращаемое значение равно nil.

Пример

Код:

re := regexp.MustCompile(`ab?`)
fmt.Println(re.FindStringIndex("tablett"))
fmt.Println(re.FindStringIndex("foo") == nil)

Вывод:

[1 3]
true

func (*Regexp) FindStringSubmatch

func (re *Regexp) FindStringSubmatch(s string) []string

FindStringSubmatch возвращает первое совпадение re в s, включая подсовпадения. Полное совпадение — это s[0], первое подсовпадение — s[1] и так далее. Если совпадений нет, возвращаемое значение равно nil.

Пример

Код:

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

Вывод:

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

func (*Regexp) FindStringSubmatchIndex

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

FindStringSubmatchIndex возвращает первое совпадение re в s, включая подсовпадения. Полное совпадение — это s[m[0]:m[1]], первое подсовпадение — s[m[2]:m[3]] и так далее. Если совпадений нет, возвращаемое значение равно nil.

func (*Regexp) FindSubmatch

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

FindSubmatch возвращает первое совпадение re в b, включая подсовпадения. Полное совпадение — это m[0], первое подсовпадение — m[1] и так далее. Если совпадений нет, возвращаемое значение равно nil.

Пример

Код:

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

Вывод:

["food" "d"]

func (*Regexp) FindSubmatchIndex

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

FindSubmatchIndex возвращает первое совпадение re в b, включая подсовпадения. Полное совпадение — это b[m[0]:m[1]], первое подсовпадение — b[m[2]:m[3]] и так далее. Если совпадений нет, возвращаемое значение равно nil.

Пример

Код:

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-")))

Вывод:

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

func (*Regexp) LiteralPrefix

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

LiteralPrefix возвращает строковый литерал, с которого должно начинаться любое совпадение регулярного выражения re. Он возвращает логическое значение true, если строковый литерал составляет всё регулярное выражение.

func (*Regexp) Longest 1.1

func (re *Regexp) Longest()

Longest заставляет последующие поиски предпочитать самое левое из самых длинных совпадений. То есть при сопоставлении с текстом регулярное выражение возвращает совпадение, которое начинается как можно раньше во входных данных (самое левое), а среди таких совпадений выбирает максимально длинное. Этот метод изменяет Regexp и не может вызываться одновременно с другими методами.

Пример

Код:

re := regexp.MustCompile(`a(|b)`)
fmt.Println(re.FindString("ab"))
re.Longest()
fmt.Println(re.FindString("ab"))

Результат:

a
ab

func (*Regexp) MarshalText 1.21

func (re *Regexp) MarshalText() ([]byte, error)

MarshalText реализует encoding.TextMarshaler. Результат совпадает с результатом вызова метода Regexp.AppendText.

Дополнительные сведения см. в разделе Regexp.AppendText.

func (*Regexp) Match

func (re *Regexp) Match(b []byte) bool

Match сообщает, содержит ли срез байтов b какое-либо совпадение регулярного выражения re.

Пример

Код:

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

Результат:

true
false

func (*Regexp) MatchReader

func (re *Regexp) MatchReader(r io.RuneReader) bool

MatchReader сообщает, содержит ли текст, возвращаемый io.RuneReader, какое-либо совпадение регулярного выражения re.

func (*Regexp) MatchString

func (re *Regexp) MatchString(s string) bool

MatchString сообщает, содержит ли строка s какое-либо совпадение регулярного выражения re.

Пример

Код:

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

Результат:

false
true
true

func (*Regexp) NumSubexp

func (re *Regexp) NumSubexp() int

NumSubexp возвращает количество подвыражений в скобках в этом Regexp.

Пример

Код:

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

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

Результат:

0
4

func (*Regexp) ReplaceAll

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

ReplaceAll возвращает копию src, заменяя совпадения Regexp текстом замены repl. Внутри repl знаки $ интерпретируются так же, как в Regexp.Expand.

Пример

Код:

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")))

Результат:

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

func (*Regexp) ReplaceAllFunc

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

ReplaceAllFunc возвращает копию src, в которой все совпадения Regexp заменены значением, возвращённым функцией repl, применённой к совпавшему срезу байтов. Возвращённая repl замена подставляется напрямую, без использования Regexp.Expand.

func (*Regexp) ReplaceAllLiteral

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

ReplaceAllLiteral возвращает копию src, заменяя совпадения Regexp байтами замены repl. Замена repl подставляется напрямую, без использования Regexp.Expand.

func (*Regexp) ReplaceAllLiteralString

func (re *Regexp) ReplaceAllLiteralString(src, repl string) string

ReplaceAllLiteralString возвращает копию src, заменяя совпадения Regexp строкой замены repl. Замена repl подставляется напрямую, без использования Regexp.Expand.

Пример

Код:

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}"))

Результат:

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

func (*Regexp) ReplaceAllString

func (re *Regexp) ReplaceAllString(src, repl string) string

ReplaceAllString возвращает копию src, заменяя совпадения Regexp строкой замены repl. Внутри repl знаки $ интерпретируются так же, как в Regexp.Expand.

Пример

Код:

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"))

Результат:

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

func (*Regexp) ReplaceAllStringFunc

func (re *Regexp) ReplaceAllStringFunc(src string, repl func(string) string) string

ReplaceAllStringFunc возвращает копию src, в которой все совпадения Regexp заменены значением, возвращённым функцией repl, применённой к совпавшей подстроке. Возвращённая repl замена подставляется напрямую, без использования Regexp.Expand.

Пример

Код:

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

Результат:

SeaFooD FooL

func (*Regexp) Split 1.1

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

Split разбивает s на подстроки, разделённые выражением, и возвращает срез подстрок, расположенных между совпадениями с этим выражением.

Срез, возвращаемый этим методом, состоит из всех подстрок s, не входящих в срез, возвращаемый методом Regexp.FindAllString. При вызове для выражения, не содержащего метасимволов, метод эквивалентен strings.SplitN.

Пример:

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

Количество определяет число возвращаемых подстрок:

• n > 0: не более n подстрок; последняя подстрока будет оставшейся частью без разделения;
• n == 0: результат равен nil (ноль подстрок);
• n < 0: все подстроки.

Пример

Код:

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

Результат:

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

func (*Regexp) String

func (re *Regexp) String() string

String возвращает исходный текст, использованный для компиляции регулярного выражения.

func (*Regexp) SubexpIndex 1.15

func (re *Regexp) SubexpIndex(name string) int

SubexpIndex возвращает индекс первого подвыражения с указанным именем или -1, если подвыражения с таким именем нет.

Обратите внимание, что несколько подвыражений могут иметь одинаковое имя, как в выражении (?P<bob>a+)(?P<bob>b+), которое объявляет два подвыражения с именем "bob". В этом случае SubexpIndex возвращает индекс самого левого такого подвыражения в регулярном выражении.

Пример

Код:

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])

Результат:

true
last => 2
Turing

func (*Regexp) SubexpNames

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

SubexpNames возвращает имена подвыражений в скобках в этом Regexp. Имя первого подвыражения находится в names[1], поэтому, если m — срез совпадений, имя для m[i] находится в SubexpNames()[i]. Поскольку всему Regexp нельзя присвоить имя, names[0] всегда является пустой строкой. Не следует изменять этот срез.

Пример

Код:

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

Результат:

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

func (*Regexp) UnmarshalText 1.21

func (re *Regexp) UnmarshalText(text []byte) error

UnmarshalText реализует encoding.TextUnmarshaler, вызывая Compile для закодированного значения.

Подкаталоги