Hoe JSON in kaart te brengen om structuren te gebruiken met veldtags

Het grootste deel van mijn dagelijkse werk bestaat uit TypeScript en PHP, maar een groot deel van de tooling erachter Toolz.dev en de kleine diensten die ik er omheen schrijf is Go, en elke keer als ik een nieuwe API-client afsluit, raak ik dezelfde muur Je hebt een JSON-antwoord voor je, en je hebt de Go-structuur nodig die json.Unmarshal zal het decoderen in Die struct met de hand schrijven is vervelend op een heel specifieke manier: het is niet moeilijk, het is gewoon onhandig, en de onhandige stukjes zijn precies waar je fouten maakt Dus ik heb een converter in de site gebouwd, en dit is de gids voor het.

tl;dr: De Toolz JSON naar Go struct-converter parseert een JSON-document en zendt de Go-type declaraties uit die het beschrijven Objecten worden inline structs, arrays van objecten worden samengevoegd tot één struct en elk veld krijgt een json:"key" tag zo encoding/json wijst de gegevens correct terug Veldnamen volgen Go conventies, dus id HALD ID en user_url HALD UserURL. Integer overschakelen naar int64, toevoegen omitempty, en hernoem het root type Het draait volledig client-side: geen upload, geen aanmelding, werkt offline.

Wat is een JSON to Go struct converter?

Een JSON to Go struct-converter verandert een JSON-document in de Go-typedeclaraties die het beschrijven, zodat u dezelfde gegevens kunt decoderen met de standaardbibliotheek's encoding/json pakket in plaats van de struct met de hand te typen Elk JSON-object wordt een Go-structuur, elk veld draagt een json:"key" tag die het weer toewijst aan de oorspronkelijke naam, en de scalaire types worden afgeleid uit de waarden Een JSON string wordt string, een heel getal wordt int, een getal met een decimaal wordt float64, true en false worden bool, en null HALD interface{}.

De reden dat dit handig is, is dat een JSON-object en een Go-struct dezelfde vorm beschrijven, een set benoemde velden met getypte waarden, maar Go is statisch getypeerd en JSON niet, dus de struct moet elk type vooraf spellen Die typen afleiden uit een voorbeeldreactie is pure mechanica, en mechanica die met de hand wordt uitgevoerd over een geneste payload is waar de bugs leven. De converter doet de afleiding deterministisch en geeft je een typeblok terug dat compileert.

Het is de moeite waard om duidelijk te zijn over de twee helften van het probleem, omdat dit is wat een naïeve converter mis heeft. De eerste is het benoemen: Go codeert alleen geëxporteerde velden, die met een hoofdletter eerste letter, en de gemeenschapspluisregels willen dat gemeenschappelijke initialismen volledig worden geactiveerd. De tweede is de tag: de json:"..." tag moet de exacte originele sleutel bevatten of json.Unmarshal slaat stil het veld over tijdens runtime zonder fout. Krijg beide verkeerd en uw decode retourneert een struct vol nulwaarden terwijl alles er goed uitziet. Het gereedschap verwerkt beide voor u.

Waarom schrijf je de struct niet met de hand?

Dit is de eerlijke vraag, want voor een plat object met drie velden is het handschrijven sneller dan het openen van een gereedschap De converter verdient zijn plaats op de reacties die niet vlak zijn: een payload met geneste objecten, arrays van objecten en twintig velden waar de helft van de sleutels is snake_case en een paar zijn initialismen zoals id, url, en api_key.

Op zo'n reactie heeft de handgeschreven versie drie faalmodi die ik herhaaldelijk raak Je vergeet een veld te exporteren, dus het blijft kleine letters en encoding/json weigert het te vullen. Je kapitaliseert het veld, maar vergeet de tag, dus UserName zoekt naar een JSON-sleutel genaamd UserName en vindt nooit user_name. Of je krijgt de nesten verkeerd, het declareren van een veld als een gewone structuur wanneer de JSON het daadwerkelijk in een array wikkelt Geen van deze zijn compileerfouten Het zijn runtime verrassingen die verschijnen als ontbrekende gegevens, en je verliest meer tijd met het debuggen van een van hen dan je zou hebben besteed aan het genereren van de hele struct.

De converter verwijdert ze alle drie Het exporteert elk veld, het schrijft de tag van de echte sleutel, en het leest de werkelijke JSON vorm om te beslissen tussen een struct en een plak van structs Wat je plakt in is wat je krijgt types voor.

