Reguláris kifejezések ebben a kurzusban:

A(z) Reguláris kifejezések fogalomról

A regexp csomag támogatást nyújt a reguláris kifejezésekhez Go-ban.

Szintaxis

Az elfogadott reguláris kifejezések szintaxisa ugyanaz az általános szintaxis, amelyet a Perl, a Python és más nyelvek használnak.

A keresési minták és a bemeneti szövegek is UTF-8-ként értelmeződnek.

Amikor backtickeket () to make strings, backslashes (`) don't have any special meaning and don't mark the beginning of special characters like tabs \t or newlines \n kezdetét:

"\t\n" // regular string literal with 2 characters: a tab and a newline
`\t\n`// raw string literal with 4 characters: two backslashes, a 't', and an 'n'

Emiatt a reguláris kifejezésekhez érdemes backtickeket használni, mert így nem kell a backslasheket escape-elni:

"\\" // string with a single backslash
`\\` // string with 2 backslashes

Minták lefordítása - RegExp típus

Egy reguláris kifejezés használatához először le kell fordítanunk a minta stringjét. A fordítás itt azt jelenti, hogy fogjuk a reguláris kifejezés string mintáját, és átalakítjuk egy belső reprezentációvá, amelyet könnyebb kezelni. Minden mintát csak egyszer kell lefordítanunk, utána a reguláris kifejezés lefordított változatát sokszor használhatjuk. A regexp.Regexp típus egy lefordított reguláris kifejezést reprezentál. Egy string mintát a regexp.Compile függvény segítségével fordíthatunk regexp.Regexp-vé. Ez a függvény nil-t és egy hibát ad vissza, ha a fordítás sikertelen volt:

re, err := regexp.Compile(`(a|b)+`)
fmt.Println(re, err) // => (a|b)+ <nil>
re, err = regexp.Compile(`a|b)+`)
fmt.Println(re, err) // => <nil> error parsing regexp: unexpected ): `a|b)+`

A MustCompile függvény kényelmes alternatívája a Compile-nak:

re = regexp.MustCompile(`[a-z]+\d*`)

Ezzel a függvénnyel nem kell a hibát kezelni.

A reguláris kifejezés metódusai

A Regexp-nek 16 metódusa van, amelyek illesztenek egy reguláris kifejezést, és azonosítják az illeszkedő szöveget. A nevükre ez a reguláris kifejezés illeszkedik:

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

• Ha az All szerepel, a rutin a teljes kifejezés egymást követő, nem átfedő illeszkedéseit keresi.
• Ha a String szerepel, az argumentum egy string; egyébként bájtok szelete; a visszatérési értékek ennek megfelelően módosulnak.
• Ha a Submatch szerepel, a visszatérési érték egy szelet, amely a kifejezés egymást követő részilleszkedéseit azonosítja.
• Ha az Index szerepel, az illeszkedéseket és a részilleszkedéseket a bemeneti stringen belüli bájtindexpárok azonosítják.

Vannak továbbá metódusok a következőkre:

• a reguláris kifejezések illeszkedéseinek cseréjére helyettesítő stringekkel, valamint
• a reguláris kifejezésekkel elválasztott stringek felbontására.

Összességében a regexp csomag több mint 40 függvényt és metódust definiál. Alább bemutatjuk néhány metódus használatát. Ezeknek és más függvényeknek a részleteit lásd az API dokumentációban.

MatchString példák

A MatchString metódus jelzi, hogy egy string tartalmaz-e bármilyen illeszkedést a reguláris kifejezésre.

re = regexp.MustCompile(`[a-z]+\d*`)
b = re.MatchString("[a12]")       // => true
b = re.MatchString("12abc34(ef)") // => true
b = re.MatchString(" abc!")       // => true
b = re.MatchString("123 456")     // => false

FindString példák

A FindString metódus egy stringet ad vissza, amely a reguláris kifejezés legbaloldalibb illeszkedésének szövegét tartalmazza.

re = regexp.MustCompile(`[a-z]+\d*`)
s = re.FindString("[a12]")       // => "a12"
s = re.FindString("12abc34(ef)") // => "abc34"
s = re.FindString(" abc!")       // => "abc"
s = re.FindString("123 456")     // => ""

FindStringSubmatch példák

A FindStringSubmatch metódus egy stringekből álló szeletet ad vissza, amely a reguláris kifejezés legbaloldalibb illeszkedésének szövegét, valamint a részkifejezéseinek illeszkedéseit tartalmazza, ha vannak ilyenek. Ezzel azonosíthatók a capturing csoportokra illeszkedő stringek. A nil visszatérési érték azt jelzi, hogy nincs illeszkedés.

re = regexp.MustCompile(`[a-z]+(\d*)`)
sl = re.FindStringSubmatch("[a12]")       // => []string{"a12","12"}
sl = re.FindStringSubmatch("12abc34(ef)") // => []string{"abc34","34"}
sl = re.FindStringSubmatch(" abc!")       // => []string{"abc",""}
sl = re.FindStringSubmatch("123 456")     // => <nil>

ReplaceAllString példák

A re.ReplaceAllString(src,repl) metódus a src egy másolatát adja vissza, a reguláris kifejezés re illeszkedéseit a repl helyettesítő stringgel cserélve.

re = regexp.MustCompile(`[a-z]+\d*`)
s = re.ReplaceAllString("[a12]", "X")       // => "[X]"
s = re.ReplaceAllString("12abc34(ef)", "X") // => "12X(X)"
s = re.ReplaceAllString(" abc!", "X")       // => " X!"
s = re.ReplaceAllString("123 456", "X")     // => "123 456"

Split példák

A re.Split(s,n) metódus a s szöveget a kifejezéssel elválasztott részstringekre bontja, és visszaadja az ezen kifejezés-illeszkedések közötti részstringek szeletét. Az n szám határozza meg a visszaadandó részstringek maximális számát. Ha n<0, a metódus az összes részstringet visszaadja.

re = regexp.MustCompile(`[a-z]+\d*`)
sl = re.Split("[a12]", -1)      // => []string{"[","]"}
sl = re.Split("12abc34(ef)", 2) // => []string{"12","(ef)"}
sl = re.Split(" abc!", -1)      // => []string{" ","!"}
sl = re.Split("123 456", -1)    // => []string{"123 456"}

Teljesítmény

A csomag által biztosított regexp-implementáció garantáltan a bemenet méretével lineáris időben fut.

Fenntartás

A regexp csomag RE2 reguláris kifejezéseket valósít meg (a \C kivételével). A szintaxis nagyrészt kompatibilis a PCRE-vel („Perl Compatible Regular Expression”), de van néhány különbség. A részletekért lásd e cikk „Caveat section” című részét.