Rune ו-Byte ב-Golang: מחרוזות UTF-8 בהסבר פשוט

מחרוזת ב-Go היא רצף של בתים, וקוד המקור והליטרלים של מחרוזות ב-Go הם UTF-8. byte הוא אחד מהבתים האלה. rune הוא תו Unicode אחד (code point), ש-UTF-8 שומר ב-1 עד 4 בתים. רוב הבלבול סביב מחרוזות ב-Go נובע מערבוב בין השניים:

package main

import (
	"fmt"
	"unicode/utf8"
)

func main() {
	s := "語Go"

	fmt.Println("bytes:", len(s))
	fmt.Println("runes:", utf8.RuneCountInString(s))

	fmt.Println("byte loop:")
	for i := 0; i < len(s); i++ {
		fmt.Printf("  %d: %d\n", i, s[i])
	}

	fmt.Println("range loop:")
	for i, r := range s {
		fmt.Printf("  %d: %c (%d)\n", i, r, r)
	}
}

語 תופס שלושה בתים ב-UTF-8, ולכן "語Go" הוא 5 בתים אבל 3 runes. לולאת האינדקס רואה חמישה בתים, ולבתים 0, 1 ו-2 אין משמעות בפני עצמם. לולאת ה-range מפענחת UTF-8 ומחזירה שלושה runes באינדקסים 0, 3 ו-4: i הוא תמיד היסט בבתים, לא מספר תווים.

byte ו-rune הם כינויים

מכיוון שהם כינויים, byte הוא uint8 ו-rune הוא int32; אין צורך בהמרה בין הכינוי לבין הטיפוס שמתחתיו. גרשיים בודדים יוצרים rune, ומירכאות כפולות יוצרות מחרוזת. 'ab' היא שגיאת הידור, כי ליטרל rune מחזיק בדיוק תו אחד.

runes הם מספרים, ולכן אפשר לבצע עליהם חשבון:

package main

import (
	"fmt"
	"unicode"
)

func main() {
	r := 'a'
	fmt.Println(r, string(r))
	fmt.Println(string(r + 1))
	fmt.Println('7'-'0', unicode.IsDigit('7'))
	fmt.Println(unicode.ToUpper('é') == 'É', string(unicode.ToUpper('é')))
	fmt.Printf("%c %U %q\n", '世', '世', '世')
}

'7' - '0' היא הדרך הקלאסית להפוך תו של ספרה לערך שלה. החבילה unicode מסווגת runes (IsLetter, IsDigit, IsSpace, IsUpper) ומשנה אותיות גדולות וקטנות נכון גם באותיות שאינן ASCII. %c מדפיס rune כתו, %U בצורה U+4E16, ו-%q כליטרל rune במירכאות.

איך UTF-8 שומר תווים

טקסט ASCII זהה ב-UTF-8, ולכן קוד שעובד על בתים עובד לעיתים קרובות בבדיקות ונשבר בשם הראשון עם ניקוד או אות מוטעמת. החבילה unicode/utf8 עובדת ישירות עם הקידוד:

package main

import (
	"fmt"
	"unicode/utf8"
)

func main() {
	for _, s := range []string{"a", "é", "€", "🙂"} {
		r, size := utf8.DecodeRuneInString(s)
		fmt.Printf("%s  U+%04X  %d bytes  % x\n", s, r, size, []byte(s))
	}

	fmt.Println(utf8.ValidString("ok"), utf8.ValidString("\xff"))
	fmt.Println(utf8.RuneLen('語'))
}

% x (עם רווח) מדפיס בתים בהקסדצימלי מופרדים ברווחים. utf8.ValidString מדווחת אם מחרוזת היא UTF-8 תקין. מחרוזות ב-Go יכולות להחזיק כל בית, לא רק UTF-8 תקין; כש-range נתקלת בבית לא תקין היא מחזירה utf8.RuneError (U+FFFD, תו ההחלפה) ומתקדמת בבית אחד.

המרה בין string, []byte ו-[]rune

package main

