Çalıştırılabilir Go Dokümanları: Düzenli İfadeler

Q: Go'da bir string'in bir regex ile eşleşip eşleşmediği nasıl kontrol edilir?

Deseni regexp.MustCompile ile bir kez derleyin; ters eğik çizgilerin kaçış gerektirmemesi için onu ters tırnaklı ham bir string olarak yazın, sonra re.MatchString(s)'i çağırın. Çapalar (^ ve $) olmadan MatchString, desen string'in herhangi bir yerinde eşleşirse true döndürür.

Q: Go regexp lookahead ve lookbehind destekler mi?

Hayır. Go'nun regexp'i, lookahead, lookbehind ya da geri başvurusu olmayan RE2 söz dizimini kullanır. Karşılığında eşleştirme girdi boyutuna göre doğrusal zamanda çalışır, bu yüzden kötü niyetli bir desen ya da girdi programınızı kilitleyemez. Bunun yerine yakalama grupları ve biraz Go kodu kullanın ya da kontrolü iki regex'e bölün.

Q: regexp.Compile ile regexp.MustCompile arasındaki fark nedir?

Compile derlenmiş deseni ve bir hata döndürür. MustCompile ise geçersiz bir desende bunun yerine panic yapar. Kaynak kodunuzda yazılmış desenler için, genellikle paket seviyesindeki bir değişkende, MustCompile kullanın ki bir yazım hatası başlangıçta başarısız olsun. Kullanıcılardan ya da yapılandırma dosyalarından gelen desenler için Compile kullanın.

Bir kez derleyin, sonra eşleştirin

package main

import (
	"fmt"
	"regexp"
)

// Compiled once, when the program starts.
var phoneRe = regexp.MustCompile(`^\d{3}-\d{3}-\d{4}$`)

func main() {
	for _, s := range []string{"555-123-4567", "5551234567", "call 555-123-4567"} {
		fmt.Printf("%-20q %v\n", s, phoneRe.MatchString(s))
	}

	wordRe := regexp.MustCompile(`go+gle`)
	fmt.Println(wordRe.MatchString("I googled it")) // unanchored: matches anywhere
}

Desenleri ters tırnaklı ham string literal'leri olarak yazın. Normal çift tırnaklı bir string'de her ters eğik çizgi ikiye katlanmalıdır ("\\d+") ve bu hızla okunamaz hale gelir.

regexp.MustCompile, desen geçersizse panic yapar; kaynak kodunuzdaki bir desen için istediğiniz de budur: bir yazım hatası ilk istekte değil, hemen başlangıçta başarısız olur. Kullanıcılardan ya da yapılandırmadan gelen desenler için regexp.Compile kullanın ve hatayı ele alın:

re, err := regexp.Compile(userPattern)
if err != nil {
	return fmt.Errorf("bad pattern: %w", err)
}

Bir kez derleyin. Derlemek eşleştirmekten çok daha pahalıdır. İstek ya da satır başına çalışan bir fonksiyonun içindeki regexp.MustCompile bu işi her seferinde tekrarlar. Derlenmiş *regexp.Regexp'i paket seviyesindeki bir var'a ya da bir struct alanına koyun. Derlenmiş bir regexp'i aynı anda birçok goroutine'den kullanmak güvenlidir.

regexp.MatchString(pattern, s) tek bir çağrıda derler ve eşleştirir. Tek seferlik bir kontrol için uygundur, bir döngüde israftır.

Eşleşmeleri bulmak

package main

import (
	"fmt"
	"regexp"
)

var numRe = regexp.MustCompile(`\d+`)

func main() {
	s := "order 66 shipped 3 boxes, 1200 grams"

	fmt.Printf("%q\n", numRe.FindString(s))           // first match
	fmt.Println(numRe.FindStringIndex(s))             // its [start, end) byte offsets
	fmt.Println(numRe.FindAllString(s, -1))           // all matches
	fmt.Println(numRe.FindAllString(s, 2))            // at most 2
	fmt.Printf("%q\n", numRe.FindString("no digits")) // "" when nothing matches

	fmt.Println(numRe.FindAllString("no digits", -1) == nil)
}

Metot adları bir kalıbı izler: Find + All? + String? + Submatch? + Index?.

Parça	Anlamı
`All`	çakışmayan her eşleşme; bir `n` limiti alır (hepsi için `-1`)
`String`	bir `string` üzerinde çalışır; o olmadan metot `[]byte` alır ve döndürür
`Submatch`	yakalama gruplarını da döndürür
`Index`	metin yerine bayt konumları döndürür

FindString eşleşme olmadığında "" döndürür; bu, boş bir string'le eşleşmekten ayırt edilemez. Desen boş metinle eşleşebiliyorsa FindStringIndex (eşleşme yoksa nil döndürür) kullanın ya da önce MatchString çağırın. All çeşitleri hiçbir şey eşleşmediğinde nil döndürür.

