Aller au contenu
4all.tools

Générez des types Go à partir d’exemples JSON complets

Inférez localement structs et maps raw Go, conservez les lexèmes numériques avec json.Number et comprenez les pointeurs facultatifs.

Espace de travail de l’outil

JSON vers Go

Déclarations Go 1.22+ ; encoding/json et bibliothèque standard uniquement.

Tous les nombres utilisent json.Number pour préserver leurs lexèmes. Les pointeurs facultatifs acceptent null même sans exemple null et ramènent absence/null à nil ; omitempty peut omettre null explicite. Raw conserve le jeton null. Les structs ne valident pas les champs requis ni null scalaire. Les clés hors du sous-ensemble de tags élargissent tout l’objet en map raw.

Activez JavaScript pour générer le code. Vous pouvez lire et modifier le JSON.

Tous les éléments et documents contribuent au même contrat. Un tableau racine reste un tableau. Un champ absent diffère de null.

Jusqu’à 20 documents, 1 000 000 d’unités UTF-16 en entrée et 2 000 000 en sortie ; d’autres budgets de ressources s’appliquent.

Votre JSON est traité localement dans un Worker du navigateur. Il n’est ni envoyé ni enregistré.

Utilisez 1 à 64 lettres et chiffres ASCII, en commençant par une lettre. Les noms réservés sont rejetés.

Prêt à recevoir du JSON.

    Exemples complets et tableaux racines

    Collez du JSON strict ou choisissez un fichier UTF-8 local. Générez à partir d’un document ou de vingt exemples complets au maximum. Tous les éléments et champs tardifs contribuent ; un tableau racine reste un tableau. Les entrées vides, clés décodées en double, commentaires, virgules finales et documents concaténés arrêtent la génération en conservant vos exemples.

    L’éditeur indique l’exemple actif et le total. Après la génération, consultez le nom du fichier, l’expression du type racine, le nombre de nœuds JSON et la taille du code complet. Ces informations décrivent le résultat actuel ; la copie et le téléchargement incluent tout le fichier même lorsque l’aperçu est limité.

    [{"id":1},{"id":2,"nombre":"Ana"}]
    package generated

import "encoding/json"

type RootItem struct {
  Id json.Number `json:"id"`
  Nombre *string `json:"nombre,omitempty"`
}

type Root []RootItem

    Tags exacts, maps et présence par pointeurs

    Les clés non vides correspondant à [A-Za-z0-9_ .:/-]+ reçoivent des champs exportés avec des tags json exacts. La clé littérale - utilise json:"-," ou json:"-,omitempty". Les collisions changent uniquement les identifiants Go. Toute autre clé, notamment guillemet, virgule, backslash, backtick, contrôles ou Unicode, élargit l’objet entier en map[string]json.RawMessage nommée, conservant toutes les clés Unicode valides. Les substituts isolés dans les clés arrêtent la génération. Les objets vides utilisent également des maps raw.

    L’absence utilise *T et omitempty, sauf pour raw. T avec null observé utilise un seul pointeur. False, zéro et chaîne vide présents conservent des pointeurs non nil. Les pointeurs facultatifs acceptent null même sans cet exemple ; absence et null deviennent nil, et une sérialisation ultérieure peut omettre null explicite. Raw distingue absence nil du jeton null reçu. Go ne valide pas les champs requis et ne rejette pas null scalaire à la désérialisation. Les avertissements expliquent ces capacités ; les types ne constituent pas une validation à l’exécution ni une garantie globale de round-trip.

    Nombres et export local complet

    Chaque nombre utilise json.Number, notamment 9007199254740993, 1.0, 1e3 et -0. String() conserve le lexème sans conversion en float64. Les avertissements de précision du parser restent visibles sans signifier une perte par json.Number. Unknown, null seul et les unions de plusieurs branches non null utilisent json.RawMessage avec avertissements. Les racines number/raw utilisent des alias conservant unmarshalling ; objet/null utilise un alias de pointeur. Seules les déclarations accessibles et les imports nécessaires sont émis dans package generated, sans désérialiseur personnalisé.

    Limites : 20 exemples, 1 000 000 unités UTF-16 d’entrée, 4 000 000 octets UTF-8 au total et par fichier, profondeur 200, 100 000 nœuds/visites d’inférence, 1 000 000 unités de parsing, 10 000 types, 20 000 champs, 2 000 000 unités de fusion, 2 000 déclarations, 4 000 000 unités d’émission et 15 secondes. Sortie : 2 000 000 unités UTF-16 et 8 000 000 octets. Ces maxima ne sont pas nécessairement atteignables ensemble ; dépasser une limite ne produit aucun code partiel.

    L’aperçu contient au maximum 20 000 unités UTF-16 ; copier et télécharger incluent tout types.go courant en text/plain;charset=utf-8, UTF-8 sans BOM et LF final. Au maximum 100 diagnostics et 50 lignes de noms totalisant 10 000 unités sont affichés avec le nombre omis. Le refus du presse-papiers propose une copie manuelle explicite du code complet. Un BOM initial est retiré uniquement au parsing ; les positions utilisent le texte original. Annuler termine le Worker ; édition, mode, ordre et options invalident la sortie. Le traitement reste dans un Worker local, hors ligne après chargement des assets, sans envoi, stockage ni données dans les liens associés. JavaScript et Worker sont nécessaires ; le Go généré n’est jamais compilé ou exécuté dans le navigateur.