import "fmt"

func reverse(s string) string {
	r := []rune(s)
	for i, j := 0, len(r)-1; i < j; i, j = i+1, j-1 {
		r[i], r[j] = r[j], r[i]
	}
	return string(r)
}

func main() {
	s := "héllo, 世界"

	b := []byte(s)
	r := []rune(s)
	fmt.Println(len(s), len(b), len(r))

	fmt.Println(reverse(s))

	// first 7 characters, not bytes
	fmt.Println(string(r[:7]))

	// edit bytes, then convert back
	b[0] = 'H'
	fmt.Println(string(b))
}

היפוך לפי בתים היה מערבב את 世界 ל-UTF-8 לא תקין, ולכן reverse עובדת על runes. גם runes הם לא כל הסיפור: תו כמו é יכול להיכתב גם כ-e ועוד סימן הטעמה מצטרף, כלומר שני runes. לתווים שהמשתמש רואה (grapheme clusters), השתמשו בספרייה כמו github.com/rivo/uniseg.

כל המרה מעתיקה, כי מחרוזות הן immutable ו-slices לא. בקוד חם, הימנעו מהמרות הלוך ושוב; המהדר מבצע אופטימיזציה בחלק מהמקרים (כמו string(b) שמשמש כמפתח של map או בהשוואה) ומדלג על ההעתקה.

גישה לפי אינדקס מחזירה byte

s[i] מחזיר byte, ו-s[i:j] חותך לפי היסטים בבתים:

s := "café"
fmt.Println(s[3])            // 195: the first byte of é
fmt.Println(string(s[3]))    // "Ã": that byte read as a code point
fmt.Println(s[:3])           // "caf"
fmt.Println(s[:4])           // "caf\xc3": half of é, invalid UTF-8

string(s[3]) הוא מלכודת: המרה של בית בודד ל-string מתייחסת אליו כאל ה-code point 195, שהוא Ã, ולא אל הבית עצמו. כדי למצוא גבולות של תווים, השתמשו ב-range, במשפחת strings.Index (שמחזירות היסטים בבתים שתמיד נופלים על גבולות), או ב-utf8.DecodeRuneInString.

החבילה bytes

bytes משקפת את strings עבור []byte: bytes.Contains, bytes.Split, bytes.Fields, bytes.TrimSpace, bytes.Equal, bytes.ToUpper וכן הלאה. השתמשו בה כשהנתונים מגיעים כבתים (תוכן קבצים, גופי HTTP, buffers של רשת), כדי לא להמיר למחרוזת ובחזרה:

package main

import (
	"bytes"
	"fmt"
)

func main() {
	data := []byte("name=ana\nrole=admin\n")

	for _, line := range bytes.Split(bytes.TrimSpace(data), []byte("\n")) {
		key, value, _ := bytes.Cut(line, []byte("="))
		fmt.Printf("%s -> %s\n", key, value)
	}

	var buf bytes.Buffer
	buf.WriteString("hello, ")
	buf.Write([]byte("bytes"))
	buf.WriteByte('!')
	fmt.Println(buf.String(), buf.Len())

	fmt.Println(bytes.Equal([]byte("a"), []byte("a")))
}

bytes.Buffer הוא buffer של בתים שגדל לפי הצורך ומממש את io.Reader ואת io.Writer. הוא הכלי הנכון כשגם כותבים וגם קוראים בתים; לבניית מחרוזת, strings.Builder זול מעט יותר. השוו slices של בתים עם bytes.Equal, כי == לא עובד על slices.

איך לבחור ביניהם

• טקסט שמציגים, משווים או מחפשים בו: השאירו אותו string, והשתמשו ב-range כשעוברים עליו תו אחרי תו.
• מיקומי תווים, היפוך, קיצור ל-n תווים: המירו ל-[]rune.
• קלט ופלט, hashing, קידוד, פרוטוקולים בינאריים: השתמשו ב-[]byte ובחבילה bytes.
• תו בודד: rune. בית גולמי בודד: byte.