Регулярное сопоставление регулярного выражения Golang

Go

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

golangстандартная библиотекаregexpОбеспечивает связанное использование регулярных выражений.

правила синтаксиса регулярного выражения

Если вы хотите использовать регулярные выражения для прямого сопоставления с образцом, чаще всего используется прямое сопоставление.regexp.Matchфункция иregexp.MatchStringфункцию или использоватьRegexpтипы и связанные с ними методы.

regexp.Match

  • определение:
func Match(pattern string, b []byte) (matched bool, err error)

Этот метод может определитьbyte sliceСоответствует ли регулярному выражению. возвращает совпадающие результаты иerror.

  • Пример:
matched, _ := regexp.Match("b", []byte("hello golang"))
fmt.Println(matched) // false

regexp.MatchString

  • определение:
func Match(pattern string, s string) (matched bool, err error)

Этот метод может определитьstringСоответствует ли регулярному выражению. возвращает совпадающие результаты иerror.

  • Пример:
matched, _ := regexp.MatchString("b", "hello golang")
fmt.Println(matched)

RegexpТипы

  • Определение типа:
type Regexp struct {}

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

RegexpМетод получения экземпляра типа, общие из нихCompileа такжеMustCompile.

Compile

Этот метод компилирует регулярное выражение и возвращает скомпилированный результат. Метод определяется как:

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

MustCompile

этот метод иCompileОчень похоже, но ошибка возникает, если компилятор не возвращает ошибку, но напрямуюpanic.

Общие методы сопоставления Regexp

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

Find

Этот метод возвращает первое совпадение[]byte.

  • определяется как:
func (re *Regexp) Find(b []byte) []byte
  • Пример:
re := regexp.MustCompile("a")
match := re.Find([]byte("hello golang"))
fmt.Println(string(match)) // a

FindAll

Этот метод возвращаетslice.

  • определяется как:
func (re *Regexp) FindAll(b []byte, n int) [][]byte

  • вернутьsliceдлина по параметруnУточнить:

    • когдаn < 0Когда , вернуть все совпадающие числа;

    • когдаn >= 0а такжеn <= 总匹配个数,вернутьnрезультат;

    • когдаn > 总匹配个数, который возвращает все результаты.

  • Пример:

re := regexp.MustCompile("l[a-z]")
match := re.FindAll([]byte("hello world, hello golang"), -1)
for _, m := range match {
	fmt.Println(string(m))
}
// ll
// ld
// ll
// la

FindString

Этот метод возвращает совпадающую строку.

  • определяется как:
func (re *Regexp) FindString (s string) string
  • Пример:
re := regexp.MustCompile("l[a-z]")
match := re.FindString("hello world, hello golang")
fmt.Println(match) // ll

FindAllString

  • определяется как:
func (re *Regexp) FindAllString(s string, n int) []string

Метод зависит от параметровn, возвращает результат сопоставления или nil, если сопоставление не удалось

  • Пример:
re := regexp.MustCompile("l[a-z]")
match := re.FindAllString("hello world, hello golang", -1)
for _, m := range match {
	fmt.Println(string(m))
}
// ll
// ld
// ll
// la

FindIndex

Этот метод возвращает позицию первого совпадения в исходной строке.

  • определяется как:
func (re *Regexp) FindIndex(b []byte) (loc []int)

loc[0]- начальная позиция результата сопоставления,loc[1]это конечная позиция результата сопоставления+1, если совпадений не найдено, вернуть пустое значениеslice.

  • Пример:
re := regexp.MustCompile("l[a-z]")
match := re.FindIndex([]byte("hello world, hello golang"))
fmt.Println(match) // [2 4]

FinAllIndex

МетодFindIndexизallверсия, основанная наnПараметр определяет количество возвращаемых результатов.

  • определяется как:
func (re *Regexp) FindAllIndex(b []byte, n int) [][]int

nиспользование см.FindAll.

  • Пример:
re := regexp.MustCompile("l[a-z]")
match := re.FindAllIndex([]byte("hello world, hello golang"), -1)
for _, m := range match {
	fmt.Println(m)
}
// [2 4] [9 11] [15 17] [21 23]

FindStringIndex

