Regexp ב-Golang: התאמה, חיפוש, submatches והחלפה

הידור פעם אחת, ואז התאמה

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
}

כתבו תבניות כ-raw string literals בתוך backticks. במחרוזת רגילה במירכאות כפולות צריך להכפיל כל לוכסן הפוך ("\\d+"), וזה הופך מהר לבלתי קריא.

regexp.MustCompile גורמת ל-panic אם התבנית לא תקינה, וזה בדיוק מה שרוצים לתבנית שכתובה בקוד המקור: שגיאת הקלדה נכשלת מיד בהפעלה, ולא בבקשה הראשונה. לתבניות שמגיעות ממשתמשים או מהגדרות, השתמשו ב-regexp.Compile וטפלו בשגיאה:

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

הדרו פעם אחת. הידור יקר בהרבה מהתאמה. regexp.MustCompile בתוך פונקציה שרצה בכל בקשה או בכל שורה חוזר על העבודה הזאת בכל פעם. שמרו את ה-*regexp.Regexp המהודר ב-var ברמת החבילה או בשדה של struct. regexp מהודר בטוח לשימוש מהרבה goroutines בו זמנית.

regexp.MatchString(pattern, s) מהדרת ומתאימה בקריאה אחת. היא מתאימה לבדיקה חד פעמית ובזבזנית בתוך לולאה.

חיפוש התאמות

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)
}

שמות המתודות בנויים לפי תבנית: Find + All? + String? + Submatch? + Index?.

FindString מחזירה "" כשאין התאמה, ואי אפשר להבדיל את זה מהתאמה למחרוזת ריקה. כשהתבנית יכולה להתאים לטקסט ריק, השתמשו ב-FindStringIndex (מחזירה nil כשאין התאמה) או קודם ב-MatchString. גרסאות ה-All מחזירות nil כששום דבר לא מתאים.

קבוצות לכידה

סוגריים לוכדים. FindStringSubmatch מחזירה את ההתאמה המלאה באינדקס 0, ואחריה רשומה אחת לכל קבוצה:

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())
}

תמיד בדקו nil לפני גישה לפי אינדקס לתוצאה; כשאין התאמה, m[1] גורם ל-panic.

(?:...) מקבץ בלי ללכוד, לחלופות או לחזרות: (?:ab)+. קבוצות עם שם נכתבות (?P<name>...), ומאז Go 1.22 גם (?<name>...).

החלפה

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))
}

מלכודת קלאסית בהפניות לקבוצות: "$1x" נקרא כקבוצה בשם 1x, שלא קיימת, ומתפרש כמחרוזת ריקה. כתבו "${1}x".

למחרוזת קבועה, strings.ReplaceAll, strings.Contains ו-strings.Split פשוטות ומהירות יותר מ-regexp. פנו ל-regexp כשלטקסט שאתם מחפשים יש צורה ולא ערך קבוע.

תקציר תחביר

Go משתמשת בתחביר RE2, שמכסה את היכולות המוכרות בסגנון Perl:

\d ו-\w מתאימים רק ל-ASCII. ל"כל אות בכל שפה", השתמשו ב-\pL, ולכל ספרת Unicode, ב-\p{Nd}. regexp.QuoteMeta(s) מבצעת escape לכל תו מיוחד ב-s, ואת זה צריך כשבונים תבנית מקלט של משתמש.

מה ש-RE2 לא יודע לעשות

regexp של Go מבטיח שההתאמה לוקחת זמן ליניארי ביחס לאורך הקלט. יכולות שהיו שוברות את ההבטחה הזאת לא נתמכות:

• אין lookahead או lookbehind: (?=...), (?!...), (?<=...), (?<!...) הן שגיאות הידור. מכיוון ש-Go 1.22 התחילה לקבל (?<name>...) לקבוצות עם שם, lookbehind נכשל עכשיו עם ההודעה המבלבלת invalid named capture, כפי שהתוכנית הבאה מראה.
• אין backreferences: אי אפשר לכתוב (\w)\1 כדי למצוא אות כפולה.
• אין כמתים רכושניים או קבוצות אטומיות.

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))
		}
	}
}

הפתרון כמעט תמיד זהה: ללכוד קצת יותר ממה שצריך, ואז לסנן או לחתוך ב-Go. התמורה היא ש-regexp של Go לא יכול להידחף ל-backtracking קטסטרופלי. תבנית כמו (a+)+$, שיכולה להקפיא מנוע PCRE על קלט קצר, רצה כאן בזמן ליניארי, וזה חשוב כשהתבנית או הקלט מגיעים מבחוץ.

טעויות נפוצות

• הידור בתוך לולאה או handler. הדרו פעם אחת לתוך משתנה ברמת החבילה.
• תבניות במירכאות כפולות. "\d" הוא אפילו לא מחרוזת Go תקינה; השתמשו ב-backticks.
• שכחת עוגנים באימות. \d{5} מתאים בתוך "abc123456xyz". השתמשו ב-^\d{5}$.
• גישה לפי אינדקס לתוצאת submatch בלי בדיקת nil.
• ציפייה ש-\w או \b יבינו טקסט שאינו ASCII. השתמשו במחלקות Unicode כמו \pL.
• שימוש ב-regexp למחרוזות קבועות. החבילה strings ברורה ומהירה יותר.