Regex (Expression régulière) du langage Go

Le paquet Regex Go est utilisé pour rechercher des chaînes de caractères. Pour rechercher une chaîne de caractères, nous devons fournir un modèle de chaîne de caractères.

Nous devons compiler le schéma dans l'objet regex afin que nous puissions appeler les méthodes à travers lui.

Il est possible d'utiliser les fonctions compile() et mustcompile() pour récupérer l'objet d'expression régulière. Maintenant, nous pouvons utiliser les fonctions pour rechercher des chaînes de caractères, par exemple FindString(), FindStringSubmatch(), FindStringIndex() et autres.

Exemple d'expression régulière1

Exemple

package main
import (
	"fmt"
	"regexp"
)
func main() {
	re　:=　regexp.MustCompile(".com")
	fmt.Println(re.FindString("oldtoolbag.com"))
	fmt.Println(re.FindString("abc.org"))
	fmt.Println(re.FindString("fb.com"))
}

Sortie :

.com
.com

La méthode FindString() renvoie une chaîne de caractères contenant le texte correspondant le plus à gauche. Si aucun correspondant n'est trouvé, elle renvoie une chaîne de caractères vide.

Exemple d'expression régulière2

Exemple

package main
import (
	"fmt"
	"regexp"
)
func main() {
	re　:=　regexp.MustCompile(".com")
	fmt.Println(re.FindStringIndex("google.com"))
	fmt.Println(re.FindStringIndex("abc.org"))
	fmt.Println(re.FindStringIndex("fb.com"))
}

Sortie :

[6　10]
[]
[2　6]

Exemple d'expression régulière3

Nous pouvons également utiliser la méthode FindStringSubmatch(), qui renvoie un tableau de chaînes de caractères contenant le correspondant le plus à gauche et le texte du correspondant. Si aucun correspondant n'est trouvé, le retour est une chaîne de caractères vide.

Exemple

package main
import (
	"fmt"
	"regexp"
)
func main() {
	re　:=　regexp.MustCompile("f([a-z]+)ing")
	fmt.Println(re.FindStringSubmatch("flying"))
	fmt.Println(re.FindStringSubmatch("abcfloatingxyz"))
}

Sortie :

[volant ly]
[flottant loat]
Processus terminé avec le code de sortie 0

Méthodes couramment utilisées du paquet regexp de la bibliothèque regexp du langage go

Pour la correspondance des expressions régulières en langage go, vous pouvez utiliser le paquet regexp du langage go. 　

Les expressions régulières en langage go suivent les mêmes règles que les expressions régulières d'autres langages, mais les fonctions appelées sont différentes 　　

Il est recommandé d'utiliser le format `pattern` lors de la construction d'expressions régulières.

regexp.Match

//　Déterminer si une sous-chaîne correspondante à l'expression régulière pattern peut être trouvée dans b
//　pattern: l'expression régulière à rechercher
//　b : la chaine de caractères []byte dans laquelle il faut rechercher
//　matched: retourne si un élément correspondant a été trouvé
//　err: retourne toute erreur rencontrée pendant la recherche
//　Cette fonction est implémentée en appelant la méthode Regexp
func Match(pattern string, b []byte) (matched bool, err error)

Exemple en ligne

package main
　
import (
　　　　"fmt"
　　　　"regexp"
)
　
func main() {
　　　　matched, err := regexp.Match("^abc.*z$", []byte("abcdefgz"))
　　　　fmt.Println(matched, err)　//true nil
　
　　　　matched, err = regexp.Match("^abc.*z$", []byte("bcdefgz"))
　　　　fmt.Println(matched, err)　//false nil
}

regexp.MatchString

//　Déterminer si une sous-chaîne correspondante à l'expression régulière pattern peut être trouvée dans s
　//　pattern: l'expression régulière à rechercher
　//　r: la chaîne dans laquelle la recherche doit être effectuée
　//　matched: retourne si un élément correspondant a été trouvé
　//　err: retourne toute erreur rencontrée pendant la recherche
　//　Cette fonction est implémentée en appelant la méthode Regexp
　
　func MatchString(pattern string, s string) (matched bool, err error)

Exemple en ligne

