Golang Rune ve Byte: UTF-8 String'ler

Bir Go string'i bir bayt dizisidir; Go kaynak kodu ve string literal'leri UTF-8'dir. Bir byte bu baytlardan biridir. Bir rune ise UTF-8'in 1 ila 4 baytta sakladığı tek bir Unicode karakteridir (bir kod noktası). Go'daki string karışıklığının çoğu ikisini birbirine karıştırmaktan gelir:

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'de üç bayttır, bu yüzden "語Go" 5 bayt ama 3 rune'dur. İndeks döngüsü beş bayt görür ve 0, 1 ve 2 numaralı baytlar tek başlarına anlamsızdır. range döngüsü UTF-8'i çözer ve 0, 3 ve 4 indekslerinde üç rune verir: i her zaman bir karakter sayısı değil, bir bayt konumudur.

byte ve rune Takma Addır

Takma ad oldukları için bir byte bir uint8, bir rune bir int32'dir; takma ad ile temel tipi arasında dönüşüm gerekmez. Tek tırnak bir rune, çift tırnak bir string oluşturur. 'ab' bir derleme hatasıdır, çünkü bir rune literal'i tam olarak bir karakter tutar.

Rune'lar sayıdır, bu yüzden üzerlerinde aritmetik yapabilirsiniz:

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', bir rakam karakterini değerine çevirmenin klasik yoludur. unicode paketi rune'ları sınıflandırır (IsLetter, IsDigit, IsSpace, IsUpper) ve ASCII olmayan harfler için büyük/küçük harfi doğru değiştirir. %c bir rune'u karakter olarak, %U U+4E16 biçiminde, %q tırnaklı bir rune literal'i olarak yazdırır.

UTF-8 Karakterleri Nasıl Saklar

ASCII metin UTF-8'de aynıdır; bayt tabanlı kodun testte çoğu zaman çalışıp ilk aksanlı adda bozulmasının nedeni budur. unicode/utf8 paketi doğrudan kodlamayla çalışır:

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 (boşlukla) baytları boşluklarla ayrılmış onaltılık olarak yazdırır. utf8.ValidString bir string'in geçerli UTF-8 olup olmadığını bildirir. Go string'leri yalnızca geçerli UTF-8 değil, herhangi bir bayt tutabilir; range geçersiz bir baytla karşılaştığında utf8.RuneError (U+FFFD, yedek karakter) verir ve bir bayt ilerler.

string, []byte ve []rune Arasında Dönüşüm

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

Baytlara göre ters çevirmek 世界'yi geçersiz UTF-8'e karıştırırdı; reverse'ün rune'lar üzerinde çalışmasının nedeni budur. Rune'lar bile hikâyenin tamamı değildir: é gibi bir karakter e artı birleşen bir aksan olarak da yazılabilir, bu da iki rune'dur. Kullanıcıya görünen karakterler (grapheme cluster'lar) için github.com/rivo/uniseg gibi bir kütüphane kullanın.

Her dönüşüm kopyalar, çünkü string'ler değiştirilemez, slice'lar değiştirilebilirdir. Sık çalışan kodda ileri geri dönüştürmekten kaçının; derleyici bazı durumları (map anahtarı ya da bir karşılaştırmada kullanılan string(b) gibi) kopyayı atlayacak şekilde optimize eder.

İndeksleme Bir Bayt Verir

s[i] bir byte döndürür ve s[i:j] bayt konumlarına göre dilimler:

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]) bir tuzaktır: tek bir baytı string'e dönüştürmek onu baytın kendisi olarak değil, kod noktası 195 olan Ã olarak ele alır. Karakter sınırlarını bulmak için range'i, strings.Index ailesini (her zaman sınırlarda olan bayt konumları döndürürler) ya da utf8.DecodeRuneInString'i kullanın.

bytes Paketi

bytes, []byte için strings'in aynısıdır: bytes.Contains, bytes.Split, bytes.Fields, bytes.TrimSpace, bytes.Equal, bytes.ToUpper ve diğerleri. Veri bayt olarak geldiğinde (dosya içerikleri, HTTP gövdeleri, ağ buffer'ları) onu kullanın, böylece string'e çevirip geri dönüştürmezsiniz:

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 ve io.Writer'ı gerçekleştiren büyüyebilen bir bayt buffer'ıdır. Baytları hem yazıp hem okuduğunuzda doğru araçtır; bir string oluşturmak için strings.Builder biraz daha ucuzdur. == slice'larda çalışmadığı için byte slice'larını bytes.Equal ile karşılaştırın.

Aralarında Seçim Yapmak

• Gösterdiğiniz, karşılaştırdığınız ya da aradığınız metin: onu bir string olarak tutun ve karakter karakter dolaşırken range kullanın.
• Karakter konumları, ters çevirme, n karaktere kırpma: []rune'a dönüştürün.
• G/Ç, hash'leme, kodlama, ikili protokoller: []byte ve bytes paketini kullanın.
• Tek bir karakter: bir rune. Tek bir ham bayt: bir byte.