regexp.MatchString în Go

func MatchString(pattern string, s string) (matched bool, err error)
func Match(pattern string, b []byte) (matched bool, err error)
func MatchReader(pattern string, r io.RuneReader) (matched bool, err error)

Ce face regexp.MatchString

regexp.MatchString(pattern, s) compilează expresia regulată pattern și verifică dacă s conține o potrivire. Returnează și o eroare, dacă expresia este scrisă greșit. Match face la fel pentru []byte, iar MatchReader pentru o sursă care se citește caracter cu caracter (io.RuneReader, de exemplu strings.Reader sau bufio.Reader).

Potrivirea poate fi oriunde în text. Ca să verifici tot textul, pune ^ la început și $ la sfârșit. Scrie expresiile între backticks (`\d+`), ca să nu dublezi fiecare backslash.

Go folosește sintaxa RE2: nu are referințe înapoi (\1) și nici lookahead, dar garantează timp de rulare liniar. Atenție: \w și \b cunosc doar literele ASCII; pentru litere românești folosește \p{L}. Dacă folosești aceeași expresie de mai multe ori, compil-o o dată cu regexp.MustCompile: funcțiile de aici o compilează la fiecare apel.

Parametri

Parametru	Descriere
pattern	Expresia regulată.
s / b / r	Textul, octeții sau sursa verificată.

Ce returnează

matched (dacă există potrivire) și eroarea de compilare a expresiei.

Exemple

Exemplul 1: Validarea unui cod poștal și a unui număr de telefon

package main

import (
	"fmt"
	"regexp"
)

func main() {
	for _, cod := range []string{"700259", "70025", "cod 700259"} {
		ok, _ := regexp.MatchString(`^\d{6}$`, cod)
		fmt.Printf("%-12q cod poștal valid: %t\n", cod, ok)
	}
	ok, err := regexp.MatchString(`^07\d{8}$`, "0721000111")
	fmt.Println("telefon:", ok, err)
	_, err = regexp.MatchString(`(\d+`, "123")
	fmt.Println("expresie greșită:", err)
}

Rezultat

"700259"     cod poștal valid: true
"70025"      cod poștal valid: false
"cod 700259" cod poștal valid: false
telefon: true <nil>
expresie greșită: error parsing regexp: missing closing ): `(\d+`

Exemplul 2: \w față de \p{L} pe cuvinte românești

package main

import (
	"fmt"
	"regexp"
)

func main() {
	cuvant := "Iași"
	a, _ := regexp.MatchString(`^\w+$`, cuvant)
	b, _ := regexp.MatchString(`^\p{L}+$`, cuvant)
	fmt.Println(`\w+:`, a, `| \p{L}+:`, b)
}

Rezultat

\w+: false | \p{L}+: true

Exemplul 3: Match pe octeți și MatchReader

package main

import (
	"fmt"
	"regexp"
	"strings"
)

func main() {
	ok, _ := regexp.Match(`eroare|avertisment`, []byte("2026-10-19 eroare: disc plin"))
	fmt.Println(ok)
	ok, _ = regexp.MatchReader(`(?i)iași`, strings.NewReader("Plecare din IAȘI la 8:00"))
	fmt.Println(ok)
}

Rezultat

true
true

Greșeli frecvente

• Uiți de ^ și $: MatchString(`\d{6}`, "cod 7002591") este true, pentru că găsește 6 cifre în interior.
• Folosești \w pentru cuvinte cu diacritice: „Iași” nu se potrivește cu ^\w+$. Folosește \p{L}.
• Chemi regexp.MatchString în buclă pe mii de texte: expresia este compilată din nou la fiecare apel. Compil-o o dată cu regexp.MustCompile.

Comenzi înrudite

• regexp.Regexp: O expresie regulată compilată: o creezi o dată cu Compile sau MustCompile și o folosești de oricâte ori (MatchString, Find…, Replace…).
• regexp.Regexp.FindString: Găsește prima potrivire (FindString), toate potrivirile (FindAllString) sau poziția primei potriviri (FindStringIndex).
• regexp.QuoteMeta: Pune backslash înaintea caracterelor speciale ale expresiilor regulate (. + * ? ( ) [ ] etc.), ca textul să fie căutat exact.
• strings.Contains: Verifică dacă un text conține un alt text, unul dintre niște caractere, un caracter anume sau un caracter care respectă o condiție.