package main
　
import (
　　　　"fmt"
　　　　"regexp"
)
　
func main() {
　　　　matched, err := regexp.MatchString("^abc.*z$", "abcdefgz")
　　　　fmt.Println(matched, err)　//true <nil>
　
　　　　matched, err = regexp.MatchString("^abc.*z$", "bcdefgz")
　　　　fmt.Println(matched, err)　//false <nil>
}

regexp.Compile

//　Compile est utilisé pour analyser si l'expression régulière expr est valide, et si elle est valide, elle retourne un objet Regexp
//　L'objet Regexp peut exécuter les opérations nécessaires sur tout texte
func Compile(expr string) (*Regexp, error)

Retourne un pointeur sur un objet regexp qui a implementé, vous pouvez utiliser la valeur de retour pour appeler les méthodes définies dans regexp, telles que Match, MatchString, find, etc.

Exemple en ligne

//func Compile(expr string) (*Regexp, error)
r, _ := regexp.Compile(`f([a-z]+)`)
　
//func (re　*Regexp) Matche(b []byte) bool
fmt.Println(r.Match([]byte("foo")))　//true
　
//func (re　*Regexp) MatcheChaine(s string) bool
fmt.Println(r.MatchString("foo"))　//true
　
//func (re　*Regexp) FindString(s string) string
//Seulement une correspondance
fmt.Println(r.FindString("foo　func"))　//foo
　
//func (re　*Regexp)　FindStringIndex(s　string)　(loc　[]int)
fmt.Println(r.FindStringIndex("demo　foo　func"))　//[5　8]
　
//func (re　*Regexp) FindStringSubmatch(s string) []string
//Matchez une seule fois, dans le résultat de la correspondance, la valeur à l'indice 0 est la valeur de la chaîne de caractères correspondante entière, et la valeur à l'indice 2 est la valeur de l'expression régulière sous-exprimée
fmt.Println(r.FindStringSubmatch("this　foo　func　fan"))　//[foo　oo]
　
//Pour FindStringSubmatch, si l'expression régulière n'a pas de sous-expression, le sous-expression n'est pas vérifié
demo,　_　:=　regexp.Compile(`foo`)
fmt.Println(demo.FindStringSubmatch("foo"))　//[foo]
　
//func (re　*Regexp) FindStringSubmatchIndex(s string) []int
fmt.Println(r.FindStringSubmatchIndex("foo　func"))　//[0　3　1　3]
　
//func (re　*Regexp)　FindAllString(s　string,　n　int)　[]string
//n est-1représente que toutes les chaînes de caractères correspondantes sont matchées, n n'est pas-1représente que seules les n correspondances sont effectuées
fmt.Println(r.FindAllString("foo　func　fan",　-1))　//[foo　func　fan]
fmt.Println(r.FindAllString("foo　func　fan",　2))　　//[foo　func]
　
//func (re　*Regexp) FindAllStringSubmatchIndex(s string, n int) [][]int
//n représente également le nombre de correspondances-1représente la recherche de tous
fmt.Println(r.FindAllStringSubmatchIndex("foo　func　demo　fan",　-1))
//[[0　3　1　3]] [4　8　5　8]] [14　17　15　17]]
　
//Remplacement
　
//func (re　*Regexp) ReplaceAll(src []byte, repl []byte) []byte
fmt.Println(string(r.ReplaceAll([]byte("this　is　foo,　that　is　func,　they　are　fan"),　[]byte("x"))))
//this　is　x,　that　is　x,　they　are　x
　
//func (re　*Regexp) ReplaceAllString(src string, repl string) string
fmt.Println(r.ReplaceAllString("this　is　foo,　that　is　func,　they　are　fan",　"xx"))

regexp.MustCompile a une utilisation similaire à regexp.Compile

Détails du paquet d'expressions régulières regexp en langage Go

