golang byte to struct

Converting byte array to struct in Golang is a common problem, and many developers will encounter this problem. Golang's byte array is very convenient for processing binary data, but for complex data structures, such as struct, manual processing is required. Such code is lengthy and error-prone. This article will introduce how to convert byte array to struct through Golang.

1. Through unsafe conversion

We can use Pointer in the unsafe package to convert between byte arrays and structs. The sample code is as follows:

package main

import (
    "fmt"
    "reflect"
    "unsafe"
)

type Person struct {
    Name string
    Age  int
}

func main() {
    p := Person{Name: "Tom", Age: 18}

    size := int(unsafe.Sizeof(p))
    fmt.Printf("struct size: %d
", size)

    b := make([]byte, size)
    pptr := unsafe.Pointer(&p)

    for i := 0; i < size; i++ {
        b[i] = *(*byte)(unsafe.Pointer(uintptr(pptr) + uintptr(i)))
    }

    fmt.Printf("byte array: %v
", b)

    q := (*Person)(unsafe.Pointer(&b[0]))
    fmt.Printf("person: %v
", q)
}

In the above code, we created a Person structure, converted it into a byte array, and reconverted it back to the Person structure through a pointer. We use Pointer and uintptr from the unsafe package to convert between pointers and integers.

After running this code, the output result is as follows:

struct size: 16
byte array: [84 111 109 0 0 0 0 0 0 0 0 0 18 0 0 0]
person: &{Tom 18}

Although this method can achieve conversion, it has certain security risks and needs to be used with caution.

2. Conversion through reflect

The Reflect package is a very powerful package in Golang. You can use it to perform type inference on variables and call functions. When converting between byte array and struct, we can use Value and Type from the reflect package. The sample code is as follows:

package main

import (
    "fmt"
    "reflect"
)

type Person struct {
    Name string
    Age  int
}

func main() {
    p := Person{Name: "Tom", Age: 18}

    size := int(reflect.TypeOf(p).Size())
    fmt.Printf("struct size: %d
", size)

    b := make([]byte, size)
    reflect.ValueOf(&p).Elem().Interface()
    for i := 0; i < size; i++ {
        b[i] = *(*byte)(unsafe.Pointer(uintptr(reflect.ValueOf(&p).Elem().UnsafeAddr()) + uintptr(i)))
    }

    fmt.Printf("byte array: %v
", b)

    var q Person
    s := reflect.ValueOf(&q).Elem()
    for i := 0; i < size; i++ {
        s.Field(i).SetInt(int64(b[i]))
    }

    fmt.Printf("person: %v
", q)
}

We use Type and Value in the reflect package to get the size and value of the structure, and get the structure in memory through reflect.ValueOf(&p).Elem().UnsafeAddr() pointer, then use uintptr and unsafe.Pointer for type conversion, and finally traverse the byte array for assignment, then the byte array can be converted into a struct.

After running this code, the output result is as follows:

struct size: 16
byte array: [84 111 109 0 0 0 0 0 0 0 0 0 18 0 0 0]
person: {Tom 84}

Due to the difference in storage order between byte array and struct, we need to manually handle the order of byte array to correctly convert to struct.

Summary

There are two ways to convert byte arrays and structs in Golang: one is to convert between pointers, integers, and byte arrays through the unsafe package; Conversion between types, values, and addresses is performed through the reflect package. Both methods have their own advantages and disadvantages, and you need to choose according to the specific situation when using them. At the same time, when converting byte arrays and structs, you need to pay attention to details such as the order of the byte arrays and the field types in the struct.

The above is the detailed content of golang byte to struct. For more information, please follow other related articles on the PHP Chinese website!