深入剖析go中字串的編碼問題——特殊字元的string怎麼轉byte？

來自公眾號：新世界雜貨鋪

前言

前段時間發表了Go中的HTTP請求之——HTTP1.1請求流程分析，所以這兩天本來打算研究HTTP2.0的請求原始碼，結果發現太複雜就跑去逛知乎了，然後就發現了一個非常有意思的提問“golang 特殊字元的string怎麼轉成[]byte?”。為了轉換一下心情， 便有了此篇文章。

問題

原問題我就不碼字了，直接上圖：

看到問題，我的第一反應是ASCII碼值範圍應該是0~127呀，怎麼會超過127呢？直到實際執行的時候才發現上圖的特殊字元是‘’（如果無法展示，記住該特殊字元的unicode是\u0081），並不是英文中的句號。

unicode和utf-8的恩怨糾葛

百度百科已經把unicode和utf-8介紹的很詳細了，所以這裡就不做過多的闡述，僅摘抄部分和本文相關的定義：

• Unicode為每個字元設定了統一併且唯一的二進位制編碼，通常用兩個位元組表示一個字元。
• UTF-8是針對Unicode的一種可變長度字元編碼。它可以用來表示Unicode標準中的任何字元。UTF-8的特點是對不同範圍的字元使用不同長度的編碼。對於0x00-0x7F之間的字元，UTF-8編碼與ASCII編碼完全相同。

go中的字元

眾所周知，go中能表示字元的有兩種型別，分別是byte和rune，byte和rune的定義分別是：type byte = uint8和type rune = int32。

uint8範圍是0-255，只能夠表示有限個unicode字元，超過255的範圍就會編譯報錯。根據上述關於unicode的定義，4位元組的rune完全相容兩位元組的unicode。

我們用下面的程式碼來驗證：

var (
        c1 byte = 'a'
        c2 byte = '新'
        c3 rune = '新'
    )
    fmt.Println(c1, c2, c3)

上述的程式根本無法執行，因為第二行編譯會報錯，vscode給到了十分詳細的提示：'新' (untyped rune constant 26032) overflows byte。

接下來，我們通過下面的程式碼來驗證字元和unicode和整型的等價關係：

    fmt.Printf("0x%x, %d\n", '', '') //輸出：0x81, 129
    fmt.Println(0x81 == '', '\u0081' == '', 129 == '') // 輸出：true true true
    //\u0081輸出到螢幕上後不展示， 所以換了大寫字母A來輸出
    fmt.Printf("%c\n", 65) // 輸出：A

根據上面的程式碼輸出的3個true可以知道，字元和unicode和整形是等價，並且整型也能轉回字元的表現形式。

go中的字串是utf8編碼的

根據golang官方部落格https://blog.golang.org/strings的原文：

Go source code is always UTF-8.
A string holds arbitrary bytes.
A string literal, absent byte-level escapes, always holds valid UTF-8 sequences.

翻譯整理過來其實也就是兩點：

1. go中的程式碼總是用utf8編碼，並且字串能夠儲存任何位元組。
2. 沒有經過位元組級別的轉義，那麼字串是一個標準的utf8序列。

有了前面的基礎知識和字串是一個標準的utf8序列這一結論後我們接下來對字串“”（如果無法展示，記住該特殊字元的unicode是\u0081）手動編碼。

Unicode到UTF-8的編碼方對照表：

字元‘’（如果無法展示，記住該特殊字元的unicode是\u0081）的二進位制表示為10000001，16進製表示為0x81。

根據unicode轉utf8的對照表，0x7f < 0x81 < 0x7ff，所以此特殊字元需佔兩個位元組，並且要套用的utf8模版是110xxxxx 10xxxxxx。

我們按照下面的步驟對10000001轉為utf8的二進位制序列：

第一步：根據x數量對特殊字元的高位補0。x的數量是11，所以需要對特殊字元的高位補3個0，此時特殊字元的二進位制表示為：00010000001。

第二步：x有兩個部分，且長度分別是5和6，所以對00010000001由底位向高位分別擷取6位和5位，得到000001和00010。

第三步：將000001和00010由低位向高位填充至模版110xxxxx 10xxxxxx，可得到utf8的二進位制序列為：11000010 10000001。

我們通過go對二進位制轉為整型：

fmt.Printf("%d, %d\n", 0b11000010, 0b10000001)
// 輸出：194, 129

綜上：當用字元轉位元組時輸出的是字元本身的整型值，當用字串轉位元組切片時，實際上是輸出的是utf8的位元組切片序列(go中的字串儲存的就是utf8位元組切片)。此時，我們回顧一下最開始的問題，就會發現輸出是完全符合預期的。

go中的rune

筆者在這裡猜測提問者期望的結果是“字串轉位元組切片和字元轉位元組的結果保持一致”，這時rune就派上用場了，我們看看使用rune的效果：

fmt.Println([]rune(""))
// 輸出：[129]

由上可知用rune切片去轉字串時，它是直接將每個字元轉為對應的unicode。

我們通過下面的程式碼模擬字串轉為[]rune切片和[]rune切片轉為字串的過程：

字串轉為rune切片:

    // 字串直接轉為[]rune切片
    for _, v := range []rune("新世界雜貨鋪") {
        fmt.Printf("%x ", v)
    }
    fmt.Println()
    bs := []byte("新世界雜貨鋪")
    for len(bs) > 0 {
        r, w := utf8.DecodeRune(bs)
        fmt.Printf("%x ", r)
        bs = bs[w:]
    }
    fmt.Println()
    // 輸出:
    // 65b0 4e16 754c 6742 8d27 94fa
    // 65b0 4e16 754c 6742 8d27 94fa