//　Détails de regexp.go
------------------------------------------------------------
1.Vérifiez si vous pouvez trouver la sous-chaîne correspondante de l'expression régulière pattern dans []byte
//　pattern: l'expression régulière à rechercher
//　b : la chaine de caractères []byte dans laquelle il faut rechercher
//　matched: retourne si un élément correspondant a été trouvé
//　err: retourne toute erreur rencontrée pendant la recherche
//　Cette fonction est implémentée en appelant la méthode Regexp
func Match(pattern string, b []byte) (matched bool, err error)
func main() {
fmt.Println(regexp.Match("H.*　", []byte("Hello World!")))
//　true
}
------------------------------------------------------------
2. Juge si une sous-chaîne correspondante peut être trouvée dans r avec l'expression régulière pattern
//　pattern: l'expression régulière à rechercher
//　r: l'interface RuneReader où la recherche doit être effectuée
//　matched: retourne si un élément correspondant a été trouvé
//　err: retourne toute erreur rencontrée pendant la recherche
//　Cette fonction est implémentée en appelant la méthode Regexp
func MatchReader(pattern string, r io.RuneReader) (matched bool, err error)
func main() {
r := bytes.NewReader([]byte("Hello　World!"))
fmt.Println(regexp.MatchReader("H.*　", r))
//　true
}
------------------------------------------------------------
3. Juge si une sous-chaîne correspondante peut être trouvée dans s avec l'expression régulière pattern
//　pattern: l'expression régulière à rechercher
//　r: la chaîne dans laquelle la recherche doit être effectuée
//　matched: retourne si un élément correspondant a été trouvé
//　err: retourne toute erreur rencontrée pendant la recherche
//　Cette fonction est implémentée en appelant la méthode Regexp
func MatchString(pattern string, s string) (matched bool, err error)
func main() {
fmt.Println(regexp.Match("H.*　", "Hello World!"))
//　true
}
------------------------------------------------------------
4. QuoteMeta convertit les "caractères spéciaux" de la chaîne s en leur "format d'échappement"
//　Par exemple, QuoteMeta(`[foo]`) retourne `
foo
`。
//　Les caractères spéciaux incluent : \.+*?()|[]{}^$
//　Ces caractères sont utilisés pour implémenter la syntaxe régulière, donc ils doivent être convertis lorsqu'ils sont utilisés comme caractères normaux
func QuoteMeta(s string) string
func main() {
fmt.Println(regexp.QuoteMeta("(?P:Hello)　[a-z]"))
//　\?P:Hello
a−z
}
------------------------------------------------------------
5.Regexp structure représente une expression régulière compilée
//　Les interfaces publiques de Regexp sont implémentées par des méthodes
//　L'utilisation concurrente de plusieurs goroutine avec un seul RegExp est sécurisée
type Regexp struct {
//　Champs privés
}
//　Par l'intermédiaire de Complite, CompilePOSIX, MustCompile, MustCompilePOSIX
//　Les quatre fonctions peuvent créer un objet Regexp.
------------------------------------------------------------
6La fonction .Compile est utilisée pour vérifier si l'expression régulière expr est valable. Si elle est valable, elle retourne un objet Regexp.
//　L'objet Regexp peut exécuter les opérations nécessaires sur tout texte
func Compile(expr string) (*Regexp, error)
func main() {
reg, err := regexp.Compile(`\w+`)
fmt.Printf("%q,%v\n", reg.FindString("Hello World!"), err)
//　"Hello"
}
------------------------------------------------------------
7.CompilePOSIX a la même fonction que Compile
//　La différence est que CompilePOSIX utilise la syntaxe POSIX
//　En même temps, il utilise la méthode de recherche la plus longue à gauche
//　Tandis que Compile utilise la méthode de recherche la plus courte à gauche
//　La syntaxe POSIX ne supporte pas les formats de syntaxe Perl : \d、\D、\s、\S、\w、\W
func CompilePOSIX(expr string) (*Regexp, error)
func main() {
reg, err := regexp.CompilePOSIX(`[[:word:]]+`)
fmt.Printf("%q,%v\n", reg.FindString("Hello World!"), err)
//　"Hello"
}
------------------------------------------------------------
8.MustCompile a la même fonction que Compile
//　La différence est que, lorsque l'expression régulière str est invalide, MustCompile lève une exception
//　Tandis que Compile ne retourne qu'une valeur error
func MustCompile(str string)　*Regexp
func main() {
reg　:=　regexp.MustCompile(`\w+`)
fmt.Println(reg.FindString("Hello　World!"))
//　Hello
}
------------------------------------------------------------
9.MustCompilePOSIX a la même fonction que CompilePOSIX
//　La différence est que, lorsque l'expression régulière str est invalide, MustCompilePOSIX lève une exception
//　Tandis que CompilePOSIX ne retourne qu'une valeur error
func MustCompilePOSIX(str string)　*Regexp
func main() {
reg := regexp.MustCompilePOSIX(`[[:word:]].+　`)
fmt.Printf("%q\n", reg.FindString("Hello World!"))
//　"Hello"
}
------------------------------------------------------------
10Dans []byte, cherche l'expression régulière compilée dans re et retourne le premier contenu correspondant
func (re　*Regexp) Find(b []byte) []byte
func main() {
reg　:=　regexp.MustCompile(`\w+`)
fmt.Printf("%q", reg.Find([]byte("Hello World!")))
//　"Hello"
}
------------------------------------------------------------
11Dans string, cherche l'expression régulière compilée dans re et retourne le premier contenu correspondant
func (re　*Regexp) FindString(s string) string
func main() {
reg　:=　regexp.MustCompile(`\w+`)
fmt.Println(reg.FindString("Hello　World!"))
//　"Hello"
}
------------------------------------------------------------
12.在　[]byte　中查找　re　中编译好的正则表达式，并返回所有匹配的内容
//　{{匹配项},　{匹配项},　...}
//　Ne cherche que les n premiers éléments correspondants, si n < 0, recherche tous les éléments correspondants
func (re　*Regexp)　FindAll(b　[]byte,　n　int)　[][]byte
func main() {
reg　:=　regexp.MustCompile(`\w+`)
fmt.Printf("%q",　reg.FindAll([]byte("Hello　World!"),　-1))
//　["Hello"　"World"]
}
------------------------------------------------------------
13Recherche de toutes les correspondances de l'expression régulière compilée dans 're' dans la chaîne 'string'.
//　{匹配项,　匹配项,　...}
//　Ne cherche que les n premiers éléments correspondants, si n < 0, recherche tous les éléments correspondants
func (re　*Regexp)　FindAllString(s　string,　n　int)　[]string
func main() {
reg　:=　regexp.MustCompile(`\w+`)
fmt.Printf("%q",　reg.FindAllString("Hello　World!",　-1))
//　["Hello"　"World"]
}
------------------------------------------------------------
14.　在　[]byte　中查找　re　中编译好的正则表达式，并返回第一个匹配的位置
//　{起始位置,　结束位置}
func (re　*Regexp)　FindIndex(b　[]byte)　(loc　[]int)
func main() {
reg　:=　regexp.MustCompile(`\w+`)
fmt.Println(reg.FindIndex([]byte("Hello　World!")))
//　[0　5]
}
------------------------------------------------------------
15.　在　string　中查找　re　中编译好的正则表达式，并返回第一个匹配的位置
//　{起始位置,　结束位置}
func (re　*Regexp)　FindStringIndex(s　string)　(loc　[]int)
func main() {
reg　:=　regexp.MustCompile(`\w+`)
fmt.Println(reg.FindStringIndex("Hello　World!"))
//　[0　5]
}
------------------------------------------------------------
16.Recherche dans r des positions de l'expression régulière compilée dans re et retourne la première position de correspondance
//　{起始位置,　结束位置}
func (re　*Regexp)　FindReaderIndex(r　io.RuneReader)　(loc　[]int)
func main() {
r := bytes.NewReader([]byte("Hello　World!"))
reg　:=　regexp.MustCompile(`\w+`)
fmt.Println(reg.FindReaderIndex(r))
//　[0　5]
}
------------------------------------------------------------
17.Recherche dans []byte des positions de l'expression régulière compilée dans re et retourne toutes les positions de correspondance
//　{{起始位置,　结束位置},　{起始位置,　结束位置},　...}
//　Ne cherche que les n premiers éléments correspondants, si n < 0, recherche tous les éléments correspondants
func (re　*Regexp)　FindAllIndex(b　[]byte,　n　int)　[][]int
func main() {
reg　:=　regexp.MustCompile(`\w+`)
fmt.Println(reg.FindAllIndex([]byte("Hello　World!"),　-1))
//　[[0　5]] [6　11]]
}
------------------------------------------------------------
18.Recherche dans string des positions de l'expression régulière compilée dans re et retourne toutes les positions de correspondance
//　{{起始位置,　结束位置},　{起始位置,　结束位置},　...}
//　Ne cherche que les n premiers éléments correspondants, si n < 0, recherche tous les éléments correspondants
func (re　*Regexp)　FindAllStringIndex(s　string,　n　int)　[][]int
func main() {
reg　:=　regexp.MustCompile(`\w+`)
fmt.Println(reg.FindAllStringIndex("Hello　World!",　-1))
//　[[0　5]] [6　11]]
}
------------------------------------------------------------
19Recherche du contenu de la première correspondance de l'expression régulière compilée dans 're' dans la chaîne '[]byte'.
//　retourne également le contenu de la correspondance de l'expression sous
//　{{item de correspondance complet}, {item de correspondance sous}, {item de correspondance sous}, ...}
func (re　*Regexp) FindSubmatch(b []byte) [][]byte
func main() {
reg := regexp.MustCompile(`(\w)(\w)+`)
fmt.Printf("%q", reg.FindSubmatch([]byte("Hello　World!")))
//　["Hello"　"H"　"o"]
}
------------------------------------------------------------
20. Recherche du contenu de la première correspondance de l'expression régulière compilée dans 're' dans la chaîne 'string'.
//　retourne également le contenu de la correspondance de l'expression sous
//　{item de correspondance complet, item de correspondance sous, item de correspondance sous, ...}
func (re　*Regexp) FindStringSubmatch(s string) []string
func main() {
reg := regexp.MustCompile(`(\w)(\w)+`)
fmt.Printf("%q", reg.FindStringSubmatch("Hello　World!"))
//　["Hello"　"H"　"o"]
}
------------------------------------------------------------
21Recherche de toutes les correspondances de l'expression régulière compilée dans 're' dans la chaîne '[]byte'.
//　retourne également le contenu de la correspondance de l'expression sous
//　{
//　{{item de correspondance complet}, {item de correspondance sous}, {item de correspondance sous}, ...},
//　{{item de correspondance complet}, {item de correspondance sous}, {item de correspondance sous}, ...},
//　...
//　}
func (re　*Regexp) FindAllSubmatch(b []byte, n int) [][][]byte
func main() {
reg := regexp.MustCompile(`(\w)(\w)+`)
fmt.Printf("%q", reg.FindAllSubmatch([]byte("Hello　World!"),　-1))
//　[["Hello"　"H"　"o"]　["World"　"W"　"d"]]
}
------------------------------------------------------------
22Recherche de toutes les correspondances de l'expression régulière compilée dans 're' dans la chaîne 'string'.
//　retourne également le contenu de la correspondance de l'expression sous
//　{
//　{item de correspondance complet, item de correspondance sous, item de correspondance sous, ...},
//　{item de correspondance complet, item de correspondance sous, item de correspondance sous, ...},
//　...
//　}
//　Ne cherche que les n premiers éléments correspondants, si n < 0, recherche tous les éléments correspondants
func (re　*Regexp) FindAllStringSubmatch(s string, n int) [][]string
func main() {
reg := regexp.MustCompile(`(\w)(\w)+`)
fmt.Printf("%q", reg.FindAllStringSubmatch("Hello　World!",　-1))
//　[["Hello"　"H"　"o"]　["World"　"W"　"d"]]
}
------------------------------------------------------------
23Recherche de la position de la première correspondance de l'expression régulière compilée dans 're' dans la chaîne '[]byte'.
//　retourne également les positions des sous-expressions
//　{début de l'élément complet, fin de l'élément complet, début de l'élément sous, fin de l'élément sous, début de l'élément sous, fin de l'élément sous, ...}
func (re　*Regexp) FindSubmatchIndex(b []byte) []int
func main() {
reg := regexp.MustCompile(`(\w)(\w)+`)
fmt.Println(reg.FindSubmatchIndex([]byte("Hello　World!")))
//　[0　5　0　1　4　5]
}
------------------------------------------------------------
24Recherche de la position de la première correspondance de l'expression régulière compilée dans 're' dans la chaîne 'string'.
//　retourne également les positions des sous-expressions
//　{début de l'élément complet, fin de l'élément complet, début de l'élément sous, fin de l'élément sous, début de l'élément sous, fin de l'élément sous, ...}
func (re　*Regexp) FindStringSubmatchIndex(s string) []int
func main() {
reg := regexp.MustCompile(`(\w)(\w)+`)
fmt.Println(reg.FindStringSubmatchIndex("Hello　World!"))
//　[0　5　0　1　4　5]
}
------------------------------------------------------------
25.Recherche dans r des positions de l'expression régulière compilée dans re et retourne la première position de correspondance
//　retourne également les positions des sous-expressions
//　{début de l'élément complet, fin de l'élément complet, début de l'élément sous, fin de l'élément sous, début de l'élément sous, fin de l'élément sous, ...}
func (re　*Regexp) FindReaderSubmatchIndex(r io.RuneReader) []int
func main() {
r := bytes.NewReader([]byte("Hello　World!"))
reg := regexp.MustCompile(`(\w)(\w)+`)
fmt.Println(reg.FindReaderSubmatchIndex(r))
//　[0　5　0　1　4　5]
}
------------------------------------------------------------
26.Recherche dans []byte des positions de l'expression régulière compilée dans re et retourne toutes les positions de correspondance
//　retourne également les positions des sous-expressions
//　{
//　{début de l'élément complet, fin de l'élément complet, début de l'élément sous, fin de l'élément sous, début de l'élément sous, fin de l'élément sous, ...},
//　{début de l'élément complet, fin de l'élément complet, début de l'élément sous, fin de l'élément sous, début de l'élément sous, fin de l'élément sous, ...},
//　...
//　}
//　Ne cherche que les n premiers éléments correspondants, si n < 0, recherche tous les éléments correspondants
func (re　*Regexp) FindAllSubmatchIndex(b []byte, n int) [][]int
func main() {
reg := regexp.MustCompile(`(\w)(\w)+`)
fmt.Println(reg.FindAllSubmatchIndex([]byte("Hello　World!"),　-1))
//　[[0　5　0　1　4　5]] [6　11　6　7　10　11]]
}
------------------------------------------------------------
27.Recherche dans string des positions de l'expression régulière compilée dans re et retourne toutes les positions de correspondance
//　retourne également les positions des sous-expressions
//　{
//　{début de l'élément complet, fin de l'élément complet, début de l'élément sous, fin de l'élément sous, début de l'élément sous, fin de l'élément sous, ...},
//　{début de l'élément complet, fin de l'élément complet, début de l'élément sous, fin de l'élément sous, début de l'élément sous, fin de l'élément sous, ...},
//　...
//　}
//　Ne cherche que les n premiers éléments correspondants, si n < 0, recherche tous les éléments correspondants
func (re　*Regexp) FindAllStringSubmatchIndex(s string, n int) [][]int
func main() {
reg := regexp.MustCompile(`(\w)(\w)+`)
fmt.Println(reg.FindAllStringSubmatchIndex("Hello　World!",　-1))
//　[[0　5　0　1　4　5]] [6　11　6　7　10　11]]
}
-----------------------------------------------------------
30. Ajouter le contenu du template traité à la fin de dst
//　le template doit contenir $1、$2}, ${name1}, ${name2comme ce "séparateur de groupe"}
//　match est le résultat retourné par la méthode FindSubmatchIndex, qui contient des informations sur les positions de chaque groupe
//　Si le template contient un "séparateur de groupe", il s'agit de match comme norme,
//　Extraire la sous-chaîne correspondante dans src et la remplacer par $ dans le template1、$2　etc. les symboles de citation.
func (re　*Regexp) Expand(dst []byte, template []byte, src []byte, match []int) []byte
func main() {
reg := regexp.MustCompile(`(\w+),(\w+)`)
src := []byte("Golang,World!")　//　Texte source
dst := []byte("Say:")　//　Texte cible
template := []byte("Hello $1, Hello $2")　//　Modèle
match := reg.FindSubmatchIndex(src)　//　Analyser le texte source
//　Remplir le modèle et ajouter le modèle à la chaîne de destination
fmt.Printf("%q", reg.Expand(dst, template, src, match))
//　"Say: Hello Golang, Hello World"
}
------------------------------------------------------------
31.La fonction est la même que Expand, mais les paramètres sont de type string
func (re　*Regexp) ExpandString(dst []byte, template string, src string, match []int) []byte
func main() {
reg := regexp.MustCompile(`(\w+),(\w+)`)
src := "Golang,World!"　//　Texte source
dst := []byte("Say:")　//　Texte cible (écritable)
template := "Hello $1, Hello $2"　//　Modèle
match := reg.FindStringSubmatchIndex(src)　//　Analyser le texte source
//　Remplir le modèle et ajouter le modèle à la chaîne de destination
fmt.Printf("%q", reg.ExpandString(dst, template, src, match))
//　"Say: Hello Golang, Hello World"
}
------------------------------------------------------------
32. LiteralPrefix retourne le préfixe commun à toutes les correspondances (en supprimant les éléments variables)
//　prefix：préfixe commun
//　complete：si prefix est la même que l'expression régulière elle-même, retourne true, sinon retourne false
func (re　*Regexp) LiteralPrefix() (prefix string, complete bool)
func main() {
reg := regexp.MustCompile(`Hello[\w\s]+`)
fmt.Println(reg.LiteralPrefix())
//　Hello false
reg = regexp.MustCompile(`Hello`)
fmt.Println(reg.LiteralPrefix())
//　Hello true
}
------------------------------------------------------------
33. Passer au "mode gourmand"
func (re　*Regexp) Longest()
func main() {
text := `Hello World,　123　Go!`
pattern := `(?U)H[\w\s]+o`　//　Marque régulière "mode non gourmand" (?U)
reg := regexp.MustCompile(pattern)
fmt.Printf("%q\n", reg.TrouveChaine(text))
//　Hello
reg.Longest()　//　Passer au "mode gourmand"
fmt.Printf("%q\n", reg.TrouveChaine(text))
//　Hello Wo
}
------------------------------------------------------------
34. Vérifier si une correspondance peut être trouvée dans b
func (re　*Regexp) Matche(b []byte) bool
func main() {
b := []byte(`Hello World`)
reg := regexp.MustCompile(`Hello\w+`)
fmt.Println(reg.Matche(b))
//　false
reg = regexp.MustCompile(`Hello[\w\s]+`)
fmt.Println(reg.Matche(b))
//　true
}
------------------------------------------------------------
35. Vérifier si une correspondance peut être trouvée dans r
func (re　*Regexp) MatcheLecteur(r io.RuneReader) bool
func main() {
r := bytes.NewReader([]byte(`Hello World`))
reg := regexp.MustCompile(`Hello\w+`)
fmt.Println(reg.MatcheLecteur(r))
//　false
r.Seek(0, 0)
reg = regexp.MustCompile(`Hello[\w\s]+`)
fmt.Println(reg.MatcheLecteur(r))
//　true
}
------------------------------------------------------------
36. Vérifier si une correspondance peut être trouvée dans s
func (re　*Regexp) MatcheChaine(s string) bool
func main() {
s := `Hello World`
reg := regexp.MustCompile(`Hello\w+`)
fmt.Println(reg.MatcheChaine(s))
//　false
reg = regexp.MustCompile(`Hello[\w\s]+`)
fmt.Println(reg.MatcheChaine(s))
//　true
}
------------------------------------------------------------
37. Compter le nombre de groupes dans l'expression régulière (sans les groupes non capturés)
func (re　*Regexp) NbGroup() int
func main() {
reg := regexp.MustCompile(`(?U)(?:Hello)(\s+)\w+)`)
fmt.Println(reg.NbGroup())
//　2
}
------------------------------------------------------------
38.Recherche des correspondances dans src et remplacement par le contenu spécifié par repl
//　全部替换，并返回替换后的结果
func (re　*Regexp) RemplacerToutesLesChaines(src, repl []byte) []byte
func main() {
b := []byte("Hello World,　123　Go!")
reg := regexp.MustCompile(`(Hell|G)o`)
rep := []byte("${1}"
fmt.Printf("%q\n", reg.RemplacerToutesLesChaines(b, rep))
//　"Hellooo World,　123　Gooo!"
}
------------------------------------------------------------
39.Recherche des correspondances dans src et remplacement par le contenu spécifié par repl
//　全部替换，并返回替换后的结果
func (re　*Regexp) RemplacerToutesLesChaines(src, repl string) string
func main() {
s := "Hello World,　123　Go!"
reg := regexp.MustCompile(`(Hell|G)o`)
rep := "${1}"
fmt.Printf("%q\n", reg.ReplaceAllString(s, rep))
//　"Hellooo World,　123　Gooo!"
}
-----------------------------------------------------------
40. Recherche des correspondances dans src et remplacement par le contenu spécifié par repl
//　Si repl contient le "symbole de groupement" (\$)1、$name），则将“分组引用符”当普通字符处理
//　全部替换，并返回替换后的结果
func (re　*Regexp) ReplaceAllLiteral(src, repl []byte) []byte
func main() {
b := []byte("Hello World,　123　Go!")
reg := regexp.MustCompile(`(Hell|G)o`)
rep := []byte("${1}"
fmt.Printf("%q\n", reg.ReplaceAllLiteral(b, rep))
//　"${1}ooo World,　123　${1}ooo!"
}
-----------------------------------------------------------
41.Recherche des correspondances dans src et remplacement par le contenu spécifié par repl
//　Si repl contient le "symbole de groupement" (\$)1、$name），则将“分组引用符”当普通字符处理
//　全部替换，并返回替换后的结果
func (re　*Regexp) ReplaceAllLiteralString(src, repl string) string
func main() {
s := "Hello World,　123　Go!"
reg := regexp.MustCompile(`(Hell|G)o`)
rep := "${1}"
fmt.Printf("%q\n", reg.ReplaceAllLiteralString(s, rep))
//　"${1}ooo World,　123　${1}ooo!"
}
------------------------------------------------------------
42.Recherche des correspondances dans src, puis remplacement du contenu correspondant traité par repl dans src
//　Si la valeur de retour de repl contient le "symbole de groupement" (\$)1、$name），则将“分组引用符”当普通字符处理
//　全部替换，并返回替换后的结果
func (re　*Regexp) ReplaceAllFunc(src []byte, repl func([]byte) []byte) []byte
func main() {
s := []byte("Hello World!")
reg := regexp.MustCompile("(H)ello")
rep := []byte("$0"1")
fmt.Printf("%s\n", reg.ReplaceAll(s, rep))
//　
fmt.Printf("%s\n", reg.ReplaceAllFunc(s,))
func(b []byte) []byte {
rst := []byte{}
rst = append(rst, b...)
rst = append(rst, "\$"1"...)
retourner rst
))
//　Hello$1　World!
}
k
------------------------------------------------------------
43.Recherche des correspondances dans src, puis remplacement du contenu correspondant traité par repl dans src
//　Si la valeur de retour de repl contient le "symbole de groupement" (\$)1、$name），则将“分组引用符”当普通字符处理
//　全部替换，并返回替换后的结果
func (re　*Regexp) ReplaceAllStringFunc(src string, repl func(string) string) string
func main() {
s := "Hello World!"
reg := regexp.MustCompile("(H)ello")
rep := "$0$"1"
fmt.Printf("%s\n", reg.ReplaceAllString(s, rep))
//　
fmt.Printf("%s\n", reg.ReplaceAllStringFunc(s,
func(b string) string {
return b　+　"$1"
))
//　Hello$1　World!
}
------------------------------------------------------------
43.在 s 中搜索匹配项，并以匹配项为分割符，将 s 分割成多个子串
//　最多分割出 n 个子串，第 n 个子串不再进行分割
//　如果 n < 0，则分割所有子串
//　返回分割后的子串列表
func (re　*Regexp) Split(s string, n int) []string
func main() {
s := "Hello World\tHello\nGolang"

fmt.Printf("%q\n", reg.Split(s,　-1))
//　["Hello" "World" "Hello" "Golang"]
}
------------------------------------------------------------
44.返回 re 中的“正则表达式”字符串
func (re　*Regexp) String() string
func main() {
re := regexp.MustCompile("Hello.*$")
fmt.Printf("%s\n", re.String())
//　Hello.*$
}
------------------------------------------------------------
45.返回 re 中的分组名称列表，未命名的分组返回空字符串
//　返回值[0] 为整个正则表达式的名称
//　返回值[1] 是分组　1　的名称
//　返回值[2] 是分组　2　的名称
//　……
func (re　*Regexp) SubexpNames() []string
func main() {
re := regexp.MustCompile("(?PHello) (World)")
fmt.Printf("%q\n", re.SubexpNames())
//　1"　"
}