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

Введение

В этом практическом занятии показано, как использовать регулярные выражения в Golang.

Skills Graph

Регулярные выражения

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

• Используйте пакет regexp для выполнения задач, связанных с регулярными выражениями.
• Используйте MatchString, чтобы проверить, соответствует ли строка шаблону.
• Используйте Compile, чтобы оптимизировать структуру Regexp.
• Используйте MatchString, чтобы проверить соответствие, как Compile.
• Используйте FindString, чтобы найти соответствие для регулярного выражения.
• Используйте FindStringIndex, чтобы найти первое соответствие и вернуть индексы начала и конца соответствия вместо совпадающего текста.
• Используйте FindStringSubmatch, чтобы вернуть информацию для обоих p([a-z]+)ch и ([a-z]+).
• Используйте FindStringSubmatchIndex, чтобы вернуть информацию о индексах совпадений и подсовпадений.
• Используйте FindAllString, чтобы найти все совпадения для регулярного выражения.
• Используйте FindAllStringSubmatchIndex, чтобы применить к всем совпадениям в вводе, а не только к первому.
• Используйте Match, чтобы проверить соответствие с аргументами []byte и убрать String из имени функции.
• Используйте MustCompile, чтобы создать глобальные переменные с регулярными выражениями.
• Используйте ReplaceAllString, чтобы заменить подмножества строк на другие значения.
• Используйте ReplaceAllFunc, чтобы преобразовать совпадающий текст с помощью заданной функции.

## Для получения полного справочника по регулярным выражениям в Go проверьте
## документацию по пакету [`regexp`](https://pkg.go.dev/regexp).

Ниже представлен полный код:

// Go предоставляет встроенную поддержку для [регулярных выражений](https://en.wikipedia.org/wiki/Regular_expression).
// Вот некоторые примеры распространенных задач, связанных с регулярными выражениями
// в Go.

package main

import (
	"bytes"
	"fmt"
	"regexp"
)

func main() {

	// Это проверяет, соответствует ли строка шаблону.
	match, _ := regexp.MatchString("p([a-z]+)ch", "peach")
	fmt.Println(match)

	// Выше мы напрямую использовали строковый шаблон, но для
	// других задач с регулярными выражениями вам понадобится `Compile`
	// оптимизированную структуру `Regexp`.
	r, _ := regexp.Compile("p([a-z]+)ch")

	// На этих структурах доступно много методов. Вот
	// тест соответствия, как мы видели ранее.
	fmt.Println(r.MatchString("peach"))

	// Это находит соответствие для регулярного выражения.
	fmt.Println(r.FindString("peach punch"))

	// Это также находит первое соответствие, но возвращает
	// индексы начала и конца соответствия вместо
	// совпадающего текста.
	fmt.Println("idx:", r.FindStringIndex("peach punch"))

	// Варианты `Submatch` включают информацию о
	// совпадениях по всему шаблону и подсовпадениях
	// внутри этих совпадений. Например, это вернет
	// информацию для обоих `p([a-z]+)ch` и `([a-z]+)`.
	fmt.Println(r.FindStringSubmatch("peach punch"))

	// Аналогично это вернет информацию о
	// индексах совпадений и подсовпадений.
	fmt.Println(r.FindStringSubmatchIndex("peach punch"))

	// Варианты `All` этих функций применяются ко всем
	// совпадениям в вводе, а не только к первому. Например, чтобы найти все совпадения для регулярного выражения.
	fmt.Println(r.FindAllString("peach punch pinch", -1))

	// Эти варианты `All` также доступны для других
	// функций, которые мы видели выше.
	fmt.Println("all:", r.FindAllStringSubmatchIndex(
		"peach punch pinch", -1))

	// Передача неотрицательного целого числа в качестве второго
	// аргумента для этих функций ограничивает количество
	// совпадений.
	fmt.Println(r.FindAllString("peach punch pinch", 2))

	// Наши примеры выше имели строковые аргументы и использовали
	// имена, такие как `MatchString`. Мы также можем передать
	// аргументы `[]byte` и убрать `String` из имени функции.
	fmt.Println(r.Match([]byte("peach")))

	// При создании глобальных переменных с регулярными
	// выражениями вы можете использовать вариант `MustCompile`
	// от `Compile`. `MustCompile` завершает работу с ошибкой вместо
	// возврата ошибки, что делает его безопаснее для использования
	// в глобальных переменных.
	r = regexp.MustCompile("p([a-z]+)ch")
	fmt.Println("regexp:", r)

	// Пакет `regexp` также можно использовать для замены
	// подмножеств строк на другие значения.
	fmt.Println(r.ReplaceAllString("a peach", "<fruit>"))

	// Вариант `Func` позволяет преобразовать совпадающий
	// текст с помощью заданной функции.
	in := []byte("a peach")
	out := r.ReplaceAllFunc(in, bytes.ToUpper)
	fmt.Println(string(out))
}

Резюме

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