Comment utiliser la réflexion pour la sérialisation et la désérialisation dans Golang

Utilisez la réflexion Go pour la sérialisation et la désérialisation : Sérialisation : utilisez la fonction encoding/json.Marshal pour sérialiser la structure dans un flux d'octets. Désérialisation : utilisez la fonction encoding/json.Unmarshal pour désérialiser une structure à partir d'un flux d'octets.

Comment sérialiser et désérialiser à l'aide de Go Reflection

Reflection est une fonctionnalité puissante de Go qui vous permet d'inspecter et de modifier un programme en cours d'exécution. Il peut être utilisé à diverses fins, notamment la sérialisation et la désérialisation, et vous permet d'enregistrer des structures de données sous forme de flux d'octets, puis de les recréer ultérieurement.

Sérialisation

Pour sérialiser des structures à l'aide de la réflexion, utilisez la fonction Marshal du package encoding/json. Cette fonction nécessite un pointeur vers une structure comme premier argument et renvoie une tranche d'octets sérialisée. encoding/json 包中的 Marshal 函数。该函数需要指向结构的指针作为其第一个参数，并返回序列化后的字节切片。

package main

import (
    "encoding/json"
    "fmt"

    "io/ioutil"

    "os"
)

type person struct {
    FirstName string
    LastName  string
    Age       int
}

func main() {
    p := person{FirstName: "John", LastName: "Doe", Age: 30}

    b, err := json.Marshal(&p)
    if err != nil {
        panic(err)
    }
    // 保存序列化后的数据到文件
    err = ioutil.WriteFile("person.json", b, 0644)
    if err != nil {
        panic(err)
    }
}

反序列化

要反序列化已序列化的数据，请使用 encoding/json 包中的 Unmarshal

func main() {
    var p person

    b, err := ioutil.ReadFile("person.json")
    if err != nil {
        panic(err)
    }
    // 反序列化数据到结构
    err = json.Unmarshal(b, &p)
    if err != nil {
        panic(err)
    }
    // 打印反序列化的数据
    fmt.Printf("%+v\n", p)
}

Désérialisation

Pour désérialiser les données sérialisées, utilisez la fonction Unmarshal du package encoding/json. La fonction nécessite un pointeur vers une structure comme premier argument et une tranche d'octets contenant les données sérialisées comme deuxième argument.

type user struct {
    ID   int
    Name string
}

var users = []user{
    {1, "john"},
    {2, "jane"},
}

var b []byte

func main() {
    // 序列化用户数组
    b, _ = json.Marshal(users)
    // 将序列化后的数据保存到文件中
    ioutil.WriteFile("users.json", b, 0644)
    // 反序列化文件中的数据
    var loadedUsers []user
    json.Unmarshal(b, &loadedUsers)
    // 打印反序列化的用户
    fmt.Println(loadedUsers)
}

Cas pratique🎜🎜Ce qui suit est un exemple pratique de sérialisation et de désérialisation utilisant la réflexion : 🎜rrreee

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!