如何在不耗尽内存的情况下解码大型IBM866编码XML文件？

需要将一个约4GB的IBM866编码XML文件转换为UTF-8。尝试过iconv和encoding_rs两个crate，但都出现内存耗尽的情况。

尝试过两种实现方式：

方式一：一次性读取整个文件 #

fn ibm866_to_utf8(ibm866: &[u8]) -> Result<String, MyError> {
    use encoding_rs::IBM866;
    let (utf8, _, had_error) = IBM866.decode(ibm866);
    if (had_error == true) {
        Err(MyError::DecodingError)
    } else {
        Ok(utf8.to_string())
    }
}

fn main() {
    let path = "ibm866_file";
    let mut file = File::open(path).unwrap();
    let mut vec: Vec<u8> = Vec::with_capacity(file.metadata().unwrap().len() as usize);
    file.read_to_end(&mut vec);
    let utf8_string = ibm866_to_utf8(&vec).unwrap();
    // write to file
}

方式二：按行迭代文件 #

fn main() {
    let path = "ibm866_file";
    let mut file = File::open(path).unwrap();
    let mut reader = BufReader::new(file);
    let mut utf8_string = String::new();
    for line in reader.lines() {
        let utf8_line = ibm866_to_utf8(line.unwrap().as_bytes());
        utf8_string = format!("{}{}", utf8_string, utf8_line.unwrap());
    }
    // write to file
}

但reader.lines()遇到非UTF-8字符时会崩溃。

请问如何正确解码大型文件？

处理大文件的核心是流式处理，避免一次性加载整个文件到内存，同时要针对IBM866字节流做解码，而非先按UTF-8读取行（这是导致崩溃的直接原因）。

方案1：借助encoding_rs_io实现流式解码 #

encoding_rs_io封装了encoding_rs的解码逻辑，可以直接包装输入字节流，自动完成IBM866到UTF-8的转换，同时逐块处理：

use std::fs::{File, OpenOptions};
use std::io::{BufRead, BufReader, Write};
use encoding_rs::IBM866;
use encoding_rs_io::DecodeReaderBytes;

fn main() -> std::io::Result<()> {
    let input_file = File::open("ibm866_file")?;
    // 用DecodeReaderBytes包装输入流，自动处理编码转换
    let mut reader = BufReader::new(DecodeReaderBytes::new(input_file, IBM866));
    
    let mut output_file = OpenOptions::new()
        .create(true)
        .write(true)
        .truncate(true)
        .open("utf8_output.xml")?;
    
    // 8KB缓冲区，可根据硬件性能调整大小
    let mut buffer = [0; 8192];
    loop {
        let bytes_read = reader.read(&mut buffer)?;
        if bytes_read == 0 {
            break;
        }
        output_file.write_all(&buffer[..bytes_read])?;
    }
    
    Ok(())
}

需要在Cargo.toml中添加依赖：

[dependencies]
encoding_rs = "0.8"
encoding_rs_io = "0.1"

方案2：手动实现增量解码（无额外依赖） #

如果不想引入额外crate，可以直接使用encoding_rs的增量解码API，手动管理解码状态：

use std::fs::{File, OpenOptions};
use std::io::{BufRead, BufReader, Write};
use encoding_rs::IBM866;

fn main() -> std::io::Result<()> {
    let input_file = File::open("ibm866_file")?;
    let mut reader = BufReader::new(input_file);
    
    let mut output_file = OpenOptions::new()
        .create(true)
        .write(true)
        .truncate(true)
        .open("utf8_output.xml")?;
    
    let mut buffer = [0; 8192];
    let mut decoder = IBM866.new_decoder();
    let mut output_buffer = String::new();
    
    loop {
        let bytes_read = reader.read(&mut buffer)?;
        if bytes_read == 0 {
            // 处理最后剩余的解码内容
            let (result, _, _) = decoder.decode_to_string(&[], true, &mut output_buffer);
            output_file.write_all(result.as_bytes())?;
            break;
        }
        
        // 增量解码当前块，写入输出文件
        let (result, _, had_error) = decoder.decode_to_string(&buffer[..bytes_read], false, &mut output_buffer);
        if had_error {
            return Err(std::io::Error::new(std::io::ErrorKind::InvalidData, "解码过程中出现错误"));
        }
        
        output_file.write_all(result.as_bytes())?;
        output_buffer.clear();
    }
    
    Ok(())
}

关键注意事项 #

1. 拒绝一次性加载文件：无论输入还是输出，都用固定大小的缓冲区逐块处理，内存占用始终维持在缓冲区级别，彻底避免内存耗尽。
2. 禁用lines()方法：BufReader::lines()默认按UTF-8解析字节，而目标文件是IBM866编码，非UTF-8字节会直接触发panic，必须直接处理原始字节流。
3. 增量解码的必要性：即使IBM866是单字节编码，流式解码也能保证XML结构的完整性，避免因块分割破坏文本逻辑。

内容的提问来源于stack exchange，提问作者KindFrog