De taak die me leerde om afvlakking te respecteren, zag er saai uit op het ticket: " exporteer het instellingenobject naar een spreadsheet zodat de client het kan bewerken." De instellingen waren een diep geneste JSON-blob uit een Laravel-configuratie, drie en vier niveaus diep op sommige plaatsen, met reeksen featurevlaggen erin gemengd. Een spreadsheet heeft kolommen en geen bomen. Ik had elke bladwaarde nodig als een enkele platte sleutel die de client in één rij kon zien, bewerken en teruggeven, en toen moest ik de exacte geneste structuur opnieuw opbouwen op basis van hun bewerkingen zonder een enkele array-index te verliezen. Die retour, genest op vlak en vlak terug naar genest. Toolless, het geheel Tool en het is het geheel. JSON flattener is de tool die ik voor die klus heb gebouwd, en deze gids legt uit hoe het werkt en waar het je redt.
tl;dr: Een JSON-plattener zet een genest object om in een object met één niveau waarvan de sleutels het pad naar elke waarde zijn, dus
{"user":{"city":"Austin"}}HALD{"user.city":"Austin"}. Arrays worden platter met hun index in het pad (roles.0). Unflatten draait het om en bouwt de geneste objecten en arrays opnieuw op van die gestippelde toetsen. De Toolz-tool doet beide richtingen verliesvrij, bewaart lege objecten en arrays, ondersteunt de notatie van de punt- of haakjesarray en een aangepaste scheidingsteken, en draait volledig aan de clientzijde zonder upload en zonder aanmelding.
Ik bouw SaaS op Laravel en React en verzend WordPress plugins, dus geneste JSON is overal in mijn tijd: config bestanden, API payloads, i18n bericht catalogi, feature-flag winkels De systemen die die payloads verbruiken, hoewel, willen vaak platte toetsen Afvlakking is de adapter tussen een vorm die natuurlijk is voor gestructureerde gegevens en een vorm die natuurlijk is voor spreadsheets, omgevingsvariabelen, en stippel sleutel winkels Het is een kleine operatie die stilletjes een heleboel anderszins vervelende taken deblokkeert.
Wat is een JSON flattener?
Een JSON-plattener zet een genest JSON-object om in een object met één niveau waarbij elke sleutel het volledige pad is van de root naar een bladwaarde De padsyntaxis is ook niet willekeurig: RFC 6901 definieert JSON Pointer, de standaardmanier om één waarde in een document aan te pakken De geneste {"user":{"name":"Ada","address":{"city":"Austin"}}} wordt de flat {"user.name":"Ada","user.address.city":"Austin"}. Niets aan de waarden verandert; alleen hun adressering doet. Elk blad, hoe diep ook, krijgt één sleutel die aangeeft hoe je het kunt bereiken.
Arrays worden op dezelfde manier behandeld, waarbij de array-index een padsegment wordt: {"roles":["admin","editor"]} vlakt af {"roles.0":"admin","roles.1":"editor"}. de index in de sleutel is wat de omgekeerde bewerking de array in de juiste volgorde opnieuw laat opbouwen Die omgekeerde bewerking, onafgeplat, neemt een plat voorwerp van gestippelde toetsen en reconstrueert de geneste objecten en arrays, waarbij bij elke stap wordt beslist of een padsegment een objecteigenschap of een array-index noemt Wanneer afgeplat en onafgeplat dezelfde scheidingsteken- en array-notatie gebruiken, zijn het exacte inverses, en die verliesvrije retourvlucht is de eigenschap die het gereedschap betrouwbaar maakt voor echt werk in plaats van voor eenrichtingsgemak.
Waarom zou ik JSON überhaupt plat maken?
Omdat veel systemen alleen platte sleutel-waardeparen spreken, en een stippelpad de standaardmanier is om geneste structuur er doorheen te dragen zonder deze te verliezen Het duidelijkste voorbeeld is een spreadsheet Een spreadsheet is een raster van kolommen, en er is geen kolom voor & quot; de stad binnen het adres binnen de gebruiker." Maak het object plat en user.address.city wordt een enkele kolomkop waar de waarde onder kan leven, en dat is precies wat mijn instellingen-exportticket nodig had.
Dezelfde vorm komt op veel andere plaatsen naar voren. Omgevingsvariabelen en .env bestanden zijn plat en tools die config erop toewijzen, gebruiken gestippelde of onderstreepte paden. Internationaliseringsbibliotheken toetsen hun strings met stippelpaden zoals checkout.button.label. Feature-flag platforms, analytics event schema's, en een heleboel logging pijpleidingen willen allemaal één niveau van sleutels, vaak zodat ze elk veld onafhankelijk kunnen indexeren of bevragen In elk geval is het nestelen echt en betekenisvol, en door afvlakking blijft het in het pad behouden in plaats van weg te gooien, wanneer de platte weergave zijn doel heeft gediend, bouwt unflatten het oorspronkelijke object opnieuw op Als je ook specifiek tussen JSON en spreadsheets beweegt, wordt de CSV naar JSON converter is de natuurlijke metgezel voor het tabellarische deel van die reis.
Hoe wordt er met arrays omgegaan bij het afvlakken?
Arrays zijn het deel dat mensen het vaakst fout hebben, dus het is de moeite waard om precies te zijn Een array-element wordt afgeplat met behulp van zijn numerieke index als padsegment, waardoor de orde behouden blijft en de array exact opnieuw opgebouwd kan worden Het Toolz-gereedschap biedt twee notaties voor die index, en ze coderen dezelfde informatie met verschillende syntaxis.
| Invoer | Puntnotatie | Beugelnotatie |
|---|---|---|
{"roles":["admin","editor"]} |
roles.0, roles.1 |
roles[0], roles[1] |
{"items":[{"id":1}]} |
items.0.id |
items[0].id |
{"matrix":[[1,2]]} |
matrix.0.0 |
matrix[0][0] |
Puntnotatie schrijft roles.0, die compact is en overeenkomt met hoeveel config - en i18n-systemen hun waarden toetsen Schrijft de beugelnotatie roles[0]die JavaScript-toegangssyntaxis en de padstijl weerspiegelt die sommige querytalen gebruiken Geen van beide is correcter; u kiest degene die het systeem aan de andere kant verwacht. Het belangrijkste is consistentie: met welke notatie u ook platter wordt, gebruik dezelfde om te unflatten, want zo weet het hulpmiddel dat een numeriek segment & quot; array index" betekent; in plaats van & quot; een objectsleutel die toevallig een getal is." De Toolz-flattener is standaard ingesteld op puntnotatie en laat u met één klik naar haakje schakelen.
Hoe gebruik ik de JSON flattener?
De stroom heeft twee richtingen en een paar opties. Begin met het kiezen van plat of onafgeplat met de tuimelaar bovenaan. Flatten neemt geneste JSON en produceert gestippelde toetsen; unflatten neemt gestippelde toetsen en herbouwt de geneste structuur. Laad monster vult een uitgewerkt voorbeeld in in welke richting u zich ook bevindt, zodat u de vorm van zowel de invoer als de uitvoer kunt zien voordat u uw eigen gegevens plakt.
Plak je JSON in het invoervak Voor plat maken, dat is een genest object; voor unflatten is het een plat object waarvan de toetsen stippellijnen zijn De invoer moet geldig zijn JSON, en als dat niet het geval is, rapporteert het gereedschap het parser' s-bericht en de positie van het probleem in plaats van u een lege uitvoer te geven, zodat een verdwaalde achterliggende komma snel te vinden is Stel de sleutelstijl in: de scheidingsteken is standaard ingesteld op een punt en kan worden gewijzigd wanneer uw sleutels al stippen bevatten, en de arraynotatie schakelt tussen roles.0 en roles[0]. Houd die twee instellingen identiek over een flatten en de bijbehorende unflatten zodat de round trip line-up Klikt u op de actieknop, controleert u het aantal toetsen dat bevestigt hoeveel bladeren er zijn geproduceerd, en kopieert u de uitvoer of downloadt u deze als een .json bestand. Het geheel wordt uitgevoerd zodra u klikt, in uw browser, zonder dat er ergens iets wordt verzonden.
Is afvlakken verliesvrij, en wat zijn de randgevallen?
Voor de Toolz tool wel, met één randkastje dat het weten waard is Scalars, null, booleans, en cijfers overleven onaangeroerd Het subtiele deel zijn lege containers: een leeg voorwerp {} of een lege array [] wordt bewaard als bladwaarde in plaats van stilzwijgend te laten vallen, dus een configuratie die afhankelijk is van een lege lijst, maakt nog steeds retourvluchten naar precies wat het was. Veel naïeve flatteners verliezen lege containers, wat stilletjes de betekenis van een document verandert, dus dit is een bewuste keuze.
De enige echte beperking zijn sleutels die al de scheidingsteken bevatten. Als uw gegevens een objectsleutel hebben met een letterlijke punt erin, zoals {"a.b":1}, en je vlakkt af met een puntafbakening, het pad wordt dubbelzinnig: onafgeplat kan niet zeggen of a.b was één sleutel of een geneste a daarna b. De oplossing is om de scheidingsteken te veranderen in een teken dat niet in uw toetsen voorkomt, zoals een schuine streep of een pijp, en dezelfde scheidingsteken voor beide richtingen te gebruiken. Het is dezelfde klasse van ontsnappingsproblemen die u ziet wanneer csv-afbakeners botsen met de gegevens, en dezelfde oplossing geldt: kies een scheidingsteken dat uw waarden niet bevatten Buiten dat geval reproduceert een afvlakking gevolgd door een unflatten met overeenkomende instellingen het originele document exact, arrays en lege containers inbegrepen.
Wat is het verschil tussen afvlakken en converteren naar een ander formaat?
Afvlakken is geen formaatconversie; het is een herstructurering binnen JSON De output van een afvlakker is nog steeds JSON, alleen met een enkel niveau van gestippelde toetsen in plaats van nestelen Dat is anders dan de converters die van JSON een echt andere serialisatie maken, en weten welke je nodig hebt, bespaart een stap.
Als u dezelfde gegevens wilt die worden uitgedrukt als YAML voor een configuratiebestand, zal de JSON naar YAML-converter is het gereedschap, omdat het de syntaxis verandert in plaats van de vorm Als u een TypeScript-interface wilt die de structuur beschrijft, zodat uw voorkant weet wat deze verwerkt, is de JSON naar TypeScript-converter leidt dat af uit een steekproef Als u een formeel contract voor validatie wilt, wordt de JSON-schemagenerator leidt een JSON Schema af van een voorbeeld. Afvlakking zit hier naast in plaats van ze te vervangen: je wordt platter wanneer een downstream-systeem één sleutelniveau wil, en je converteert wanneer een systeem een andere taal wil. Ik doe beide vaak op volgorde, waarbij ik een payload afvlak om deze als kolommen te bewerken en vervolgens, afzonderlijk, typen genereer voor de geneste versie die ik aan React geef. Voor het mooi afdrukken of valideren van de JSON op elk punt in die keten, de JSON-formatter is het hulpprogramma dat ik openhoud op het volgende tabblad.
Hoe beslist unflatten tussen een array en een object?
Dit is het mechanisme dat de retourvlucht laat werken, en het begrijpen ervan verklaart zowel de tool' s standaards als de enige scherpe rand ervan Wanneer unflatten een toets leest zoals user.roles.0, het splitst het in de segmenten user, roles, en 0, dan loopt ze bouwstructuur zoals het gaat Bij elke stap kijkt het naar het volgende segment om te beslissen wat voor soort container te maken Als het volgende segment een niet-negatief geheel getal is, maakt het een array; als het iets anders is, maakt het een object Dus roles.0 vertelt de tool dat roles moet een array zijn waarvan het eerste element de waarde is, terwijl address.city vertelt het dat address moet een object zijn met een city property.
Die enkele regel, & quot; geheel getal segment betekent array index, & quot; is de reden waarom een flatten en een unflatten met overeenkomende instellingen arrays exact reproduceren Het is ook de reden dat de array notatie die u kiest consistent moet zijn In puntnotatie zijn de array index en een object sleutel beide slechts tekst tussen punten, dus het gereedschap vertrouwt volledig op de gehele test In haakjes notatie de [0] syntaxis maakt de intentie expliciet voordat de splitsing zelfs maar plaatsvindt Ofwel werkt, maar door ze te mengen, af te vlakken met haakjes en los te maken met stippen, wordt het signaal verbroken waarvan het gereedschap afhankelijk is.
Hier is de scherpe rand die volgt uit de regel: een object waarvan de toetsen werkelijk de snaren zijn "0", "1", "2" is niet te onderscheiden, eenmaal afgeplat, van een array Beide produceren de toetsen 0, 1, 2, en unflatten zal ze opnieuw opbouwen als een array, want dat is het overweldigend veel voorkomende geval Als je echt een object met numerieke tekenreekstoetsen nodig hebt om de heen-en-weer-reis te overleven, is dat de enige situatie waarin afvlakken en unflattening je niet het exacte type terug zal geven, en je beter af bent om dat object genest te houden of een niet-numeriek sleutelschema te gebruiken. In jaren dat ik dit doe, heb ik dat geval precies twee keer geraakt, beide keren in gegevens die in het begin aantoonbaar verkeerd waren gemodelleerd, dus de standaard is de juiste handel voor bijna iedereen. Het is dezelfde soort pragmatische beslissing achter het behouden van getallen met voorloopnullen als tekenreeksen in de tekenreeksen CSV naar JSON converter: de tool optimaliseert voor wat de gegevens bijna altijd betekenen, en documenteert de zeldzame uitzondering in plaats van het gemeenschappelijke pad lastig te maken.
Is mijn JSON veilig om in deze tool te plakken?
Ja, en het is eerder architectonisch dan een belofte Parseren, afvlakken, unflattening, en serialiseren draaien allemaal als JavaScript binnenin je eigen browsertabblad Er is geen upload, geen server round trip, en er is niets gelogd of opgeslagen Open je browser' s netwerktab en klik op de actieknop: geen verzoek gaat uit Als de pagina is geladen kun je de verbinding met internet verbreken en het blijft werken, omdat er nooit een server in de loop was om mee te beginnen.
Dit is belangrijker dan het lijkt, omdat JSON payloads precies het soort dingen zijn dat geheimen met zich meebrengt: API-tokens in een configuratie, persoonlijke gegevens in een API-antwoord, interne identificatiegegevens in een instellingenblob Een flattener die uw object naar een server heeft geüpload, zou een privépayload in iemand anders veranderen's logregel. De verwerking aan de clientzijde verwijdert het risico volledig. Daarom is dit de standaard voor elk hulpmiddel op Toolz.dev. Als je de volledige redenering wilt, heb ik het in de tekst uiteengezet gegevensprivacygids voor online tools, en de bredere kit die ik voor dit soort werk gebruik, zit in mijn Handleiding voor webontwikkelaars.
Veelgestelde vragen
Wat betekent het om JSON plat te maken?
Flattening JSON zet een genest object om in een object met één niveau waarvan de sleutels het pad naar elke waarde zijn De geneste {"user":{"city":"Austin"}} wordt de flat {"user.city":"Austin"}. Elke bladwaarde krijgt één gestippelde sleutel, en er blijft geen nesting in de uitvoer. Unflatten keert het proces om en herbouwt de geneste structuur.
Hoe wordt er met arrays omgegaan bij het afvlakken?
Array-elementen worden afgeplat met behulp van hun index als padsegment. {"roles":["admin","editor"]} HALD {"roles.0":"admin","roles.1":"editor"} in puntnotatie, of {"roles[0]":"admin","roles[1]":"editor"} tussen haakjes notatie De index behoudt de volgorde zodat de array kan worden herbouwd precies wanneer u unflatten.
Kan ik de gestippelde sleutels weer losmaken in de geneste JSON? Ja Schakel over naar de unflatten-modus en plak een plat object waarvan de toetsen stippellijnen zijn. Het gereedschap herbouwt de geneste objecten en arrays en beslist array versus object door te bepalen of elk padsegment een gehele index is. Afgeplat en onafgeplat zijn exacte inverses wanneer de scheidingsteken- en arraynotatie overeenkomen.
Wat is het verschil tussen punt- en haakjesarray-notatie?
Beide coderen dezelfde array-index; alleen de syntaxis verschilt Puntnotatie schrijft items.0.id, die compact en gemeenschappelijk in config en i18n sleutels is Schrijft de Beugelnotatie items[0].id, die overeenkomt met JavaScript-toegangssyntaxis en sommige querytalen Kies wat uw doelsysteem verwacht en gebruik dezelfde voor beide richtingen.
Verliest flattening gegevens? Nee. Scalars, nulls, booleans en zelfs lege objecten en lege arrays worden bewaard als bladwaarden, dus het niet afvlakken van het resultaat reproduceert het originele document. Het enige dat u moet bekijken zijn sleutels die uw scheidingsteken al bevatten, en daarom is het scheidingsteken configureerbaar.
Waarom zou ik JSON plat maken? Flattening past geneste gegevens aan systemen aan die één niveau van sleutels verwachten: spreadsheetkolommen, omgevingsvariabelen, gestippelde vertaalsleutels, feature-flag-stores en veel analyse- en logpijplijnen Het gestippelde pad voert de oorspronkelijke structuur door een vlak formaat, zodat er niets verloren gaat.
Wat gebeurt er als een sleutel al een punt bevat? Een letterlijke stip binnenin een toets is dubbelzinnig met de padscheider, dus de heen-en-terugreis kan deze op de verkeerde plaats splitsen Verander de scheidingsteken in een teken dat niet in je toetsen voorkomt, zoals een schuine streep of een pijp, en gebruik diezelfde scheidingsteken voor zowel plat als onvlak.
Is mijn json ergens geüpload? Nee. Parseren en transformeren wordt uitgevoerd als JavaScript in uw browser Niets wordt verzonden, gelogd of opgeslagen U kunt dit bevestigen door het tabblad netwerk te bekijken tijdens het afvlakken, of door offline te gaan, aangezien de tool blijft werken zonder verbinding.
