Aller au contenu
🛠️ToolsShed

JSON vers Go Struct

Convertit des données JSON en types de struct Go avec des balises de champ.

À propos de cet outil

JSON to Go Struct est un utilitaire pour développeurs qui convertit automatiquement des données JSON en définitions de structures Go fortement typées. Cet outil est essentiel pour les programmeurs Go qui travaillent avec des API JSON, des fichiers de configuration ou des formats d'échange de données, éliminant le processus manuel fastidieux de définition des champs de structure et de leurs balises JSON correspondantes.

Il suffit de coller vos données JSON dans l'outil et il génère instantanément du code de structure Go avec les types de champs, les noms et les balises de structure appropriées (y compris json, omitempty et d'autres balises courantes). Les structures générées préservent la structure JSON d'origine tout en appliquant la sécurité des types de Go, ce qui facilite l'analyse directe des réponses JSON en structures de données typées.

Cet outil s'avère particulièrement précieux lors de l'intégration d'API externes ou de la consommation de données JSON tierces où le schéma est complexe ou profondément imbriqué. Il prend en charge les champs optionnels, les tableaux, les objets imbriqués et les types de données spéciaux, permettant aux développeurs d'économiser un temps considérable lors de l'intégration d'API et de réduire le risque d'erreurs d'exécution causées par des incompatibilités de type.

Questions Fréquentes

Implémentation du Code

import json

def to_pascal_case(s: str) -> str:
    return ''.join(word.capitalize() for word in s.replace('-', '_').split('_'))

def json_to_go_type(value, field_name: str, structs: dict) -> str:
    if value is None:
        return "interface{}"
    if isinstance(value, bool):
        return "bool"
    if isinstance(value, int):
        return "int64"
    if isinstance(value, float):
        return "float64"
    if isinstance(value, str):
        return "string"
    if isinstance(value, list):
        if not value:
            return "[]interface{}"
        elem_type = json_to_go_type(value[0], field_name, structs)
        return f"[]{elem_type}"
    if isinstance(value, dict):
        struct_name = to_pascal_case(field_name)
        fields = []
        for k, v in value.items():
            field_type = json_to_go_type(v, k, structs)
            go_name = to_pascal_case(k)
            fields.append(f'\t{go_name} {field_type} `json:"{k}"`')
        structs[struct_name] = "type " + struct_name + " struct {\n" + "\n".join(fields) + "\n}"
        return struct_name
    return "interface{}"

def json_to_go(json_str: str, root_name: str = "Root") -> str:
    data = json.loads(json_str)
    structs = {}
    json_to_go_type(data, root_name, structs)
    return "\n\n".join(structs.values())

sample = '{"name": "Alice", "age": 30, "address": {"city": "Tokyo", "zip": "100-0001"}}'
print(json_to_go(sample))

Comments & Feedback

Comments are powered by Giscus. Sign in with GitHub to leave a comment.