我正在尝试找出在 Go 中读取由 Python 生成的打包二进制文件的最佳方法，如下所示:

import struct
f = open('tst.bin', 'wb')
fmt = 'iih' #please note this is packed binary: 4byte int, 4byte int, 2byte int
f.write(struct.pack(fmt,4, 185765, 1020))
f.write(struct.pack(fmt,4, 185765, 1022))
f.close()

我一直在修改我在 Github.com 和其他一些来源上看到的一些示例但我似乎无法让任何东西正常工作(更新显示了工作方法)。 在 Go 中做这种事情的惯用方法是什么？这是几种尝试之一

更新和工作

package main

    import (
            "fmt"
            "os"
            "encoding/binary"
            "io"
            )

    func main() {
            fp, err := os.Open("tst.bin")

            if err != nil {
                    panic(err)
            }

            defer fp.Close()

            lineBuf := make([]byte, 10) //4 byte int, 4 byte int, 2 byte int per line

            for true {
                _, err := fp.Read(lineBuf)

                if err == io.EOF{
                    break
                }

                aVal := int32(binary.LittleEndian.Uint32(lineBuf[0:4])) // same as: int32(uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24)
                bVal := int32(binary.LittleEndian.Uint32(lineBuf[4:8]))
                cVal := int16(binary.LittleEndian.Uint16(lineBuf[8:10])) //same as: int16(uint32(b[0]) | uint32(b[1])<<8)
                fmt.Println(aVal, bVal, cVal)
            }
    }

最佳答案

处理问题的一种便携且相当简单的方法是 Google's "Protocol Buffers" .虽然现在已经太晚了，因为你让它工作了，但我花了一些努力来解释和编码它，所以我还是发布了它。

您可以在 https://github.com/mwmahlberg/ProtoBufDemo 上找到代码

您需要使用首选方法(pip、操作系统包管理、源代码)为 python 和 Go 安装 Protocol Buffer 。

.proto 文件

.proto 文件对于我们的示例来说相当简单。我称它为 data.proto

syntax = "proto2";
package main;

message Demo {
  required uint32  A = 1;
  required uint32 B = 2;

  // A shortcomning: no 16 bit ints
  // We need to make this sure in the applications
  required uint32 C = 3;
}

现在您需要在文件上调用 protoc 并让它为 Python 和 Go 提供代码:

protoc --go_out=. --python_out=. data.proto

生成文件 data_pb2.py 和 data.pb.go。这些文件提供了对 Protocol Buffer 数据的特定语言访问。

使用github上的代码时，只需要发布

go generate

在源目录中。

Python代码

import data_pb2

def main():

    # We create an instance of the message type "Demo"...
    data = data_pb2.Demo()

    # ...and fill it with data
    data.A = long(5)
    data.B = long(5)
    data.C = long(2015)


    print "* Python writing to file"
    f = open('tst.bin', 'wb')

    # Note that "data.SerializeToString()" counterintuitively
    # writes binary data
    f.write(data.SerializeToString())
    f.close()

    f = open('tst.bin', 'rb')
    read = data_pb2.Demo()
    read.ParseFromString(f.read())
    f.close()

    print "* Python reading from file"
    print "\tDemo.A: %d, Demo.B: %d, Demo.C: %d" %(read.A, read.B, read.C)

if __name__ == '__main__':
    main()

我们导入protoc生成的文件并使用它。这里没有太多魔法。

Go 文件

package main

//go:generate protoc --python_out=. data.proto
//go:generate protoc --go_out=. data.proto
import (
    "fmt"
    "os"

    "github.com/golang/protobuf/proto"
)

func main() {

    // Note that we do not handle any errors for the sake of brevity
    d := Demo{}
    f, _ := os.Open("tst.bin")
    fi, _ := f.Stat()

    // We create a buffer which is big enough to hold the entire message
    b := make([]byte,fi.Size())

    f.Read(b)

    proto.Unmarshal(b, &d)
    fmt.Println("* Go reading from file")

    // Note the explicit pointer dereference, as the fields are pointers to a pointers
    fmt.Printf("\tDemo.A: %d, Demo.B: %d, Demo.C: %d\n",*d.A,*d.B,*d.C)
}

请注意，我们不需要显式导入，因为 data.proto 的包是 main。

结果

生成所需文件并编译源码后，当你发出

$ python writer.py && ./ProtoBufDemo

结果是

* Python writing to file
* Python reading from file
    Demo.A: 5, Demo.B: 5, Demo.C: 2015
* Go reading from file
    Demo.A: 5, Demo.B: 5, Demo.C: 2015

请注意，存储库中的 Makefile 提供了生成代码、编译 .go 文件并运行这两个程序的快捷方式:

make run

关于go - 如何在 Go 中读取打包的二进制数据？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/34078427/