Go语言教程：实现位级文件写入（Bit-Level File Writing）

package main

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

// BitWriter 结构体用于将位写入底层 io.Writer
type BitWriter struct {
    writer *bufio.Writer // 使用 bufio.Writer 提高写入效率
    buffer byte          // 当前正在构建的字节
    count  uint8         // buffer 中已存储的位数 (0-7)
}

// NewBitWriter 创建一个新的 BitWriter 实例
func NewBitWriter(w io.Writer) *BitWriter {
    // 包装 io.Writer 以使用 bufio.Writer 提高写入性能
    return &BitWriter{
        writer: bufio.NewWriter(w),
        buffer: 0,
        count:  0,
    }
}

// WriteBit 写入一个位 (true为1, false为0)。
// 位将从当前字节的最高位（MSB）开始填充。
func (bw *BitWriter) WriteBit(bit bool) error {
    if bit {
        // 将当前位设置为1，通过左移操作将其放置在正确的位置
        // 例如，当count为0时，位放在第7位（最高位）
        bw.buffer |= (1 << (7 - bw.count))
    }
    bw.count++

    // 如果缓冲区已满（8位），则写入一个完整的字节
    if bw.count == 8 {
        _, err := bw.writer.Write([]byte{bw.buffer})
        if err != nil {
            return fmt.Errorf("failed to write byte: %w", err)
        }
        // 重置缓冲区和计数器
        bw.buffer = 0
        bw.count = 0
    }
    return nil
}

// WriteBits 写入指定数量的位。
// value: 要写入的数值。
// numBits: 要从 value 中写入的位数 (从最高位开始)。
func (bw *BitWriter) WriteBits(value uint64, numBits uint8) error {
    if numBits > 64 {
        return fmt.Errorf("cannot write more than 64 bits at once")
    }

    // 从 value 的最高位开始迭代，逐位写入
    for i := int(numBits) - 1; i >= 0; i-- {
        // 提取当前位：将 value 右移 i 位，然后与 1 进行按位与操作
        bit := (value >> i) & 1
        if err := bw.WriteBit(bit == 1); err != nil {
            return err
        }
    }
    return nil
}

// Flush 将缓冲区中剩余的位（如果存在）写入底层 writer。
// 剩余位会用0填充到最近的字节边界。
// 此外，它还会刷新底层的 bufio.Writer。
func (bw *BitWriter) Flush() error {
    if bw.count > 0 {
        // 写入剩余的字节，不足8位的会用0填充
        _, err := bw.writer.Write([]byte{bw.buffer})
        if err != nil {
            return fmt.Errorf("failed to flush remaining byte: %w", err)
        }
        // 重置缓冲区
        bw.buffer = 0
        bw.count = 0
    }
    // 刷新 bufio.Writer，确保所有缓冲数据写入底层 io.Writer
    return bw.writer.Flush()
}

// Close 关闭 BitWriter，并刷新所有挂起的位和缓冲区。
// 如果底层 writer 实现了 io.Closer 接口，也会尝试关闭它。
func (bw *BitWriter) Close() error {
    // 首先刷新所有未写入的位
    if err := bw.Flush(); err != nil {
        return err
    }
    // 如果底层的 writer 实现了 io.Closer 接口，则尝试关闭它
    if closer, ok := bw.writer.Writer.(io.Closer); ok {
        return closer.Close()
    }
    return nil
}

func main() {
    // 创建一个文件用于写入位数据
    file, err := os.Create("output.bin")
    if err != nil {
        fmt.Println("Error creating file:", err)
        return
    }
    // 使用 defer 确保文件在函数结束时关闭
    defer file.Close() 

    // 创建 BitWriter 实例，并使用 defer 确保所有位被刷新并关闭
    bitWriter := NewBitWriter(file)
    defer bitWriter.Close() 

    fmt.Println("Writing bits to output.bin...")

    // 示例1: 写入 0101 (4位)
    // 缓冲区: 0101xxxx (x表示未填充)
    if err := bitWriter.WriteBits(0b0101, 4); err != nil {
        fmt.Println("Error writing bits:", err)
        return
    }
    // 示例2: 写入 110 (3位)
    // 缓冲区: 0101110x
    if err := bitWriter.WriteBits(0b110, 3); err != nil {
        fmt.Println("Error writing bits:", err)
        return
    }
    // 示例3: 写入 1 (1位)
    // 缓冲区: 01011101。此时缓冲区已满，写入第一个字节。
    if err := bitWriter.WriteBits(0b1, 1); err != nil {
        fmt.Println("Error writing bits:", err)
        return
    } 

    // 示例4: 写入 00110011 (8位)
    // 缓冲区直接填满并写入第二个字节。
    if err := bitWriter.WriteBits(0b00110011, 8); err != nil {
        fmt.Println("Error writing bits:", err)
        return
    }

    // 示例5: 写入 10101 (5位)
    // 缓冲区: 10101xxx
    if err := bitWriter.WriteBits(0b10101, 5); err != nil {
        fmt.Println("Error writing bits:", err)
        return
    }

    fmt.Println("Bits written successfully. Flushing remaining bits...")

    // 调用 Flush 将缓冲区中剩余的 5 位 (10101) 写入，并用 0 填充。
    // 最终文件内容：
    // Byte 1: 01011101 (来自 0101 + 110 + 1)
    // Byte 2: 00110011 (来自 00110011)
    // Byte 3: 10101000 (来自 10101 + 000 填充)
    if err := bitWriter.Flush(); err != nil {
        fmt.Println("Error flushing:", err)
        return
    }

    fmt.Println("All bits flushed and file closed. Check output.bin.")
}