Go语言中UTF-8编码字符串的读取与处理实践

// 从 []byte 转换为 string
b := []byte{'h', 'e', 'l', 'l', 'o'}
s := string(b) // 此时，b的内容会被复制到新的字符串s中

// 从 string 转换为 []byte
s2 := "world"
b2 := []byte(s2) // 此时，s2的内容会被复制到新的字节切片b2中

package main

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

// readUTF8String 从 io.Reader 中读取指定长度的字节，并将其转换为 UTF-8 字符串
// length 参数表示预期的字符串字节长度
func readUTF8String(reader io.Reader, length int) (string, error) {
    // 1. 准备缓冲区
    buf := make([]byte, length)

    // 2. 读取数据
    // io.ReadFull 会确保读取到指定长度的字节，否则返回错误
    n, err := io.ReadFull(reader, buf)
    if err != nil {
        return "", fmt.Errorf("无法从io.Reader中读取所有字节: %w", err)
    }
    if n != length {
        // 理论上io.ReadFull已经处理了这种情况，但此处仍可作为额外检查
        return "", fmt.Errorf("预期读取%d字节，实际读取%d字节", length, n)
    }

    // 3. 转换为字符串
    // 此时 buf 的内容会被复制到一个新的字符串中
    return string(buf), nil
}

func main() {
    // 模拟一个包含UTF-8编码字符串的io.Reader
    utf8Data := []byte("你好 Go语言! ?") // 这是一个UTF-8编码的字节序列
    reader := bytes.NewReader(utf8Data)

    // 假设我们从协议中得知字符串的字节长度
    expectedByteLength := len(utf8Data) // 实际应用中这个长度会从协议头中解析

    // 调用函数读取字符串
    readStr, err := readUTF8String(reader, expectedByteLength)
    if err != nil {
        fmt.Printf("读取字符串失败: %v\n", err)
        return
    }

    fmt.Printf("成功读取字符串: \"%s\"\n", readStr)
    fmt.Printf("字符串的字节长度: %d\n", len(readStr))
    fmt.Printf("字符串的rune（字符）数量: %d\n", len([]rune(readStr)))

    // 示例：尝试读取一个比实际数据短的长度
    readerShort := bytes.NewReader(utf8Data)
    _, err = readUTF8String(readerShort, 5) // 尝试只读取5个字节
    if err != nil {
        fmt.Printf("\n尝试读取短长度时发生错误: %v\n", err)
    }

    // 示例：尝试读取一个比实际数据长的长度
    readerLong := bytes.NewReader(utf8Data)
    _, err = readUTF8String(readerLong, expectedByteLength+5) // 尝试读取更多字节
    if err != nil {
        fmt.Printf("尝试读取长长度时发生错误: %v\n", err)
    }
}

package main

import (
    "bytes"
    "fmt"
    "io"
    "reflect"
    "unsafe"
)

// unsafeBytesToString 尝试在不复制数据的情况下将 []byte 转换为 string
// !!! 极度危险，不推荐在生产环境使用 !!!
func unsafeBytesToString(b []byte) string {
    // 使用 reflect.StringHeader 结构体来操作字符串的底层结构
    // StringHeader 包含 Data (指向底层字节数组的指针) 和 Len (长度)
    return *(*string)(unsafe.Pointer(&b)) // 这种转换是错误的，会直接把[]byte的header当成string的header
    // 正确的unsafe转换应该像这样：
    /*
    bh := (*reflect.SliceHeader)(unsafe.Pointer(&b))
    sh := reflect.StringHeader{Data: bh.Data, Len: bh.Len}
    return *(*string)(unsafe.Pointer(&sh))
    */
}

// readUnsafeUTF8String 从 io.Reader 中读取指定长度的字节，并尝试避免复制转换为字符串
// !!! 极度危险，不推荐在生产环境使用 !!!
func readUnsafeUTF8String(reader io.Reader, length int) (string, error) {
    buf := make([]byte, length)
    n, err := io.ReadFull(reader, buf)
    if err != nil {
        return "", fmt.Errorf("无法从io.Reader中读取所有字节: %w", err)
    }
    if n != length {
        return "", fmt.Errorf("预期读取%d字节，实际读取%d字节", length, n)
    }

    // 真正的unsafe转换示例
    // 将字节切片的底层数据指针和长度直接赋给字符串的底层结构
    sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&buf))
    stringHeader := reflect.StringHeader{
        Data: sliceHeader.Data,
        Len:  sliceHeader.Len,
    }
    // 将构造好的StringHeader的指针转换为string指针，然后解引用
    s := *(*string)(unsafe.Pointer(&stringHeader))

    // 注意：一旦 buf 被修改或垃圾回收，s 将指向无效内存
    // 这是一个非常危险的操作，因为 buf 的生命周期可能比 s 短
    // 在此示例中，由于 buf 是局部变量，当函数返回后，其底层数组可能被回收，
    // 导致 s 成为悬空指针。
    // 为了安全，buf 必须在 s 的整个生命周期内保持有效且不可变。
    // 这通常意味着 buf 必须是全局的、或由调用者管理其生命周期，且在转换为字符串后不能再被修改。
    return s, nil
}

func main() {
    // 模拟一个包含UTF-8编码字符串的io.Reader
    utf8Data := []byte("这是一个非常长的字符串，假设它有几兆字节，我们希望避免复制。")
    reader := bytes.NewReader(utf8Data)

    expectedByteLength := len(utf8Data)

    // 使用标准安全方法
    safeStr, err := readUTF8String(reader, expectedByteLength)
    if err != nil {
        fmt.Printf("安全方法读取失败: %v\n", err)
    } else {
        fmt.Printf("安全方法读取字符串: \"%s\"\n", safeStr)
    }

    // 再次创建Reader，用于unsafe方法
    reader = bytes.NewReader(utf8Data)
    // 使用不安全方法 (仅作演示，不推荐)
    // 请注意，此处 unsafeBytesToString(buf) 的 buf 是局部变量，
    // 当函数返回后，buf 的底层数组可能被回收，导致返回的 string 成为悬空指针。
    // 这是一个典型的 unsafe 使用风险。
    unsafeStr, err := readUnsafeUTF8String(reader, expectedByteLength)
    if err != nil {
        fmt.Printf("不安全方法读取失败: %v\n", err)
    } else {
        fmt.Printf("不安全方法读取字符串: \"%s\"\n", unsafeStr)
        // 在此点，如果 buf 被修改或回收，unsafeStr 将不再有效。
        // 实际应用中，必须确保 buf 的生命周期与 unsafeStr 相同或更长，并且在转换后不再修改 buf。
    }
}