النصوص في Golang: Split وJoin وContains وReplace وغيرها

النص في Go سلسلة غير قابلة للتعديل من البايتات، وعادة ما يكون نصًا بترميز UTF-8. تعمل المعاملات على النص نفسه (+ و== و< والفهرسة والتقطيع)، وكل ما عدا ذلك يعيش في الحزمة القياسية strings.

package main

import (
	"fmt"
	"strings"
)

func main() {
	csv := "apple,banana,cherry"

	parts := strings.Split(csv, ",")
	fmt.Println(parts, len(parts))

	fmt.Println(strings.Join(parts, " | "))
	fmt.Println(strings.Contains(csv, "nan"))
	fmt.Println(strings.ReplaceAll(csv, ",", ";"))
	fmt.Println(strings.ToUpper(parts[0]))
	fmt.Println(strings.TrimSpace("   padded   ") + "!")
}

تقسيم النصوص

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Printf("%q\n", strings.Split("a,b,,c", ","))
	fmt.Printf("%q\n", strings.Split("", ","))
	fmt.Printf("%q\n", strings.Fields("  one  two\tthree\n"))
	fmt.Printf("%q\n", strings.SplitN("k=v=x", "=", 2))
	fmt.Printf("%q\n", strings.Split("go", ""))

	key, value, found := strings.Cut("timeout=30s", "=")
	fmt.Println(key, value, found)
}

حالة Split("", ",") تفاجئ الناس: المدخل الفارغ يعطي شريحة طولها 1، لا 0. عند تقسيم مدخلات المستخدم، تتجنّب Fields أو فحص s == "" أولًا عنصرًا فارغًا وهميًا.

strings.Cut أنظف طريقة لتقسيم key=value وuser@host والأزواج المشابهة. وأضافت Go 1.24 أيضًا نسخًا بمكرِّرات، strings.SplitSeq وstrings.FieldsSeq، تعطي الأجزاء واحدًا تلو الآخر دون بناء شريحة.

البحث

كل بحث يميّز حالة الأحرف ما عدا EqualFold. للبحث دون تمييز حالة الأحرف، حوّل الطرفين إلى حروف صغيرة أو استخدم EqualFold لمقارنة النصوص كاملة.

التحويل

package main

import (
	"fmt"
	"strings"
)

func main() {
	s := "  Hello, Gopher!  "

	fmt.Printf("%q\n", strings.TrimSpace(s))
	fmt.Printf("%q\n", strings.Trim("--go--", "-"))
	fmt.Printf("%q\n", strings.TrimPrefix("v1.2.3", "v"))
	fmt.Printf("%q\n", strings.TrimSuffix("report.pdf", ".pdf"))
	fmt.Printf("%q\n", strings.TrimLeft("xxhixx", "x"))

	fmt.Println(strings.ToLower("MiXeD"), strings.ToUpper("mixed"))
	fmt.Println(strings.Replace("a-b-c-d", "-", "+", 2))
	fmt.Println(strings.ReplaceAll("a-b-c-d", "-", ""))
	fmt.Println(strings.Repeat("=", 20))
}

فخ واحد: تأخذ Trim وTrimLeft وTrimRight مجموعة أحرف، لا بادئة. تزيل strings.TrimLeft("abcab", "ab") كل a وb في البداية وتعيد "cab". لإزالة بادئة أو لاحقة بعينها استخدم TrimPrefix وTrimSuffix.

الضمّ وstrings.Builder

يضمّ + النصوص، وتنسّق fmt.Sprintf القيم في نص واحد. كلاهما يحجز نصًا جديدًا في كل مرة، لأن النصوص غير قابلة للتعديل. هذا مقبول لعدد قليل من العمليات وبطيء في حلقة، حيث ينسخ كل += كل ما بُني حتى الآن. استخدم strings.Builder بدلًا من ذلك:

package main

import (
	"fmt"
	"strings"
)

func main() {
	var b strings.Builder
	for i := 1; i <= 5; i++ {
		fmt.Fprintf(&b, "row %d", i)
		if i < 5 {
			b.WriteString(", ")
		}
	}
	fmt.Println(b.String())
	fmt.Println("length:", b.Len())

	// joining a slice is simpler still
	names := []string{"Ana", "Ben", "Chen"}
	fmt.Println("Hello " + strings.Join(names, ", "))
}