Hier is de beslissing in één tabel.

betrekking	goed doen	waarom
Een plat voorwerp met twee of drie velden	Hand-schrijf het	Sneller dan iets openen
Een geneste API-reactie met veel velden	JSON naar Go struct-converter	Naamgeving en tags zijn waar handgeschreven structuren breken
U heeft dezelfde vorm nodig als TypeScript	JSON naar TypeScript-converter	Dezelfde gevolgtrekking, andere doeltaal
U wilt een validatieschema, geen typen	JSON Schema generator	Draft-07-regels in plaats van Go-typen

Waarom zijn de Go-veldnamen anders dan mijn JSON-toetsen?

Dit maakt mensen de eerste keer naar boven, dus het is de moeite waard om uit te leggen in plaats van te verbergen. Go's encoding/json alleen maar marshals en unmarshals verpakken geëxporteerd struct-velden, wat betekent velden waarvan de naam begint met een hoofdletter Een JSON-sleutel zoals user_name kan niet toewijzen aan een niet-geëxporteerde user_name veld, dus het veld moet worden hernoemd naar iets dat wordt geëxporteerd. De tool kapitaliseert elk woord en draait user_name per UserName.

Daarbovenop de Go community' s pluisjes tooling, de regels waarmee begonnen is golint en leef voort in tools als staticcheck, wil gemeenschappelijke initialismen geschreven in hoofdletters Dus id HALD ID, niet Id; user_url HALD UserURL, niet UserUrl; En html_body HALD HTMLBody. De converter kent de standaardset initialismen, ID, URL, API, HTTP, JSON, UUID, en de rest, en past ze toe, dus de uitvoer passeert de linters die uw CI waarschijnlijk uitvoert.

Het stuk dat de hernoeming veilig maakt is de tag Elk veld krijgt een json:"user_name" tag die de originele sleutel precies vasthoudt, dus tijdens runtime json.Unmarshal leest de JSON-sleutel user_name en schrijft het in de UserName veld ongeacht de hernoeming Het Go blog' s artikel op JSON en Go documenteert dit tag mechanisme, en het is de reden dat een hernoemd veld nog steeds correct decodeert Zonder de tag zou de hernoemde struct stilletjes niet kunnen bevolken.

Hoe wordt omgegaan met getallen en arrays van objecten?

Twee delen van de gevolgtrekking verdienen een nadere beschouwing, omdat converters daarin in kwaliteit verschillen.

Getallen eerst JSON heeft een enkel getaltype, maar Go niet, dus het gereedschap moet kiezen Een waarde zonder fractioneel deel wordt int, of int64 als u die optie inschakelt en een waarde met een decimaal wordt float64. Het interessante geval is een array die ze combineert, zoals [9.5, 8, 7.2]. Als de tool dat heeft getypt als []int het zou er niet in slagen de 9.5, dus het verbreedt het hele deel tot []float64. Elke array waarbij één element een breder type forceert, krijgt voor alle elementen het bredere type, wat de enige keuze is die elke waarde decodeert.

Arrays van objecten zijn de andere plaats echte payloads worden interessant Een API geeft je bijna nooit een array waar elk object een identieke set sleutels heeft; één element heeft een veld dat de anderen weglaten, of een nullable veld is hier aanwezig en afwezig daar Als het gereedschap een struct genereerde van alleen het eerste element, zou het de sleutels laten vallen die later verschijnen In plaats daarvan voegt het elk object in de array samen tot één struct die elke sleutel bevat die een element heeft En als twee elementen dezelfde sleutel geven incompatibele typen, zeg een getal in de ene en een tekenreeks in een andere, valt dat veld terug naar interface{} in plaats van dat het gereedschap verkeerd raadt of regelrecht faalt. Het resultaat is een enkel struct-type dat de hele array kan decoderen.

Hoe gebruik ik de converter?

De stroom bestaat uit vier stappen Plak een JSON-object of array in het invoervak; als u eerst de vorm van de uitvoer wilt zien, laadt u het monster Geef het stamtype een naam, zoiets als User of ApiResponse, en de tool maakt het schoon in een geldige geëxporteerde Go-identificatie, zodat het compileert zoals geschreven. Kies int of int64 voor hele getallen, en aan omitempty als u velden met nulwaarde wilt weglaten wanneer de struct later wordt teruggecodeerd naar JSON Klik vervolgens op Converteren en kopieer de struct naar uw .go bestand.

