Rune dan Byte di Golang: Penjelasan String UTF-8

String di Go adalah rangkaian byte, dan source code serta literal string Go memakai UTF-8. byte adalah salah satu byte itu. rune adalah satu karakter Unicode (sebuah code point), yang disimpan UTF-8 dalam 1 sampai 4 byte. Sebagian besar kebingungan soal string di Go berasal dari tertukarnya keduanya:

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

語 berukuran tiga byte di UTF-8, jadi "語Go" berukuran 5 byte tapi berisi 3 rune. Loop indeks melihat lima byte, dan byte 0, 1, dan 2 tidak bermakna kalau berdiri sendiri. Loop range men-decode UTF-8 dan menghasilkan tiga rune di indeks 0, 3, dan 4: i selalu merupakan offset byte, bukan jumlah karakter.

byte dan rune adalah alias

Karena keduanya alias, byte adalah uint8 dan rune adalah int32; tidak perlu konversi antara alias dan tipe dasarnya. Tanda kutip tunggal menghasilkan rune, tanda kutip ganda menghasilkan string. 'ab' adalah compile error, karena literal rune berisi tepat satu karakter.

Rune adalah angka, jadi kamu bisa melakukan aritmetika padanya:

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' adalah cara klasik untuk mengubah karakter digit menjadi nilainya. Package unicode mengklasifikasikan rune (IsLetter, IsDigit, IsSpace, IsUpper) dan mengubah huruf besar dan kecil dengan benar untuk huruf non-ASCII. %c mencetak rune sebagai karakter, %U dalam bentuk U+4E16, %q sebagai literal rune bertanda kutip.

Cara UTF-8 menyimpan karakter

Teks ASCII sama persis di UTF-8, itulah sebabnya kode berbasis byte sering berjalan lancar saat diuji lalu rusak pada nama pertama yang memakai aksen. Konverter teks ke biner menampilkan byte UTF-8 dari teks apa pun yang kamu tempel. Package unicode/utf8 bekerja langsung dengan encoding-nya:

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 (dengan spasi) mencetak byte dalam heksadesimal yang dipisahkan spasi. utf8.ValidString melaporkan apakah sebuah string berisi UTF-8 yang valid. String Go boleh berisi byte apa pun, tidak hanya UTF-8 yang valid; saat range bertemu byte yang tidak valid, ia menghasilkan utf8.RuneError (U+FFFD, karakter pengganti) lalu maju satu byte.

Konversi antara string, []byte, dan []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))
}

Membalik berdasarkan byte akan mengacak 世界 menjadi UTF-8 yang tidak valid, itulah sebabnya reverse bekerja pada rune. Bahkan rune pun belum menceritakan semuanya: karakter seperti é juga bisa ditulis sebagai e ditambah aksen kombinasi, yaitu dua rune. Untuk karakter yang terlihat oleh pengguna (grapheme cluster), pakai library seperti github.com/rivo/uniseg.

Setiap konversi melakukan penyalinan, karena string bersifat immutable sedangkan slice tidak. Di kode yang sering dieksekusi, hindari konversi bolak-balik; compiler mengoptimalkan beberapa kasus (seperti string(b) yang dipakai sebagai key map atau dalam perbandingan) untuk melewati penyalinan.

Indeks menghasilkan byte

s[i] mengembalikan byte, dan s[i:j] memotong berdasarkan offset byte:

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]) adalah jebakan: mengubah satu byte menjadi string memperlakukannya sebagai code point 195, yaitu Ã, bukan byte itu sendiri. Untuk menemukan batas karakter, pakai range, keluarga strings.Index (yang mengembalikan offset byte yang selalu tepat di batas karakter), atau utf8.DecodeRuneInString.

Package bytes

bytes adalah cerminan strings untuk []byte: bytes.Contains, bytes.Split, bytes.Fields, bytes.TrimSpace, bytes.Equal, bytes.ToUpper, dan seterusnya. Pakai package ini saat data datang dalam bentuk byte (isi file, body HTTP, buffer jaringan), supaya kamu tidak perlu mengubahnya menjadi string lalu kembali lagi:

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 adalah buffer byte yang bisa membesar dan mengimplementasikan io.Reader serta io.Writer. Ini alat yang tepat saat kamu menulis sekaligus membaca byte; untuk menyusun string, strings.Builder sedikit lebih murah. Bandingkan byte slice dengan bytes.Equal, karena == tidak bisa dipakai pada slice.

Memilih di antara keduanya

• Teks yang kamu tampilkan, bandingkan, atau cari: biarkan sebagai string, dan pakai range saat menelusurinya karakter demi karakter.
• Posisi karakter, membalik, memotong menjadi n karakter: ubah menjadi []rune.
• I/O, hashing, encoding, protokol biner: pakai []byte dan package bytes.
• Satu karakter: rune. Satu byte mentah: byte.