Go语言中UTF-16文本文件的正确读取与处理

package main

import (
    "bufio"
    "fmt"
    "os"
)

func main() {
    f, err := os.Open("test.txt") // 假设 test.txt 是 UTF-16 编码
    if err != nil {
        fmt.Printf("error opening file: %v\n", err)
        os.Exit(1)
    }
    defer f.Close() // 确保文件关闭

    r := bufio.NewReader(f)
    s, _, e := r.ReadLine() // ReadLine 无法正确处理 UTF-16
    if e == nil {
        fmt.Println("原始字节:", s)
        fmt.Println("转换为字符串 (错误):", string(s)) // 此时会是乱码或错误字符
    }
}

package main

import (
    "bytes"
    "fmt"
    "io/ioutil" // 注意：ioutil 已被弃用，建议使用 os.ReadFile
    "log"
    "strings"

    "golang.org/x/text/encoding/unicode"
    "golang.org/x/text/transform"
)

// ReadFileUTF16 类似于 os.ReadFile，但会解码 UTF-16 编码的文件。
// 它能智能处理 BOM，并最终将内容转换为 UTF-8 字节切片。
func ReadFileUTF16(filename string) ([]byte, error) {
    // 1. 读取整个文件到原始字节切片
    raw, err := ioutil.ReadFile(filename) // 在 Go 1.16+ 中，建议使用 os.ReadFile
    if err != nil {
        return nil, err
    }

    // 2. 创建一个 UTF-16 解码器。
    // 这里我们默认以大端序（BigEndian）且忽略BOM的方式初始化，
    // 但 BOMOverride 会在后续步骤中智能地纠正字节序。
    win16be := unicode.UTF16(unicode.BigEndian, unicode.IgnoreBOM)

    // 3. 创建一个转换器，它会根据 BOM 智能地选择正确的 UTF-16 解码器。
    // unicode.BOMOverride 会尝试检测文件开头的 BOM (如 FE FF 或 FF FE)，
    // 并相应地调整字节序。如果不存在 BOM，它会回退到传入解码器的默认设置。
    utf16bom := unicode.BOMOverride(win16be.NewDecoder())

    // 4. 使用 transform.NewReader 将原始字节流包装起来，并应用 UTF-16 解码转换。
    // bytes.NewReader(raw) 将原始字节切片转换为一个 io.Reader。
    unicodeReader := transform.NewReader(bytes.NewReader(raw), utf16bom)

    // 5. 从转换后的读取器中读取所有解码后的字节。
    // 此时，读取到的 `decoded` 已经是 UTF-8 编码的字节切片。
    decoded, err := ioutil.ReadAll(unicodeReader)
    if err != nil {
        return nil, err
    }
    return decoded, nil
}

func main() {
    // 假设 "inputfile.txt" 是一个 UTF-16 编码的文件
    data, err := ReadFileUTF16("inputfile.txt")
    if err != nil {
        log.Fatalf("读取 UTF-16 文件失败: %v", err)
    }

    // 将解码后的 UTF-8 字节切片转换为字符串
    finalString := string(data)

    // 注意：Windows 系统的 UTF-16 文件可能使用 "\r\n" 作为行结束符。
    // 在转换为 Go 字符串后，为了跨平台一致性，通常建议将其标准化为 "\n"。
    normalizedString := strings.ReplaceAll(finalString, "\r\n", "\n")

    fmt.Println("解码并标准化后的内容:")
    fmt.Println(normalizedString)
}

package main

import (
    "bufio"
    "fmt"
    "log"
    "os"

    "golang.org/x/text/encoding/unicode"
    "golang.org/x/text/transform"
)

// NewScannerUTF16 创建一个类似于 os.Open 的读取器，但会解码 UTF-16 编码的文件。
// 它能智能处理 BOM，并返回一个 io.Reader 接口，该接口可用于 bufio.NewScanner。
func NewScannerUTF16(filename string) (*transform.Reader, error) { // 返回具体类型以方便使用
    // 1. 打开文件
    file, err := os.Open(filename)
    if err != nil {
        return nil, err
    }
    // 注意：这里没有 defer file.Close()，因为文件句柄需要传递给 transform.NewReader，
    // 并在外部的 scanner 使用完毕后由调用者负责关闭。
    // 通常，当 bufio.Scanner 结束时，它会关闭底层的 io.Reader，
    // 但 transform.Reader 不会自动关闭其底层 Reader。
    // 因此，在 main 函数中，我们需要在 scanner 结束后手动关闭 file。

    // 2. 创建一个 UTF-16 解码器 (同 ReadFileUTF16)
    win16be := unicode.UTF16(unicode.BigEndian, unicode.IgnoreBOM)
    utf16bom := unicode.BOMOverride(win16be.NewDecoder())

    // 3. 使用 transform.NewReader 包装文件句柄，应用 UTF-16 解码转换。
    unicodeReader := transform.NewReader(file, utf16bom)
    return unicodeReader, nil
}

func main() {
    // 假设 "inputfile.txt" 是一个 UTF-16 编码的文件
    // 1. 获取一个解码 UTF-16 的读取器
    unicodeReader, err := NewScannerUTF16("inputfile.txt")
    if err != nil {
        log.Fatalf("创建 UTF-16 扫描器失败: %v", err)
    }
    // 确保在程序结束时关闭原始文件句柄
    // 由于 NewScannerUTF16 返回的是 transform.Reader，其内部持有 os.File，
    // 我们需要获取并关闭 os.File。
    // 一个更健壮的实现可能让 NewScannerUTF16 返回一个结构体，包含 Reader 和 Close 方法。
    // 为简化示例，这里假设 transform.Reader 内部的 file 会被管理，
    // 但在实际生产代码中，应确保 os.File 被正确关闭。
    // 实际上，transform.Reader 不提供直接关闭其底层 io.Reader 的方法。
    // 更好的做法是：
    f, err := os.Open("inputfile.txt")
    if err != nil {
        log.Fatalf("打开文件失败: %v", err)
    }
    defer f.Close() // 确保原始文件句柄被关闭

    win16be := unicode.UTF16(unicode.BigEndian, unicode.IgnoreBOM)
    utf16bom := unicode.BOMOverride(win16be.NewDecoder())
    s := transform.NewReader(f, utf16bom)


    // 2. 使用 bufio.NewScanner 包装这个解码读取器
    scanner := bufio.NewScanner(s)

    // 3. 逐行扫描并打印
    fmt.Println("逐行解码并打印内容:")
    for scanner.Scan() {
        // scanner.Text() 返回的是已经解码为 UTF-8 的字符串
        // 同样，Windows 的 \r\n 会被保留，如果需要标准化，可以在这里处理
        line := scanner.Text()
        normalizedLine := strings.ReplaceAll(line, "\r\n", "\n") // 针对每一行进行标准化
        fmt.Println(normalizedLine)
    }

    // 4. 检查扫描过程中是否发生错误
    if err := scanner.Err(); err != nil {
        fmt.Fprintf(os.Stderr, "扫描文件时出错: %v\n", err)
    }
}