Als de JSON ongeldig is, rapporteert de tool de parser' een eigen foutmelding in plaats van stil te falen, dus een verdwaalde achterliggende komma of een niet-geciteerde sleutel is snel te vinden En omdat alles in uw browser draait, kunt u een echt API-antwoord plakken, inclusief een met privévelden, zonder dat deze uw machine verlaat Dat model aan de clientzijde is hetzelfde achter de rest van de site, beschreven in de online tools voor gegevensprivacy guide.

Hoe past dit bij de andere JSON tools?

De JSON to Go struct converter is een lid van een familie van JSON transformatoren op de site, en ze delen dezelfde parsing kern Wanneer je eerst de JSON wilt opruimen, de JSON-formatter zal inspringen en valideren, wat de moeite waard is voordat u converteert, zodat u de vorm kunt lezen die u gaat typen Wanneer uw doeltaal TypeScript is in plaats van Go, zal de JSON naar TypeScript-converter voert dezelfde gevolgtrekking uit en zendt interfaces uit Wanneer u een validatiecontract nodig heeft in plaats van taaltypen, wordt de JSON Schema generator produceert een Draft-07-schema, en wanneer de bestemming een PHP-codebasis is, zal de JSON naar PHP array converter schrijft een array letterlijk.

De draad die ze allemaal verbindt, is dat ze JSON behandelen als een bron van structuur en die structuur vertalen naar wat je codebase ook spreekt. Als je in verschillende talen werkt, is de Webontwikkelaar Toolkit roundup laat zien hoe deze stukken in elkaar grijpen, en de Handleiding voor coderingshulpmiddelen omvat de bredere set formatters en converters.

Een uitgewerkt voorbeeld van het bouwen van een Go-service

Laat me dit concreet maken Een tijdje terug was ik een kleine Go-service aan het schrijven die gegevens uit een API van derden haalde en een afgeslankte versie ervan opnieuw belichtte De vendor' s reactie was een genest object: een record op het hoogste niveau met een owner subobject, a tags array van strings, en een scores array die, vervelend genoeg, gehele getallen en decimalen mengde, afhankelijk van het veld. Het met de hand typen van de struct betekende het verkrijgen van de owner goed nesten, elke taggen snake_case sleutel, en beslissen wat te doen met die gemengde array.

Ik plakte de monsterreactie in de converter, noemde het roottype naar de bron en kreeg een struct terug Owner als een inline geneste structuur, Tags even []string, en Scores correct verbreed naar []float64. de id field kwam uit als ID met een json:"id" tag, dus het ging zowel de linter door als decodeerde de echte sleutel. Ik kopieerde het rechtstreeks naar het clientpakket en ging verder met de logica, waar ik eigenlijk mijn tijd aan wilde besteden. De structuur was niet het interessante deel van het werk, en door het te genereren betekende dit dat het geen enkel onderdeel meer was van het werk.

De reden dat ik op deze plekken naar de converter reik in plaats van naar een handgeschreven structuur is niet luiheid, het is dat de mechanische onderdelen, exporteren, taggen en nestelen, precies de onderdelen zijn die ik verkeerd krijg als ik in plaats daarvan aan de logica denk. Als ik ze naar een deterministisch hulpmiddel laad, betekent dit dat de struct correct is bij de eerste compile, en een correcte decode bij de eerste run, wat bij een geneste payload een echte debugsessie opslaat. Wanneer ik de struct nodig heb om ook te overleven als hij opnieuw wordt gecodeerd, schakel ik in omitempty de nulwaarden blijven dus buiten de uitvoer en de tags komen door als json:"key,omitempty" klaar voor die rondreis.

Wat zijn de grenzen die de moeite waard zijn om te weten?

Een paar eerlijke randjes De eerste is null. EEN JSON null draagt op zichzelf geen type-informatie, dus een veld dat wel is null in uw monster wordt getypt als interface{}. Er is niets dat de tool daar kan afleiden; als u het echte type kent, wijzig het dan in uw editor na het plakken, of voer de converter een monster toe waar dat veld een reële waarde heeft, zodat het type kan worden afgeleid Dit is een eigenschap van de gegevens, geen tekortkoming van de tool.