上述程式碼中utf8.DecodeRune的作用是通過傳入的utf8位元組序列轉為一個rune即unicode。

rune切片轉為字串:

    // rune切片轉為字串
    rs := []rune{0x65b0, 0x4e16, 0x754c, 0x6742, 0x8d27, 0x94fa}
    fmt.Println(string(rs))
    utf8bs := make([]byte, 0)
    for _, r := range rs {
        bs := make([]byte, 4)
        w := utf8.EncodeRune(bs, r)
        utf8bs = append(utf8bs, bs[:w]...)
    }
    fmt.Println(string(utf8bs))
    // 輸出:
    // 新世界雜貨鋪
    // 新世界雜貨鋪

上述程式碼中utf8.EncodeRune的作用是將一個rune轉為utf8位元組序列。

綜上：對於無法確定字串中僅有單位元組的字元的情況， 請使用rune，每一個rune型別代表一個unicode字元，並且它可以和字串做無縫切換。

理解go中的字串其實是位元組切片

前面已經提到了字串能夠儲存任意位元組資料，而且是一個標準的utf8格式的位元組切片。那麼本節將會通過程式碼來加深印象。

    fmt.Println([]byte("新世界雜貨鋪"))
    s := "新世界雜貨鋪"
    for i := 0; i < len(s); i++ {
        fmt.Print(s[i], " ")
    }
    fmt.Println()
    // 輸出：
    // [230 150 176 228 184 150 231 149 140 230 157 130 232 180 167 233 147 186]
    // 230 150 176 228 184 150 231 149 140 230 157 130 232 180 167 233 147 186

由上述的程式碼可知，我們通過遊標按位元組訪問字串得到的結果和字串轉為位元組切片是一樣的，因此可以再次確認字串和位元組切片是等價的。

通常情況下我們的字串都是標準utf8格式的位元組切片，但這並不是說明字串只能儲存utf8格式的位元組切片，go中的字串可以儲存任意的位元組資料。

    bs := []byte{65, 73, 230, 150, 176, 255}
    fmt.Println(string(bs))         // 將隨機的位元組切片轉為字串
    fmt.Println([]byte(string(bs))) // 將字串再次轉回位元組切片

    rs := []rune(string(bs)) // 將字串轉為位元組rune切片
    fmt.Println(rs)          // 輸出rune切片
    fmt.Println(string(rs))  // 將rune切片轉為字串

    for len(bs) > 0 {
        r, w := utf8.DecodeRune(bs)
        fmt.Printf("%d: 0x%x ", r, r) // 輸出rune的值和其對應的16進位制
        bs = bs[w:]
    }
    fmt.Println()
    fmt.Println([]byte(string(rs))) // 將rune切片轉為字串後再次轉為位元組切片
    // 輸出：
    // AI新�
    // [65 73 230 150 176 255]
    // [65 73 26032 65533]
    // AI新�
    // 65: 0x41 73: 0x49 26032: 0x65b0 65533: 0xfffd 
    // [65 73 230 150 176 239 191 189]

仔細閱讀上面的程式碼和輸出，前5行的輸出應該是沒有疑問的。但是第6行輸出卻和預期有出入。

前面提到了字串可以儲存任意的位元組資料，那如果儲存的位元組資料不是標準的utf8位元組切片就會出現上面的問題。

我們已經知道通過utf8.DecodeRune可以將位元組切片轉為rune。那如果碰到不符合utf8編碼規範的位元組切片時，utf8.DecodeRune會返回一個容錯的unicode\uFFFD，這個unicode對應上面輸出的16進位制0xfffd。

問題也就出現在這個容錯的unicode\uFFFD上，因為位元組切片不符合utf8編碼規範無法得到正確的unicode，既\uFFFD佔據了本應該是正確的unicode所在的位置。這個時候再將已經含有容錯字元的rune切片轉為字串時，字串儲存的就是合法的utf8位元組切片了，因此第六行輸出的是含有\uFFFD的合法utf8位元組切片，也就產生了和最初始的位元組切片不一致的情況了。

⚠️：在平時的開發中要注意rune切片和byte切片的相互轉換一定要基於沒有亂碼的字串(內部是符合utf8編碼規則的位元組切片)，否則容易出現上述類似的錯誤。

字串的多種表示方式

本節算是擴充套件了，在開發中還是儘量別用這種特殊的表示方式，雖然看起來很高階但是可讀性太差。

下面直接看程式碼：

    bs := []byte([]byte("新"))
    for i := 0; i < len(bs); i++ {
        fmt.Printf("0x%x ", bs[i])
    }
    fmt.Println()
    fmt.Println("\xe6\x96\xb0")
    fmt.Println("\xe6\x96\xb0世界雜貨鋪" == "新世界雜貨鋪")
    fmt.Println('\u65b0' == '新')
    fmt.Println("\u65b0世界雜貨鋪" == "新世界雜貨鋪")
    // 輸出:
    // 0xe6 0x96 0xb0 
    // 新
    // true
    // true
    // true

目前筆者僅發現unicode和單位元組的16進位制可以直接用在字串中， 歡迎讀者提供更多的表示方式以供交流。

最後，祝大家讀完此篇文章後能夠有所收穫。