Lim inn Rust til venstre og klikk "Konverter" — vi gjør det om til JSONLim inn Rust-kode

Hva verktøyet gjør

Hvis du noen gang har definert en struct, slengt #[derive(Serialize)] oppå og så skjønt at du egentlig bare trenger JSON-en — uten å skrive serde-boilerplate, legge til serde_json i Cargo.toml og kjøre cargo run — så er det nøyaktig det dette verktøyet gjør. Lim inn Rust-koden her og få gyldig JSON tilbake uten å røre cargo. Det håndterer en enkelt struct-literal, en hel modul med flere typer, eller noe med dypt nestede Vec og Option — samme resultat: et rent JSON-dokument med hvert felt bevart.

Konverteren følger hvordan serde faktisk serialiserer verdier. String og &str blir JSON-strenger. i32, u64, f32, f64 blir alle JSON-tall. bool blir true/false. Vec<T>, &[T] og [T; N] blir JSON-arrays. HashMap<String, V> / BTreeMap<String, V> blir JSON-objekter. Option<T> med None blir JSON-null; med Some(value) serialiseres den indre typen. Tupler kommer ut som heterogene arrays — akkurat den oppførselen som er dokumentert på serde.rs/data-model.

Serde-attributter blir respektert. #[serde(rename = "x")] døper om JSON-nøkkelen, #[serde(skip)] fjerner feltet, og #[serde(flatten)] løfter felter fra en nestet struct opp til foreldreobjektet. enum-typer følger externally-tagged-representasjonen som standard (konfigurerbart med #[serde(tag = "type")]). Lim inn flere structs samtidig, så kommer hver ut som en oppføring på toppnivå. Jobber du med webtjenester bygd på Rust-standardbiblioteket pluss axum/actix, faller denne outputen rett ned i integrasjonstestene dine.

Slik bruker du det

Tre steg. Funker likt enten du limer inn én struct eller en hel modul med et dusin typer.

Lim inn Rust-en din (eller last eksemplet)

Slipp Rust-koden inn i venstre editor som den er. En struct, en tuple struct, en enum med varianter, flere typer eller nestede Vec/Option/HashMap — alt går. Klikk på Last eksempel for å se et realistisk tilfelle først.

Du trenger ikke fjerne use-setninger, lifetimes eller derive-attributter. La Rust-syntaksen stå som den er — serde-attributtene er en del av det parseren leser.

Trykk Konverter

Klikk på den grønne Konverter-knappen. Verktøyet leser Rust-en, beholder hver struct og hvert felt og spyr ut JSON på én runde. En kort lasteindikator går mens det jobber.

Kopier JSON-en

Høyre panel fylles med innrykket JSON. Kopier det inn i en reqwest-test, en axum-integrasjonstest, OpenAPI-eksemplene dine eller en curl-kommando. Ingen rebuild trengs.

Når dette faktisk er nyttig

Fixtures til webtjenester

Du har en axum- eller actix-request-struct og trenger JSON til en test eller et curl-kall. Lim inn structen, ta JSON-en, videre — ingen cargo-syklus.

Config-maler til CLI-er

En clap-drevet CLI med en Config-struct. Konverter den til en JSON-mal brukerne kan redigere, uten å skrive en egen <code>Default</code>-impl bare for dokumentasjonen.

Seeds til integrasjonstester

Gjør struct-literalene fra enhetstestene dine om til JSON-seed-filer for integrasjonstester, mock-servere eller fixtures til innebygde databaser.

Dokumentasjon som følger koden

Generer JSON-eksempler til README-en eller OpenAPI-speccen din direkte fra de ekte Rust-typene, så slutter dokumentasjonen å sige fra hverandre.

Vanlige spørsmål

Trenger jeg serde og serde_json i Cargo.toml?

Ikke for dette verktøyet — det kjører på serversiden og kompilerer ikke koden din. For runtime-bruk i din egen app er serde med derive-featuren pluss serde_json standardkombinasjonen.

Respekterer det #[serde(rename)], #[serde(skip)] og #[serde(flatten)]?

Ja. #[serde(rename = "x")] døper om JSON-nøkkelen, #[serde(skip)] fjerner feltet fra outputen, og #[serde(flatten)] løfter nestede struct-felter opp til forelderen — akkurat slik dokumentasjonen for serde field attributes beskriver.

Hvordan håndteres Option, Vec og HashMap?

Option<T> med None blir JSON-null; med Some(v) serialiseres den indre verdien. Vec<T>, slices og arrays blir JSON-arrays. HashMap<String, V> og BTreeMap<String, V> blir JSON-objekter; maps med ikke-string-nøkler får nøklene konvertert til strenger.

Hva med enums med varianter?

Som standard bruker enum-varianter externally-tagged-representasjonen ({ "VariantName": {...} }). Attributtene #[serde(tag = "type")], #[serde(untagged)] og #[serde(content = "data")] bytter til internally-tagged, untagged eller adjacently-tagged — verktøyet leser disse attributtene og sender ut tilsvarende.

Lagres koden min?

Koden din sendes til backend-en for konvertering og lagres ikke — vi logger ikke payloaden. Ta en titt på sensitiv kode før du limer den inn.

Hva hvis Rust-koden bruker lifetimes eller generics?

Lifetimes (&'a str) ignoreres — JSON har ikke begrepet. Konkretiserte generics (Vec<User>) funker. Ikke-instansierte generics kommer ut som null. Makroer som ekspanderer til ekte syntaks funker; makroer som hviler på en proc-macro-crate som ikke er synlig her, behandles som ugjennomsiktige.

Andre verktøy du kanskje får bruk for

Rust til JSON er bare én bit av puslespillet. Disse passer godt sammen med det:

Rust til JSON-konverter