De tweede is numerieke precisie, en het is een eigenschap van JSON parsing in het algemeen in plaats van deze converter specifiek De tool parseert uw JSON met de browser' s JSON parser, die getallen vertegenwoordigt als dubbele precisie drijft, dus gehele getallen voorbij ruwweg 2 tot de 53e macht verliezen exactheid op parseertijd, voordat de tool ze ooit ziet De gegenereerde int64 het veld is breed genoeg om hold een grote ID, maar als de ID arriveert als een kaal JSON-nummer dat zo groot is, heeft de parse het al afgerond. Voor echt grote gehele ID's is de robuuste zet om ze als tekenreeksen in de JSON te dragen, waardoor ze exact blijven en je het veld kunt typen als string.

De derde is dat gevolgtrekking een startpunt is, geen evangelie. De tool geeft je de typen die de sample ondersteunt, maar alleen jij weet dat een veld dat in dit antwoord toevallig een geheel getal is, in werkelijkheid een nulbare telling is, of dat a float64 zou een json.Number om precisieverlies te voorkomen Behandel de output als een juiste eerste versie die je verfijnt, niet als een contract dat in steen is uitgehouwen Dat geldt voor elke generator van JSON naar typen, in elke taal.

Ten slotte produceert de converter inline geneste structs, die de hele vorm in één declaratie houden die je als blok kunt plakken. Dat is de meest voorkomende en meest leesbare stijl voor een gegenereerde struct, en dat is wat tools in het Go-ecosysteem populair maakten. Als je liever afzonderlijke benoemde typen hebt voor diep hergebruikte subobjecten, is dat een refactor die je met de hand doet zodra de inline-versie in je editor staat, en het is meestal een extract van vijf seconden met je IDE.

Veelgestelde vragen

Wat is een JSON to Go struct converter? Een JSON to Go struct converter transformeert een JSON document in de Go type declaraties die het beschrijven Elk object wordt een struct, elk veld krijgt een json: & quot; key" tag, en de waardetypen worden afgeleid, zodat u dezelfde gegevens kunt unmarshal met codering/json zonder de struct met de hand te schrijven.

Hoe converteer ik JSON naar een Go-structuur? Plak je JSON in het invoervak, voer een naam in voor het hoofdtype, kies je integer - en tagopties en klik vervolgens op Converteren Het gereedschap drukt Go struct-definities af met json-tags die je rechtstreeks in een .go-bestand kunt kopiëren.

Waarom zijn de Go-veldnamen anders dan mijn JSON-toetsen? Go codeert alleen geëxporteerde velden, dus elke veldnaam wordt met een hoofdletter geschreven en er worden algemene initialismen gemaakt die overeenkomen met golint. De json:"..." tag op elk veld behoudt de originele sleutel, dus json.Unmarshal brengt de gegevens nog steeds correct in kaart, ondanks het hernoemde veld.

Hoe worden JSON-nummers toegewezen aan Go-typen? Een geheel getal wordt int, of int64 als je die optie inschakelt, en een getal met een decimaal wordt float64 Wanneer een array gehele getallen en decimalen voor dezelfde positie mengt, wordt het type verbreed tot float64 zodat elke waarde past.

Hoe wordt omgegaan met arrays van objecten? Een array van objecten wordt samengevoegd tot een enkele struct die elke sleutel bevat die een element heeft Als twee elementen dezelfde sleutel-incompatibele typen geven, wordt dat veld interface{}, zodat de struct nog steeds de hele array bestrijkt.

Wat gebeurt er met nulwaarden? Een JSON-null geeft op zichzelf geen type-informatie, dus het veld wordt getypt als interface{}. Als u het echte type kent, wijzig deze dan in uw editor na het plakken, of geef een niet-nul voorbeeldwaarde op in de JSON, zodat het type kan worden afgeleid.

Is mijn json ergens geüpload? Nee. De conversie gebeurt volledig in uw browser met behulp van JavaScript op uw apparaat Uw JSON wordt nooit geüpload, gelogd of opgeslagen, en de tool blijft werken met het netwerk verbroken zodra de pagina is geladen.

Is de JSON to Go struct-converter gratis? Ja. Het is volledig gratis zonder aanmelding, zonder watermerk en zonder gebruikspet. Converteer zoveel JSON-documenten naar Go-structuren als u nodig heeft voor persoonlijke of commerciële projecten.