Comment désorganiser un tableau Go avec des types de données disparates ?

Désorganisation d'un tableau de types disparates dans Go

Lors de la gestion des paires clé-valeur, la désorganisation est simple. Cependant, regrouper un ensemble de types mixtes dans un ordre distinct présente un défi. La résolution de ce problème nécessite une solution capable de prendre en charge différents types de données de manière flexible.

Le langage de programmation Go offre une option élégante pour gérer ce scénario. En exploitant le type interface{} en conjonction avec l'assertion de type, nous pouvons analyser dynamiquement le type sous-jacent de chaque élément du tableau et le désassembler en conséquence.

Revoyons le code problématique et modifions-le pour exploiter cette technique :

package main

import (
    "encoding/json"
    "fmt"
)

func decodeJSON(f interface{}) {
    switch vf := f.(type) {
    case map[string]interface{}:
        fmt.Println("is a map:")
        for k, v := range vf {
            checkTypeAndDecode(k, v)
        }
    case []interface{}:
        fmt.Println("is an array:")
        for k, v := range vf {
            checkTypeAndDecode(k, v)
        }
    }
}

func checkTypeAndDecode(k string, v interface{}) {
    switch vv := v.(type) {
    case string:
        fmt.Printf("%v: is string - %q\n", k, vv)
    case int:
        fmt.Printf("%v: is int - %q\n", k, vv)
    default:
        fmt.Printf("%v: ", k)
        decodeJSON(v)
    }
}

func main() {
    my_json := `{
    "an_array":[
    "with_a string",
    {
        "and":"some_more",
        "different":["nested", "types"]
    }
    ]
}`

    var f interface{}
    err := json.Unmarshal([]byte(my_json), &f)
    if err != nil {
        fmt.Println(err)
    } else {
        fmt.Println("JSON:")
        decodeJSON(f)
    }
}

Ce code modifié utilise la fonction decodeJSON pour analyser récursivement la structure JSON, identifiant le type de données de chaque élément et imprimant la représentation appropriée. Pour les structures imbriquées complexes, des appels imbriqués à decodeJSON sont effectués.

La sortie générée par ce code révisé illustre comment chaque élément est correctement identifié et imprimé en fonction de son type de données :

JSON:
is a map:
an_array: is an array:
0: is string - "with_a string"
1: is a map:
and: is string - "some_more"
different: is an array:
0: is string - "nested"
1: is string - "types"

Avec Grâce à cette compréhension améliorée de la gestion des types dans Go, vous pouvez en toute confiance désassembler des tableaux contenant un mélange hétérogène de types de données, garantissant ainsi une représentation précise et cohérente des données dans vos applications.

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!