Go语言中从io.Reader读取UTF-8编码字符串的实践指南

// 示例：string和[]byte的特性
var s string = "Hello"
// s[0] = 'h' // 编译错误：string是不可变的

b := make([]byte, 5)
b[0] = 'H'
b[1] = 'e'
b[2] = 'l'
b[3] = 'l'
b[4] = 'o'
fmt.Println(string(b)) // 输出: Hello

package main

import "fmt"

func main() {
    byteSlice := []byte{0xE4, 0xBD, 0xA0, 0xE5, 0xA5, 0xBD} // "你好"的UTF-8编码
    str := string(byteSlice) // []byte转换为string，发生数据复制
    fmt.Printf("字符串: %s, 长度(字节): %d, 长度(rune): %d\n", str, len(str), len([]rune(str)))

    newByteSlice := []byte(str) // string转换为[]byte，再次发生数据复制
    fmt.Printf("字节切片: %v\n", newByteSlice)
}

package main

import (
    "bytes"
    "fmt"
    "io"
)

// ReadUTF8String 从io.Reader中读取指定长度的UTF-8编码字符串
func ReadUTF8String(reader io.Reader, length int) (string, error) {
    // 1. 准备字节切片
    // 推荐复用字节切片以减少GC压力，这里为了演示每次创建新的
    buf := make([]byte, length)

    // 2. 读取字节
    n, err := io.ReadFull(reader, buf)
    if err != nil {
        return "", fmt.Errorf("读取字节失败: %w", err)
    }
    if n != length {
        return "", fmt.Errorf("期望读取%d字节，实际读取%d字节", length, n)
    }

    // 3. 转换为字符串
    // 这一步会发生数据复制，将buf的内容复制到新的string实例中
    return string(buf), nil
}

func main() {
    // 模拟一个io.Reader，包含UTF-8编码的字符串 "你好世界"
    // "你好世界" 的UTF-8编码是 0xE4BDA0E5A5BDE4B896E7958C，共12字节
    data := []byte{0xE4, 0xBD, 0xA0, 0xE5, 0xA5, 0xBD, 0xE4, 0xB8, 0x96, 0xE7, 0x95, 0x8C}
    reader := bytes.NewReader(data)

    // 假设我们知道要读取的字符串长度是12字节
    str, err := ReadUTF8String(reader, 12)
    if err != nil {
        fmt.Printf("错误: %v\n", err)
        return
    }
    fmt.Printf("成功读取字符串: \"%s\"\n", str) // 输出: 成功读取字符串: "你好世界"

    // 尝试读取另一个字符串，假设长度为6字节
    data2 := []byte{0x65, 0x6E, 0x67, 0x6C, 0x69, 0x73, 0x68} // "english" (7字节)
    reader2 := bytes.NewReader(data2)
    str2, err := ReadUTF8String(reader2, 6) // 只读取前6字节
    if err != nil {
        fmt.Printf("错误: %v\n", err)
        return
    }
    fmt.Printf("成功读取字符串: \"%s\"\n", str2) // 输出: 成功读取字符串: "englis"
}

package main

import (
    "bytes"
    "fmt"
    "io"
)

// Global (or passed as argument) byte buffer for reuse
var sharedBuffer = make([]byte, 1024) // 预分配一个足够大的缓冲区

// ReadUTF8StringOptimized 从io.Reader中读取指定长度的UTF-8编码字符串，复用缓冲区
func ReadUTF8StringOptimized(reader io.Reader, length int) (string, error) {
    if length > len(sharedBuffer) {
        // 如果所需长度超过共享缓冲区，需要重新分配或处理错误
        return "", fmt.Errorf("所需字符串长度 (%d) 超过共享缓冲区大小 (%d)", length, len(sharedBuffer))
    }

    // 使用共享缓冲区的一部分
    buf := sharedBuffer[:length]

    n, err := io.ReadFull(reader, buf)
    if err != nil {
        return "", fmt.Errorf("读取字节失败: %w", err)
    }
    if n != length {
        return "", fmt.Errorf("期望读取%d字节，实际读取%d字节", length, n)
    }

    // 转换为字符串，数据仍然会被复制，但避免了每次都分配新的[]byte切片
    return string(buf), nil
}

func main() {
    data := []byte{0xE4, 0xBD, 0xA0, 0xE5, 0xA5, 0xBD, 0xE4, 0xB8, 0x96, 0xE7, 0x95, 0x8C} // "你好世界"
    reader := bytes.NewReader(data)

    str, err := ReadUTF8StringOptimized(reader, 12)
    if err != nil {
        fmt.Printf("错误: %v\n", err)
        return
    }
    fmt.Printf("成功读取字符串 (优化版): \"%s\"\n", str)

    // 模拟多次读取
    data2 := []byte{0x47, 0x6F, 0x4C, 0x61, 0x6E, 0x67} // "GoLang" (6字节)
    reader2 := bytes.NewReader(data2)
    str2, err := ReadUTF8StringOptimized(reader2, 6)
    if err != nil {
        fmt.Printf("错误: %v\n", err)
        return
    }
    fmt.Printf("成功读取字符串 (优化版): \"%s\"\n", str2)
}