rune وbyte في Golang: شرح نصوص UTF-8

النص في Go سلسلة من البايتات، وملفات Go المصدرية وحرفيات النصوص بترميز UTF-8. الـ byte واحد من تلك البايتات. والـ rune حرف Unicode واحد (نقطة رمز)، يخزّنه UTF-8 في بايت إلى 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" خمسة بايتات لكنه 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.

كل تحويل ينسخ، لأن النصوص غير قابلة للتعديل والشرائح قابلة. في الشيفرة الساخنة تجنّب التحويل ذهابًا وإيابًا؛ يحسّن المترجم بعض الحالات (مثل string(b) المستخدمة كمفتاح خريطة أو في مقارنة) فيتخطّى النسخ.

الفهرسة تعطي بايتًا

تعيد 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 يعامله كنقطة الرمز 195، أي Ã، لا البايت نفسه. لإيجاد حدود الأحرف استخدم range، أو عائلة strings.Index (التي تعيد إزاحات بايتات تقع دائمًا على الحدود)، أو utf8.DecodeRuneInString.

الحزمة bytes

تحاكي bytes الحزمة strings للنوع []byte: bytes.Contains وbytes.Split وbytes.Fields وbytes.TrimSpace وbytes.Equal وbytes.ToUpper وغيرها. استخدمها عندما تصل البيانات كبايتات (محتوى الملفات، أجسام HTTP، مخازن الشبكة)، كي لا تحوّل إلى نص ثم تعود:

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 مخزن بايتات قابل للنمو يطبّق io.Reader وio.Writer. وهو الأداة الصحيحة عندما تكتب البايتات وتقرؤها معًا؛ أما لبناء نص فإن strings.Builder أرخص قليلًا. قارن شرائح البايتات بـ bytes.Equal، لأن == لا تعمل مع الشرائح.

الاختيار بينها

• النص الذي تعرضه أو تقارنه أو تبحث فيه: أبقه string، واستخدم range عندما تمشي عليه حرفًا حرفًا.
• مواضع الأحرف، والعكس، والاقتطاع إلى n حرفًا: حوّل إلى []rune.
• الإدخال والإخراج، والتجزئة، والترميز، والبروتوكولات الثنائية: استخدم []byte والحزمة bytes.
• حرف واحد: rune. بايت خام واحد: byte.