Yakalama grupları

Parantezler yakalar. FindStringSubmatch tüm eşleşmeyi 0. indekste, ardından her grup için bir girdi döndürür:

package main

import (
	"fmt"
	"regexp"
)

var dateRe = regexp.MustCompile(`(\d{4})-(\d{2})-(\d{2})`)

var logRe = regexp.MustCompile(`(?P<level>INFO|WARN|ERROR) (?P<msg>.+)`)

func main() {
	m := dateRe.FindStringSubmatch("released on 2026-09-23 at noon")
	if m == nil {
		fmt.Println("no date")
		return
	}
	fmt.Println("whole:", m[0], "year:", m[1], "month:", m[2], "day:", m[3])

	for _, g := range dateRe.FindAllStringSubmatch("2025-01-15 and 2026-02-28", -1) {
		fmt.Println(g[1], g[2], g[3])
	}

	// Named groups: look up the index by name.
	line := "ERROR disk full on /dev/sda1"
	if lm := logRe.FindStringSubmatch(line); lm != nil {
		fmt.Println("level:", lm[logRe.SubexpIndex("level")])
		fmt.Println("msg:  ", lm[logRe.SubexpIndex("msg")])
	}
	fmt.Println("group names:", logRe.SubexpNames())
}

Sonucu indekslemeden önce her zaman nil kontrolü yapın; eşleşme yoksa m[1] panic olur.

(?:...) yakalamadan gruplar; alternatif ya da tekrar için: (?:ab)+. Adlı gruplar (?P<name>...) olarak, Go 1.22'den beri ayrıca (?<name>...) olarak yazılır.

Değiştirmek

package main

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

var (
	spaceRe = regexp.MustCompile(`\s+`)
	dateRe  = regexp.MustCompile(`(\d{4})-(\d{2})-(\d{2})`)
	emailRe = regexp.MustCompile(`[\w.+-]+@[\w-]+\.[\w.]+`)
)

func main() {
	fmt.Printf("%q\n", spaceRe.ReplaceAllString("  too   many\tspaces \n", " "))

	// $1, $2 refer to groups. Use ${1} when a letter or digit follows.
	fmt.Println(dateRe.ReplaceAllString("due 2026-09-23", "$3/$2/$1"))

	// Literal replacement: $ has no special meaning.
	fmt.Println(dateRe.ReplaceAllLiteralString("due 2026-09-23", "$DATE"))

	// Compute the replacement in Go.
	masked := emailRe.ReplaceAllStringFunc("mail ada@example.com or bob@test.org", func(e string) string {
		at := strings.IndexByte(e, '@')
		return e[:1] + strings.Repeat("*", at-1) + e[at:]
	})
	fmt.Println(masked)

	// Split on a pattern.
	fmt.Printf("%q\n", regexp.MustCompile(`\s*[,;]\s*`).Split("a, b;c ,d", -1))
}

Grup başvurularıyla ilgili klasik bir tuzak: "$1x", var olmayan 1x adlı bir grup olarak okunur ve boş bir string'e genişler. "${1}x" yazın.

Sabit bir string için strings.ReplaceAll, strings.Contains ve strings.Split bir regexp'ten daha basit ve hızlıdır. Aradığınız metnin sabit bir değeri değil de bir biçimi olduğunda regexp'e başvurun.

Söz dizimi hızlı başvurusu

Go, tanıdık Perl tarzı özellikleri kapsayan RE2 söz dizimini kullanır:

Söz dizimi	Eşleştiği
`.`	yeni satır dışında herhangi bir karakter (`(?s)` ile yeni satır da)
`\d` `\w` `\s`	rakam, kelime karakteri `[0-9A-Za-z_]`, boşluk (yalnızca ASCII)
`\D` `\W` `\S`	olumsuzları
`[abc]` `[^abc]` `[a-z]`	karakter sınıfları
`\pL` `\p{Greek}`	Unicode sınıfları: herhangi bir harf, herhangi bir Yunan karakteri
`*` `+` `?` `{n,m}`	tekrar, açgözlü
`*?` `+?` `??`	tekrar, tembel
`^` `$`	metnin başı ve sonu (`(?m)` ile satırın)
`\b`	kelime sınırı (ASCII)
`a\|b`	alternatif
`(?i)`	o noktadan çevreleyen grubun sonuna kadar büyük/küçük harf duyarsız; genellikle desenin başına yazılır

\d ve \w yalnızca ASCII ile eşleşir. "Herhangi bir dildeki herhangi bir harf" için \pL, herhangi bir Unicode rakamı için \p{Nd} kullanın. regexp.QuoteMeta(s), s içindeki her özel karakteri kaçışlar; kullanıcı girdisinden bir desen oluştururken buna ihtiyacınız olur.

