我们如何知道字节数组上有什么样的结构

Question

I'm looking for some solution to know whats the struct type of the hash. It is possible to do that without try an error method (casting to a specific type and see the cast is successfully)?

Please check the code:

import (
    "bytes"
    "encoding/binary"
    "fmt"
    "reflect"
)

type T struct {
    A int64
    B float64
}

type D struct {
    A int64
    B float64
    C string
}


func main() {
    // Create a struct and write it.
    t := T{A: 0xEEFFEEFF, B: 3.14}
    buf := &bytes.Buffer{}
    err := binary.Write(buf, binary.BigEndian, t)
    if err != nil {
        panic(err)
    }
    fmt.Println(buf.Bytes())

    out := getType(buf)
    fmt.Println(out)
}

func getType(v interface{})(r string){
    fmt.Println(reflect.TypeOf(v))
    switch t := v.(type) {
        case T:
            return "Is type T"
        case D:
            return "Is type D"
        default:
            _ = t
            return "unknown"
    }
}

Answer 1

Since the encoding/binary package does not write out type information, it is not possible to tell what type was written / serialized.

And you're in a worse position that you might originally think: even trying to decode into a value of different type might succeed without errors, so there isn't even a reliable way to tell the type.

For example if you serialize a value of this type:

type T struct {
    A int64
    B float64
}

You can read it into a value of this type:

type T2 struct {
    B float64
    A int64
}

It will give no errors because the size of both structs is the same, but obviously you will get different numbers in the fields.

You are in a little better position if you use encoding/gob, as the gob package does transmit type information, and encoding a value of type T and then decoding it into a value of type T2 would work: order of fields does not matter, and extra or missing fields also do not cause trouble.

See this example:

// Create a struct and write it.
t := T{A: 0xEEFFEEFF, B: 3.14}
fmt.Println("Encoding:", t)
buf := &bytes.Buffer{}
fmt.Println(binary.Write(buf, binary.BigEndian, t))
fmt.Println(buf.Bytes())

fmt.Println(gob.NewEncoder(buf).Encode(t))

t2 := T2{}
fmt.Println(binary.Read(buf, binary.BigEndian, &t2))
fmt.Println(t2)

t2 = T2{}
fmt.Println(gob.NewDecoder(buf).Decode(&t2))
fmt.Println(t2)

Output (try it on the Go Playground):

Encoding: {4009750271 3.14}
<nil>
[0 0 0 0 238 255 238 255 64 9 30 184 81 235 133 31]
<nil>
<nil>
{1.9810798573e-314 4614253070214989087}
<nil>
{3.14 4009750271}

If you want to be able to detect the type before reading it, you have to take care of it yourself: you have to transmit type information (e.g. name of the type). Or even better, use a serialization method that already does this, for example Google's protocol buffers, and here is the Go implementation for it: github.com/golang/protobuf.