الـ strings.Builder الصفري جاهز للاستخدام. يطبّق io.Writer، فتكتب فيه fmt.Fprintf مباشرة. استدعِ b.Grow(n) أولًا إذا كنت تعرف تقريبًا حجم النتيجة. لا تنسخ Builder بعد الكتابة فيه؛ مرّر مؤشرًا.

النصوص متعدّدة الأسطر والخام

لدى Go نوعان من حرفيات النصوص:

package main

import "fmt"

func main() {
	interpreted := "line one\nline two\ttabbed \"quoted\""
	raw := `C:\Users\ana\notes.txt
second line, \n stays literal`

	fmt.Println(interpreted)
	fmt.Println(raw)

	query := `
SELECT id, name
FROM users
WHERE active = true`
	fmt.Println(query)
}

تعالج النصوص بين علامتي الاقتباس المزدوجتين رموز الهروب (\n و\t و\" و\\ و\u00e9) ويجب أن تتّسع في سطر واحد. أما النصوص الخام بين علامتي الاقتباس المائلتين فتأخذ كل شيء حرفيًا، بما في ذلك الأسطر الجديدة، وهذا يجعلها طريقة كتابة النصوص متعدّدة الأسطر والتعابير النمطية وJSON ومسارات Windows. لا يمكن للنص الخام أن يحتوي علامة الاقتباس المائلة، وتُحذف منه محارف العودة (carriage return). لاحظ أن الاستعلام السابق يبدأ بسطر جديد، لأن الحرفية تبدأ مباشرة بعد علامة الاقتباس المائلة الافتتاحية.

الطول والفهرسة والنصوص الفرعية

len(s) هو عدد البايتات. وs[i] بايت، وs[i:j] نص فرعي بمواضع البايتات:

package main

import (
	"fmt"
	"unicode/utf8"
)

func main() {
	s := "naïve café"

	fmt.Println(len(s), utf8.RuneCountInString(s))
	fmt.Println(s[0], string(s[0]))
	fmt.Println(s[:5]) // first 5 bytes
	fmt.Println(s[6:]) // from byte 6 to the end

	r := []rune(s)
	fmt.Println(string(r[:5])) // first 5 characters
}

يشغل كل من ï وé بايتين، فالنص 12 بايتًا و10 أحرف. التقطيع بالبايتات آمن ما دامت المواضع تأتي من strings.Index أو ما يشبهها، التي تعيد إزاحات بايتات على حدود الأحرف. لأخذ "أول n حرفًا" حوّل إلى []rune أولًا. صفحة الـ runes والبايتات تشرح UTF-8 بالتفصيل.

النصوص غير قابلة للتعديل

لا يمكنك تغيير بايت في مكانه: s[0] = 'H' خطأ ترجمة (cannot assign to s[0] (neither addressable nor a map index expression)). كل دالة في strings تعيد نصًا جديدًا. للتعديل حوّل إلى []byte أو []rune، وغيّر الشريحة، ثم حوّل بالعكس:

b := []byte("hello")
b[0] = 'H'
s := string(b) // "Hello"

عدم قابلية التعديل هو أيضًا سبب رخص النصوص الفرعية: تتشارك s[2:5] الذاكرة مع s بدل نسخها. والوجه الآخر أن نصًا فرعيًا صغيرًا من نص ضخم يُبقي النص الضخم كله حيًّا. استخدم strings.Clone (Go 1.20) عندما تحتفظ بقطعة قصيرة من مدخل كبير.

مقارنة النصوص

تقارن == و!= المحتوى، وتقارن < و> بايتًا ببايت، وهذا ترتيب أبجدي في ASCII. توجد strings.Compare لكن نادرًا ما تُحتاج؛ وslices.Sort على []string تستخدم <. للترتيب المراعي للغة المحلية في النصوص غير الإنجليزية استخدم golang.org/x/text/collate.

تحويل الأنواع الأخرى

تصير الأرقام نصوصًا بـ strconv.Itoa أو strconv.FormatFloat أو fmt.Sprintf، وتصير النصوص أرقامًا بـ strconv.Atoi وstrconv.ParseFloat. لا تكتب string(42): فهي تنتج الحرف صاحب نقطة الرمز 42، أي "*". صفحة تحويل الأنواع فيها الجدول الكامل.

query := `SELECT id, name
FROM users
WHERE active = true`