RE2'nin yapamadıkları

Go'nun regexp'i eşleştirmenin girdinin uzunluğuna göre doğrusal zaman almasını garanti eder. Bu garantiyi bozacak özellikler desteklenmez:

Lookahead ya da lookbehind yok: (?=...), (?!...), (?<=...), (?<!...) derleme hatasıdır. Go 1.22 adlı gruplar için (?<name>...)'i kabul etmeye başladığından, bir lookbehind artık aşağıdaki programın gösterdiği gibi kafa karıştırıcı invalid named capture mesajıyla başarısız olur.
Geri başvuru yok: çift harfi eşleştirmek için (\w)\1 mümkün değildir.
Possessive niceleyiciler ya da atomik gruplar yok.

package main

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

// Goal: a price in dollars, but only the number, and not when it is negative.
// PCRE would write (?<!-)(?<=\$)\d+(\.\d{2})? using lookbehind.
var priceRe = regexp.MustCompile(`(-?)\$(\d+(?:\.\d{2})?)`)

func main() {
	_, err := regexp.Compile(`(?<=\$)\d+`)
	fmt.Println("lookbehind:", err)

	text := "was $19.99, now $15, refund -$5"
	for _, m := range priceRe.FindAllStringSubmatch(text, -1) {
		if m[1] == "-" {
			continue // the lookbehind's job, done in Go
		}
		fmt.Println("price:", m[2])
	}

	// A doubled letter without a backreference: check in plain Go.
	word := "balloon"
	for i := 1; i < len(word); i++ {
		if word[i] == word[i-1] {
			fmt.Println("doubled:", strings.Repeat(string(word[i]), 2))
		}
	}
}

Geçici çözüm neredeyse her zaman aynıdır: ihtiyacınızdan biraz fazlasını yakalayın, sonra Go'da filtreleyin ya da dilimleyin. Karşılığında bir Go regexp'i felaket boyutunda geri izlemeye (catastrophic backtracking) itilemez. Bir PCRE motorunu kısa bir girdide dondurabilen (a+)+$ gibi bir desen burada doğrusal zamanda çalışır; bu, desen ya da girdi dışarıdan geldiğinde önemlidir.

Sık yapılan hatalar

Bir döngü ya da handler içinde derlemek. Paket seviyesindeki bir değişkene bir kez derleyin.
Çift tırnaklı desenler. "\d" geçerli bir Go string'i bile değildir; ters tırnak kullanın.
Doğrulamada çapaları unutmak. \d{5}, "abc123456xyz" içinde eşleşir. ^\d{5}$ kullanın.
Bir alt eşleşme sonucunu nil kontrolü olmadan indekslemek.
\w ya da \b'nin ASCII olmayan metni anlamasını beklemek. \pL gibi Unicode sınıflarını kullanın.
Sabit string'ler için regexp kullanmak. strings paketi daha anlaşılır ve daha hızlıdır.

Sıkça Sorulan Sorular

Go'da bir string'in bir regex ile eşleşip eşleşmediği nasıl kontrol edilir?

Deseni regexp.MustCompile ile bir kez derleyin; ters eğik çizgilerin kaçış gerektirmemesi için onu ters tırnaklı ham bir string olarak yazın, sonra re.MatchString(s)'i çağırın. Çapalar (^ ve $) olmadan MatchString, desen string'in herhangi bir yerinde eşleşirse true döndürür.

Go regexp lookahead ve lookbehind destekler mi?

Hayır. Go'nun regexp'i, lookahead, lookbehind ya da geri başvurusu olmayan RE2 söz dizimini kullanır. Karşılığında eşleştirme girdi boyutuna göre doğrusal zamanda çalışır, bu yüzden kötü niyetli bir desen ya da girdi programınızı kilitleyemez. Bunun yerine yakalama grupları ve biraz Go kodu kullanın ya da kontrolü iki regex'e bölün.

regexp.Compile ile regexp.MustCompile arasındaki fark nedir?

Compile derlenmiş deseni ve bir hata döndürür. MustCompile ise geçersiz bir desende bunun yerine panic yapar. Kaynak kodunuzda yazılmış desenler için, genellikle paket seviyesindeki bir değişkende, MustCompile kullanın ki bir yazım hatası başlangıçta başarısız olsun. Kullanıcılardan ya da yapılandırma dosyalarından gelen desenler için Compile kullanın.

Go'da bir regex'ten yakalama grupları nasıl alınır?

indeksin tüm eşleşme, 1, 2, ... indekslerinin gruplar olduğu bir slice döndüren ya da eşleşme yoksa nil döndüren FindStringSubmatch'i kullanın. Tüm eşleşmeler için FindAllStringSubmatch(s, -1) kullanın. Adlı gruplar (?P<year>\d{4}), re.SubexpIndex("year") ile bulunabilir.

İlgili kavramlar