Эффект от этого метода такой же, какFindIndex, но типы передаваемых параметров отличаются.

  • определяется как:
func (re *Regexp) FindStringIndex(s string) (loc []int)

FindAllStringIndex

МетодFindStringIndexизallВерсия.

  • определяется как:
func (re *Regexp) FindAllStringIndex(s string, n int) [][]int

FindStringSubmatch

Этот метод возвращает совпадающую группу строк.

  • определяется как:
func (re *Regexp) FindStringSubmatch(s string) []string

По описанию может быть сложно понять, что делает этот метод. Вот пример:

...
re := regexp.MustCompile(`(aaa)bb(c)`)
fmt.Printf("%q\n", re.FindStringSubmatch("aaabbc"))

Возвращаемый результат:

["aaabbc", "aaa", "c"]

FindAllStringSubmatch

МетодFindStringSubmatchизallВерсия.

  • Реализовано как:
func (re *Regexp) FindAllStringSubmatch(s string, n int) [][]string

Match

Этот метод судитbyte sliceСоответствует ли регулярному выражению.

  • определение:
func (re *Regexp) Match(b []byte) bool
  • Пример:
re := regexp.MustCompile(`hello`)
match := re.Match([]byte("hello everyone"))
fmt.Println(match) // true

MatchString

Проверить, соответствует ли строка регулярному выражению.

  • определение:
func (re *Regexp) MatchString(s string) bool
  • Пример:
re := regexp.MustCompile(`hello`)
match := re.MatchString("hello everyone")
fmt.Println(match) // true

ReplaceAll

  • определяется как:
func (re *Regexp) ReplaceAll(src, repl []byte) []byte

Метод возвращаетsrcкопия , все совпадения в этой копии будутreplзаменять.

  • Пример:
re := regexp.MustCompile(`hello`)
match := re.ReplaceAll([]byte("hello everyone"), []byte("hi!"))
fmt.Println(string(match)) // hi! everyone

ReplaceAllString

  • определяется как:
func (re *Regexp) ReplaceAllString(src, repl string) string

Метод возвращаетsrcкопия , все вхождения этой копии будутreplзаменять.

  • Пример:
re := regexp.MustCompile(`hello`)
match := re.ReplaceAllString("hello everyone", "hi!")
fmt.Println(match) // hi! everyone

Split

  • определяется как:
func (re *Regexp) Split(s string, n int) []string

Этот метод использует соответствующий элемент в качестве разделителя и будетsРазделить на несколько строк и вернуть часть строк.

  • Пример:
re := regexp.MustCompile(`a`)
s := re.Split("abacadaeafff", -1)
fmt.Println(s) // ["", "b", "c", "d", "e", "fff"]

  • параметрnуправление возвращеноsliceдлина:

    • n > 0: вернуть больше всегоnстрока, последняя - оставшаяся неразрезанная часть

    • n == 0:вернутьnil

    • n < 0: вернуть все строки

Правила синтаксиса регулярных выражений

персонаж описывать
^ Соответствие строки начала позиции
$ Соответствует концу строки
* соответствует предыдущему подвыражению ноль или более раз
+ соответствует предыдущему подвыражению один или несколько раз
? соответствует предыдущему подвыражению ноль или один раз
{n} совпадение n раз
{n,} совпадение не менее n раз
{n,m} Совпадение не менее n раз и не более m раз
? Когда следует * + ? {n} {n.} {n,m}, это означает нежадное совпадение
. соответствует любому одиночному символу, кроме "\n"
x|y соответствует х или у
[xyz] соответствует любому символу, содержащемуся
[^xyz] соответствует не включенным символам
[a-z] Сопоставить диапазон символов
[^a-z] соответствует символам, не входящим в указанный диапазон
\b соответствовать границе слова
\B соответствовать границе не слова
\d соответствует числовому символу
\D соответствует нечисловому символу
\f соответствует фиду формы
\n соответствует новой строке
\r соответствует возврату каретки
\s соответствует любому символу пробела
\S соответствует любому непробельному символу
\t соответствует вкладке
\v соответствует вертикальной вкладке
\w Соответствовать любому символу слова, включая подчеркивание
\W соответствует любому символу, не являющемуся словом
Категории