التعابير النمطية Regexp في Golang: المطابقة والبحث والمجموعات والاستبدال

ترجم مرة واحدة، ثم طابق

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
}

اكتب الأنماط كنصوص خام بين علامتي الاقتباس المائلتين. في النص العادي بين علامتي اقتباس مزدوجتين يجب مضاعفة كل شرطة مائلة عكسية ("\\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 على مستوى الحزمة أو في حقل بنية. والتعبير النمطي المترجم آمن للاستخدام من 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 عندما يكون للنص الذي تبحث عنه شكل لا قيمة ثابتة.

مرجع سريع للصياغة

تستخدم Go صياغة RE2، التي تغطّي الميزات المألوفة بأسلوب Perl:

لا يطابق \d و\w إلا ASCII. لـ "أي حرف في أي لغة" استخدم \pL، ولأي رقم Unicode استخدم \p{Nd}. تهرّب regexp.QuoteMeta(s) كل حرف خاص في s، وهذا ما تحتاجه عند بناء نمط من مدخلات المستخدم.

ما لا تستطيعه RE2

يضمن regexp في Go أن المطابقة تستغرق وقتًا خطيًا بطول المدخل. الميزات التي تكسر هذا الضمان غير مدعومة:

• لا lookahead ولا lookbehind: (?=...) و(?!...) و(?<=...) و(?<!...) أخطاء ترجمة. ولأن Go 1.22 بدأت تقبل (?<name>...) للمجموعات المسمّاة، صار الـ lookbehind يفشل برسالة مربكة هي invalid named capture، كما يُظهر البرنامج التالي.
• لا مراجع خلفية: (\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. والمكسب أن تعبيرًا نمطيًا في Go لا يمكن دفعه إلى تراجع كارثي. نمط مثل (a+)+$ قد يجمّد محرّك PCRE مع مدخل قصير يعمل هنا في وقت خطي، وهذا مهم عندما يأتي النمط أو المدخل من الخارج.

أخطاء شائعة

• الترجمة داخل حلقة أو معالج. ترجم مرة واحدة إلى متغيّر على مستوى الحزمة.
• أنماط بين علامتي اقتباس مزدوجتين. "\d" ليس حتى نصًا صالحًا في Go؛ استخدم علامتي الاقتباس المائلتين.
• نسيان المثبّتات في التحقّق. يطابق \d{5} داخل "abc123456xyz". استخدم ^\d{5}$.
• فهرسة نتيجة مجموعات فرعية دون فحص nil.
• توقّع أن يفهم \w أو \b النصوص غير ASCII. استخدم أصناف Unicode مثل \pL.
• استخدام regexp للنصوص الثابتة. الحزمة strings أوضح وأسرع.