How we can know what kind of struct is on byte array

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"
    }
}

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.