我有一个我定义的结构实例，我想将其转换为字节数组。我尝试了 []byte(my_struct)，但这不起作用。另外，我被指出了二进制包，但我不确定我应该使用哪个函数以及如何使用它。一个例子将不胜感激。
一种可能的解决方案是
"encoding/gob"正如其他人指出的那样，有必要使用这样的包，因为结构本质上具有未知的大小，并且无法转换为字节数组。
我已经包含了一些代码和一个play。
package main
import (
"bytes"
"encoding/gob"
"fmt"
"log"
)
type P struct {
X, Y, Z int
Name string
}
type Q struct {
X, Y *int32
Name string
}
func main() {
// Initialize the encoder and decoder. Normally enc and dec would be
// bound to network connections and the encoder and decoder would
// run in different processes.
var network bytes.Buffer // Stand-in for a network connection
enc := gob.NewEncoder(&network) // Will write to network.
dec := gob.NewDecoder(&network) // Will read from network.
// Encode (send) the value.
err := enc.Encode(P{3, 4, 5, "Pythagoras"})
if err != nil {
log.Fatal("encode error:", err)
}
// HERE ARE YOUR BYTES!!!!
fmt.Println(network.Bytes())
// Decode (receive) the value.
var q Q
err = dec.Decode(&q)
if err != nil {
log.Fatal("decode error:", err)
}
fmt.Printf("%q: {%d,%d}\n", q.Name, *q.X, *q.Y)
}
我假设你想要类似 C 处理这个问题的方式。没有内置的方法可以做到这一点。您必须为结构的字节定义自己的序列化和反序列化。二进制包将帮助您编码 将结构中的字段转换为可以添加到字节数组中的字节，但您将负责指定字节数组中的长度和偏移量，以保存结构中的字段。
您的其他选择是使用其中一种编码包：http://golang.org/pkg/encoding/，例如 gob 或 json。
编辑：
既然你想像你在评论中所说的那样进行哈希，最简单的事情就是使用
[]byte(fmt.Sprintf("%v", struct))使用json marshal即可，这是一个非常简单的方法。
newFsConfig := dao.ConfigEntity{EnterpriseId:"testing"}
newFsConfigBytes, _ := json.Marshal(newFsConfig)
我知道这个帖子很旧，但是没有一个答案被接受，并且有一个非常简单的方法可以做到这一点。
https://play.golang.org/p/TedsY455EBD
来自 Playground 的重要代码
import (
"bytes"
"fmt"
"encoding/json"
)
type MyStruct struct {
Name string `json:"name"`
}
testStruct := MyStruct{"hello world"}
reqBodyBytes := new(bytes.Buffer)
json.NewEncoder(reqBodyBytes).Encode(testStruct)
reqBodyBytes.Bytes() // this is the []byte
序列化可能是正确的答案。
但是，如果您同意不安全并且实际上需要将 struct 作为字节读取，那么依赖 byte array 内存表示可能比依赖 byte slice 内部结构好一点。
type Struct struct {
Src int32
Dst int32
SrcPort uint16
DstPort uint16
}
const sz = int(unsafe.Sizeof(Struct{}))
var asByteSlice []byte = (*(*[sz]byte)(unsafe.Pointer(&struct_value)))[:]
工作并提供结构的读写视图，零拷贝。两个“不安全”就足以暗示它可能会严重损坏。
您应该使用字节缓冲区而不是字符串，其他建议的方法创建可变长度的 SHA1，SHA1 标准长度必须是 20 字节（160 位）
package main
import (
"crypto/sha1"
"fmt"
"encoding/binary"
"bytes"
)
type myStruct struct {
ID string
Data string
}
func main() {
var bin_buf bytes.Buffer
x := myStruct{"1", "Hello"}
binary.Write(&bin_buf, binary.BigEndian, x)
fmt.Printf("% x", sha1.Sum(bin_buf.Bytes()))
}
自己尝试一下：http://play.golang.org/p/8YuM6VIlLV
这是一个非常简单的方法，而且效果很好。
package main
import (
"crypto/sha1"
"fmt"
"encoding/binary"
"bytes"
)
type myStruct struct {
ID [10]byte
Data [10]byte
}
func main() {
var bin_buf bytes.Buffer
x := myStruct{"1", "Hello"}
binary.Write(&bin_buf, binary.BigEndian, x)
fmt.Printf("% x", sha1.Sum(bin_buf.Bytes()))
}
binary.Write 采用具有固定长度内存分配数据类型的结构。
json.Marshal 是将结构转换为 []byte 的最佳选择，请参见下面的示例：
package main
import (
"encoding/json"
"fmt"
)
type ExampleConvertToByteArray struct {
Name string
SurName string
}
func main() {
example := ExampleConvertToByteArray{
Name: "James",
SurName: "Camara",
}
var exampleBytes []byte
var err error
exampleBytes, err := json.Marshal(example)
if err != nil {
print(err)
return
}
fmt.Println(string(exampleBytes))
}
看看 https://blog.golang.org/go-slices-usage-and-internals 特别是切片内部。这个想法是模仿切片的内部结构并指向我们的结构而不是字节序列：
package main
import (
"fmt"
"unsafe"
)
// our structure
type A struct {
Src int32
Dst int32
SrcPort uint16
DstPort uint16
}
// that is how we mimic a slice
type ByteSliceA struct {
Addr *A
Len int
Cap int
}
func main() {
// structure with some data
a := A{0x04030201,0x08070605,0x0A09, 0x0C0B}
// create a slice structure
sb := &ByteSliceA{&a, 12, 12} // struct is 12 bytes long, e.g. unsafe.Sizeof(a) is 12
// take a pointer of our slice mimicking struct and cast *[]byte on it:
var byteSlice []byte = *(*[]byte)(unsafe.Pointer(sb))
fmt.Printf("%v\n", byteSlice)
}
输出：
[1 2 3 4 5 6 7 8 9 10 11 12]
您是否考虑过将其序列化为 bson？ http://labix.org/gobson
var v any
b := (*[unsafe.Sizeof(v)]byte)(unsafe.Pointer(&v))
c := b[:]