Strings ב-Golang: Split, Join, Contains, Replace ועוד

מחרוזת ב-Go היא רצף בתים immutable, בדרך כלל טקסט 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("", ",") תופס אנשים: קלט ריק נותן slice באורך 1, לא 0. כשמפצלים קלט של משתמש, Fields או בדיקה של s == "" קודם מונעות איבר ריק מדומה.

strings.Cut היא הדרך הנקייה ביותר לפצל key=value, user@host וזוגות דומים. Go 1.24 הוסיפה גם גרסאות איטרטור, strings.SplitSeq ו-strings.FieldsSeq, שמחזירות חלקים אחד אחד בלי לבנות slice.

חיפוש

כל חיפוש מבחין בין אותיות גדולות לקטנות חוץ מ-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 מעצבת ערכים לתוך מחרוזת אחת. שתיהן מקצות מחרוזת חדשה בכל פעם, כי מחרוזות הן immutable. זה בסדר לקומץ פעולות ואיטי בלולאה, שבה כל += מעתיק את כל מה שנבנה עד עכשיו. השתמשו במקום זה ב-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 אחרי שכתבתם לתוכו; העבירו מצביע.

מחרוזות מרובות שורות ו-raw strings

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

מחרוזות במירכאות כפולות מעבדות תווי escape (\n, \t, \", \\, \u00e9) וחייבות להיכנס בשורה אחת. raw strings בתוך backticks לוקחות הכול כמו שהוא, כולל שורות חדשות, ולכן הן הדרך לכתוב מחרוזות מרובות שורות, ביטויים רגולריים, JSON ונתיבים של Windows. raw string לא יכולה להכיל backtick, ותווי carriage return בתוכה מושמטים. שימו לב שהשאילתה למעלה מתחילה בשורה חדשה, כי הליטרל מתחיל מיד אחרי ה-backtick הפותח.

אורך, גישה לפי אינדקס ותת מחרוזות

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 ו-bytes מסביר UTF-8 לעומק.

מחרוזות הן immutable

אי אפשר לשנות בית במקום: s[0] = 'H' היא שגיאת הידור (cannot assign to s[0] (neither addressable nor a map index expression)). כל פונקציה ב-strings מחזירה מחרוזת חדשה. כדי לערוך, המירו ל-[]byte או ל-[]rune, שנו את ה-slice והמירו בחזרה:

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

immutability היא גם הסיבה שתת מחרוזות זולות: s[2:5] חולקת זיכרון עם s במקום להעתיק אותו. הצד השני הוא שתת מחרוזת קטנה של מחרוזת ענקית שומרת את כל המחרוזת הענקית בחיים. השתמשו ב-strings.Clone (Go 1.20) כששומרים חתיכה קצרה מקלט גדול.

השוואת מחרוזות

== ו-!= משווים תוכן, ו-<, > משווים בית אחרי בית, וזה סדר אלפביתי ב-ASCII. strings.Compare קיימת אבל כמעט אף פעם לא נחוצה; slices.Sort על []string משתמשת ב-<. למיון טקסט שאינו באנגלית לפי כללי locale, השתמשו ב-golang.org/x/text/collate.

המרה מטיפוסים אחרים

מספרים הופכים למחרוזות עם strconv.Itoa, strconv.FormatFloat או fmt.Sprintf, ומחרוזות הופכות למספרים עם strconv.Atoi ו-strconv.ParseFloat. אל תכתבו string(42): זה מייצר את התו עם ה-code point 42, "*". הדף על המרת טיפוסים מכיל את הטבלה המלאה.

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