Пакет regexp

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

Обзор

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

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

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

Все символы закодированы в кодировке UTF-8.

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

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

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

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

Если присутствует «String», аргументом является строка; в противном случае — срез байтов; возвращаемые значения корректируются соответственно.

Если присутствует «Submatch», возвращаемое значение — срез, определяющий последовательные подсовпадения выражения. Подсовпадения — это совпадения выражений в скобках (также известные как группы захвата) внутри регулярного выражения, пронумерованные слева направо в порядке открытия скобок. Подсовпадение 0 — это совпадение всего выражения, подсовпадение 1 — совпадение первого выражения в скобках и так далее.

Если присутствует «Index», совпадения и подсовпадения определяются парами индексов байтов во входной строке: result[2*n:2*n+2] определяет индексы n-го подсовпадения. Пара для n==0 определяет совпадение всего выражения. Если «Index» отсутствует, совпадение определяется текстом совпадения/подсовпадения. Если индекс отрицательный или текст равен null, это означает, что подвыражение не совпало ни с одной строкой во входных данных. В «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

Индекс

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

Файлы пакета

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

Функция 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`

функция MatchReader

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

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

функция 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`

функция QuoteMeta

func QuoteMeta(s string) string

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

Пример

Код:

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

Вывод:

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

тип Regexp

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

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

функция Compile

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

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

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

функция CompilePOSIX

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

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

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

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

функция MustCompile

func MustCompile(str string) *Regexp

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

функция MustCompilePOSIX

func MustCompilePOSIX(str string) *Regexp

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

функция (*Regexp) AppendText 1.24

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

AppendText реализует encoding.TextAppender. Вывод соответствует выводу метода Regexp.String.

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

функция (*Regexp) Copy 1.6

func (re *Regexp) Copy() *Regexp

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

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

функция (*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

функция (*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

функция (*Regexp) Find

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

Find возвращает срез, содержащий текст самого левого совпадения в b с регулярным выражением. Возвращаемое значение nil указывает на отсутствие совпадения.

Пример

Код:

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

Вывод:

"food"

функция (*Regexp) FindAll

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

FindAll — это версия «Все» метода Regexp.Find; она возвращает срез всех последовательных совпадений выражения, как определено в описании «Все» в комментарии пакета. Возвращаемое значение nil указывает на отсутствие совпадения.

Пример

Код:

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

Вывод:

["food" "fool"]

функция (*Regexp) FindAllIndex

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

FindAllIndex — это версия «Все» метода Regexp.FindIndex; она возвращает срез всех последовательных совпадений выражения, как определено в описании «Все» в комментарии пакета. Возвращаемое значение nil указывает на отсутствие совпадения.

Пример

Код:

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

функция (*Regexp) FindAllString

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

FindAllString — это версия «Все» метода Regexp.FindString; она возвращает срез всех последовательных совпадений выражения, как определено в описании «Все» в комментарии пакета. Возвращаемое значение nil указывает на отсутствие совпадения.

Пример

Код:

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

функция (*Regexp) FindAllStringIndex

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

FindAllStringIndex — это версия «Все» метода Regexp.FindStringIndex; она возвращает срез всех последовательных совпадений выражения, как определено в описании «Все» в комментарии пакета. Возвращаемое значение nil указывает на отсутствие совпадения.

функция (*Regexp) FindAllStringSubmatch

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

FindAllStringSubmatch — это версия «Все» метода Regexp.FindStringSubmatch; она возвращает срез всех последовательных совпадений выражения, как определено в описании «Все» в комментарии пакета. Возвращаемое значение nil указывает на отсутствие совпадения.

Пример

Код:

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

функция (*Regexp) FindAllStringSubmatchIndex

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

FindAllStringSubmatchIndex — это версия «Все» метода Regexp.FindStringSubmatchIndex; она возвращает срез всех последовательных совпадений выражения, как определено в описании «Все» в комментарии пакета. Возвращаемое значение nil указывает на отсутствие совпадения.

Пример

Код:

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

функция (*Regexp) FindAllSubmatch

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

FindAllSubmatch — это версия «Все» метода Regexp.FindSubmatch; она возвращает срез всех последовательных совпадений выражения, как определено в описании «Все» в комментарии пакета. Возвращаемое значение nil указывает на отсутствие совпадения.

Пример

Код:

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

Вывод:

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

функция (*Regexp) FindAllSubmatchIndex

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

FindAllSubmatchIndex — это версия «Все» метода Regexp.FindSubmatchIndex; она возвращает срез всех последовательных совпадений выражения, как определено в описании «Все» в комментарии пакета. Возвращаемое значение 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+)$`)
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

функция (*Regexp) FindIndex

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

FindIndex возвращает срез целых чисел из двух элементов, определяющий положение первого совпадения в b регулярного выражения. Само совпадение находится в b[loc[0]:loc[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) (loc []int)

FindReaderIndex возвращает срез целых чисел из двух элементов, определяющий положение первого совпадения регулярного выражения в тексте, считанном из io.RuneReader. Совпадение найдено в входном потоке по байтовому смещению loc[0] до loc[1]-1. Возвращаемое значение nil указывает на отсутствие совпадения.

func (*Regexp) FindReaderSubmatchIndex

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

FindReaderSubmatchIndex возвращает срез, содержащий пары индексов, определяющие первое совпадение регулярного выражения в тексте, считанном из io.RuneReader, а также совпадения, если таковые имеются, его подвыражений, как определено в описании «Подвыражение» и «Индекс» в комментарии пакета. Возвращаемое значение nil указывает на отсутствие совпадения.

func (*Regexp) FindString

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

FindString возвращает строку, содержащую текст первого совпадения в 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) (loc []int)

FindStringIndex возвращает срез целых чисел из двух элементов, определяющий положение первого совпадения в s регулярного выражения. Само совпадение находится в s[loc[0]:loc[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 возвращает срез строк, содержащих текст первого совпадения регулярного выражения в s и совпадения, если таковые имеются, его подвыражений, как определено в описании «Подвыражение» в комментарии пакета. Возвращаемое значение 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 возвращает срез, содержащий пары индексов, определяющие первое совпадение регулярного выражения в s и совпадения, если таковые имеются, его подвыражений, как определено в описаниях «Подвыражение» и «Индекс» в комментарии пакета. Возвращаемое значение nil указывает на отсутствие совпадения.

func (*Regexp) FindSubmatch

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

FindSubmatch возвращает срез срезов, содержащих текст первого совпадения регулярного выражения в b и совпадения, если таковые имеются, его подвыражений, как определено в описаниях «Подвыражение» в комментарии пакета. Возвращаемое значение 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 возвращает срез, содержащий пары индексов, определяющие первое совпадение регулярного выражения в b и совпадения, если таковые имеются, его подвыражений, как определено в описаниях «Подвыражение» и «Индекс» в комментарии пакета. Возвращаемое значение 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. Возвращает boolean true, если литеральная строка составляет всё регулярное выражение.

func (*Regexp) Longest 1.1

func (re *Regexp) Longest()

Longest заставляет будущие поиски отдавать предпочтение совпадению наибольшей длины. То есть, при сопоставлении с текстом regexp возвращает совпадение, которое начинается как можно раньше во входных данных (самое левое), и среди них выбирает совпадение, которое является максимально длинным. Этот метод изменяет 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"]

Значение count определяет количество подстрок для возврата:

• 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 для закодированного значения.

Подкаталоги