Question

我有一个我定义的结构实例，我想将它转换为一个字节数组。我试过[] byte（my_struct），但那不起作用。另外，我被指向了binary package，但我不确定应该使用哪种功能以及我应该如何使用它。一个例子将不胜感激。

Answer 1

我假设你想要像C处理这个的方式。没有内置的方法可以做到这一点。您必须为结构定义自己的序列化和反序列化。二进制包将帮助您编码你的struct中的字段可以添加到字节数组中，但是你将负责指定字节数组中的长度和偏移量，它们将保存结构中的字段。

您的其他选择是使用其中一个编码包：http://golang.org/pkg/encoding/，例如gob或json。

修改

由于您希望根据评论中的说法制作哈希，因此最简单的方法是使用[]byte(fmt.Sprintf("%v", struct))，如下所示：http://play.golang.org/p/yY8mSdZ_kf

Answer 2

一种可能的解决方案是"encoding/gob"标准包。 gob包创建了一个编码器/解码器，可以将任何结构编码为字节数组，然后将该数组解码回结构。有一篇很棒的帖子，here。

正如其他人所指出的那样，有必要使用这样的包，因为结构本质上具有未知的大小，不能转换为字节数组。

我添加了一些代码和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)
}

Answer 3

你应该使用字节缓冲区而不是字符串，其他建议的方法创建一个可变长度的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

这是一种非常简单的方法，效果很好。

Answer 4

我知道这个帖子已经老了，但没有一个答案被接受了，而且有一个非常简单的方法可以做到这一点。

https://play.golang.org/p/TedsY455EBD

来自游乐场的重要代码

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

Answer 5

您是否考虑将其序列化为bson？ http://labix.org/gobson

Answer 6

看看https://blog.golang.org/go-slices-usage-and-internals 特别是切片内部。这个想法是模仿slice的内部结构，并指向我们的结构，而不是字节序列：

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]

https://play.golang.org/p/Rh_yrscRDV6

Answer 7

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采用具有固定长度内存分配数据类型的结构。

Answer 8

序列化可能是正确的答案。

但是，如果您同意不安全并且实际上需要将结构读取为字节，那么依赖字节 array 内存表示可能比依赖字节内部的 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)))[:]

工作并提供对struct，零复制的读写视图。两个“不安全”应该足以暗示它可能会严重破裂。

Answer 9

只需使用json marshal，这是一种非常简单的方法。

newFsConfig := dao.ConfigEntity{EnterpriseId:"testing"}
newFsConfigBytes, _ := json.Marshal(newFsConfig)

Answer 10

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://play.golang.org/p/mnB9Cxy-2H3

在Go中，如何将结构转换为字节数组？

10 个答案: