Go语言文件头读取与字节解析实践

package main

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

// RoflFile 结构体用于存储文件标识符
type RoflFile struct {
    Identifier []byte
}

func main() {
    // 检查命令行参数
    if len(os.Args) != 2 {
        fmt.Println("Usage: <path-to-file>")
        return
    }

    inputPath := os.Args[1]

    // 检查文件是否存在
    if _, err := os.Stat(inputPath); os.IsNotExist(err) {
        fmt.Printf("Error: The input file could not be found: %s\n", inputPath)
        return
    }

    // 初始化RoflFile结构体并分配4字节的切片用于存储标识符
    rofl := new(RoflFile)
    rofl.Identifier = make([]byte, 4)

    // 打开文件
    f, err := os.Open(inputPath)
    if err != nil {
        fmt.Printf("Error opening file: %v\n", err)
        return
    }
    // 确保文件在函数结束时关闭
    defer func() {
        if closeErr := f.Close(); closeErr != nil {
            fmt.Printf("Error closing file: %v\n", closeErr)
        }
    }()

    // 从文件读取至少4个字节到rofl.Identifier
    // 如果文件大小不足4字节，io.ReadAtLeast会返回io.ErrUnexpectedEOF
    n, err := io.ReadAtLeast(f, rofl.Identifier, 4)
    if err != nil && err != io.EOF { // io.EOF在文件大小不足时可能出现，但ReadAtLeast会返回ErrUnexpectedEOF
        fmt.Printf("Error reading file identifier: %v\n", err)
        return
    }
    if n < 4 {
        fmt.Printf("Warning: File is too small, only read %d bytes.\n", n)
        // 如果需要严格的4字节，可以在这里返回错误
        // return
    }

    // 打印读取到的字节信息
    fmt.Printf("Got: %+v\n", rofl)
}

// ... (接上面的文件读取代码)

// 假设rofl.Identifier已经包含了读取到的字节
identifierBytes := rofl.Identifier

// 将字节切片转换为字符串（按UTF-8或ASCII解释）
identifierString := string(identifierBytes)
fmt.Printf("Identifier as string: %s\n", identifierString)

// ... (接上面的文件读取代码)

// 假设rofl.Identifier已经包含了读取到的字节
identifierBytes := rofl.Identifier

// 以十六进制形式打印字节切片
fmt.Printf("Identifier as hex: %x\n", identifierBytes)
// 如果需要每个字节之间有空格分隔，可以使用fmt.Sprintf结合循环
fmt.Printf("Identifier as hex (spaced): ")
for _, b := range identifierBytes {
    fmt.Printf("%02x ", b) // %02x 确保每个字节都以两位十六进制数表示，不足补零
}
fmt.Println()

package main

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

func main() {
    if len(os.Args) != 2 {
        fmt.Println("Usage: <path-to-file>")
        return
    }

    inputPath := os.Args[1]

    if _, err := os.Stat(inputPath); os.IsNotExist(err) {
        fmt.Printf("Error: The input file could not be found: %s\n", inputPath)
        return
    }

    // 创建一个4字节的缓冲区
    buffer := make([]byte, 4)

    f, err := os.Open(inputPath)
    if err != nil {
        fmt.Printf("Error opening file: %v\n", err)
        return
    }
    defer func() {
        if closeErr := f.Close(); closeErr != nil {
            fmt.Printf("Error closing file: %v\n", closeErr)
        }
    }()

    n, err := io.ReadAtLeast(f, buffer, 4)
    if err != nil && err != io.EOF {
        fmt.Printf("Error reading file: %v\n", err)
        return
    }
    if n < 4 {
        fmt.Printf("Warning: File is too small, only read %d bytes.\n", n)
        // 如果文件不足4字节，可能需要根据业务逻辑决定是否继续
        // 例如，可以将buffer填充0或直接返回错误
        // For this example, we'll proceed with fewer bytes if n < 4
    }

    // 打印原始十进制字节值
    fmt.Printf("Raw bytes (decimal): %v\n", buffer[:n])

    // 尝试将字节转换为字符串（假定为UTF-8或ASCII）
    fmt.Printf("Bytes as string: %s\n", string(buffer[:n]))

    // 打印十六进制表示
    fmt.Printf("Bytes as hex: %x\n", buffer[:n])

    // 打印带空格的十六进制表示
    fmt.Printf("Bytes as spaced hex: ")
    for i := 0; i < n; i++ {
        fmt.Printf("%02x ", buffer[i])
    }
    fmt.Println()

    // 示例：检查文件头是否匹配特定值（例如，一个虚构的"ROFL"文件头）
    expectedHeader := []byte{0x52, 0x4F, 0x46, 0x4C} // ASCII for "ROFL"
    if n == 4 && string(buffer) == string(expectedHeader) {
        fmt.Println("File header matches 'ROFL'!")
    } else if n == 4 {
        fmt.Printf("File header does not match 'ROFL'. Found: %x\n", buffer)
    } else {
        fmt.Println("Could not verify header due to insufficient bytes.")
    }
}