Skip to content

JSON naar Rust struct omzetter

Plak JSON en krijg direct idiomatische Rust-serde-structs. 100% in je browser — data verlaat de pagina nooit. Correcte i64/u64/f64-typen, Option voor null, #[serde(rename)] voor camelCase. Gratis.

Geen tracking Draait in je browser Gratis
Opties
0 tekens
Rust-uitvoer
0 regels
Uitvoer geverifieerd tegen serde-semantiek en rustfmt-opmaak voor API-payloads uit de praktijk. — Go Tools Team · Jul 2, 2026

Wat is JSON naar Rust-conversie?

JSON naar Rust-conversie zet een JSON-voorbeeld om in compileerklare Rust-structs met de macro's #[derive(Serialize, Deserialize)] van serde, zodat je nooit deserialisatie-boilerplate voor API-responses of configuratiebestanden met de hand schrijft. Deze snelle Rust-struct-generator leidt correcte getaltypen af, markeert ontbrekende velden als Option en voegt #[serde(rename)] toe voor sleutels die geen snake_case zijn — allemaal 100% in je browser.

Voorbeelden

API-respons

{"id":101,"name":"Ada Lovelace","email":"ada@example.com","active":true,"roles":["admin","user"]}
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Root {
    pub id: i64,
    pub name: String,
    pub email: String,
    pub active: bool,
    pub roles: Vec<String>,
}

Een typische REST-payload wordt een serde-klare struct die je rechtstreeks in je client kunt plaatsen. Getallen worden i64, arrays worden Vec<String>.

Genest object

{"repo":"serde","owner":{"login":"dtolnay","id":100}}
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Root {
    pub repo: String,
    pub owner: Owner,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Owner {
    pub login: String,
    pub id: i64,
}

Geneste objecten worden afzonderlijke, benoemde structs (Owner) waarnaar per veld wordt verwezen — identieke vormen worden ontdubbeld.

Array van objecten (optioneel veld)

{"users":[{"id":1,"nick":"x"},{"id":2}]}
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Root {
    pub users: Vec<User>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct User {
    pub id: i64,
    pub nick: Option<String>,
}

Arrays van objecten worden samengevoegd tot één element-struct. Sleutels die in sommige items ontbreken, worden Option<String> — geen #[serde(default)] nodig.

camelCase-sleutels

{"login":"octocat","publicRepos":15,"followerCount":9001,"createdAt":"2011-01-25"}
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Root {
    pub login: String,
    #[serde(rename = "publicRepos")]
    pub public_repos: i64,
    #[serde(rename = "followerCount")]
    pub follower_count: i64,
    #[serde(rename = "createdAt")]
    pub created_at: String,
}

Velden worden snake_case met #[serde(rename)] die terugverwijst naar de originele JSON-sleutel. Sleutels die al snake zijn, zoals login, krijgen geen rename.

Zo zet je JSON om naar Rust

  1. 1

    Plak je JSON

    Zet een JSON-object, array of API-respons in het invoerveld. De conversie start direct.

  2. 2

    Stem de uitvoer af

    Hernoem het root-struct en schakel serde-derives, Debug en Clone of de pub-zichtbaarheid om, passend bij de stijl van je crate.

  3. 3

    Kopieer of download

    Haal de gegenereerde Rust met één klik op en plak het rechtstreeks in je project.

Common Use Cases

Getypeerde API-clients
Zet een voorbeeldrespons van REST of GraphQL om in serde-structs voor een reqwest- of vergelijkbare client, zonder deserialisatie-boilerplate met de hand te schrijven.
Config- en fixture-parsing
Genereer structs voor JSON-configuratiebestanden, testfixtures of webhook-payloads die je met serde_json moet deserialiseren.
Snel prototypen
Plak een onbekende payload om de vorm ervan direct als Rust-types te zien — een snelle manier om een nieuwe API te verkennen voordat je die aansluit.

Hoe de conversie werkt

Structurele afleiding
Elk object wordt een benoemd struct; identieke vormen worden ontdubbeld, zodat je één struct krijgt en geen kopieën. Arrays van objecten worden sleutel voor sleutel samengevoegd, en sleutels die in sommige items ontbreken, worden Option<T>.
Correcte getaltypering
Gehele getallen worden i64, gaan voorbij i64::MAX over naar u64 en vallen voorbij u64 terug op f64. Floats worden herkend aan het token (1.0, 2e3), zodat de serde-deserialisatie nooit faalt op een float-in-integer-conflict.
Idiomatische, compileerbare identifiers
Sleutels worden snake_case-velden met #[serde(rename)] terug naar de originele sleutel; Rust-sleutelwoorden, dubbele namen en niet-identifier-sleutels worden opgeschoond, zodat de uitvoer altijd compileert.
100% aan de clientzijde
Het verwerken en genereren draait in je browser zonder netwerkaanroepen, zodat je data privé blijft.

Tips voor schone Rust-structs

Geef je root-struct een naam
Stel een betekenisvolle rootnaam in (bijv. User, ApiResponse) in plaats van de standaard Root voor leesbare code.
Voeg serde_json alleen toe wanneer nodig
serde_json::Value verschijnt bij lege of gemengde arrays en velden die alleen null zijn. Geef die velden waar mogelijk een concreet type uit een rijker voorbeeld, of voeg serde_json toe aan Cargo.toml.
Beoordeel Option versus verplicht
Velden worden alleen als Option<T> gemarkeerd wanneer een voorbeeld ze weglaat. Plak een representatieve payload zodat de tool verplichte en optionele velden nauwkeurig afleidt.

Veelgestelde vragen

Hoe zet ik JSON om naar een Rust-struct?
Plak je JSON in het invoerveld. De omzetter leest het direct in je browser en genereert rechts Rust-structs met serde-derives. Klik op Kopiëren om het resultaat te halen — geen upload, geen account, geen wachten.
Genereert het serde-derives? Heb ik serde en serde_json nodig?
Ja — de uitvoer gebruikt standaard #[derive(Debug, Clone, Serialize, Deserialize)]. Voeg serde met de derive-feature toe aan je Cargo.toml. Je hebt serde_json alleen als dependency nodig als de uitvoer serde_json::Value bevat, wat voorkomt bij lege of gemengde arrays en velden die alleen null zijn. Zet de serde-schakelaar uit om kale structs te produceren.
Hoe gebruik ik het gegenereerde struct om JSON te parsen?
Voeg serde_json toe aan je Cargo.toml en deserialiseer in één regel: let root: Root = serde_json::from_str(json)?;. De gegenereerde Deserialize-derive doet de rest — gebruik serde_json::from_slice voor een byte-slice of from_reader voor een bestand of HTTP-body, en serde_json::to_string om terug te serialiseren.
Hoe worden optionele en null-velden afgehandeld?
Wanneer een sleutel in sommige array-items voorkomt maar in andere niet, wordt het een Option-veld. Een veld dat altijd alleen null is, wordt een optionele serde_json::Value. serde behandelt Option automatisch als optioneel, dus er wordt geen #[serde(default)]-attribuut toegevoegd of vereist.
Hoe gaat het om met camelCase-sleutels en Rust-sleutelwoorden?
Veldnamen worden omgezet naar idiomatisch snake_case, en een #[serde(rename)]-attribuut verwijst ze terug naar de exacte JSON-sleutel. Gereserveerde sleutelwoorden zoals type of match worden uitgevoerd als type_ of match_ met een rename, wat robuuster is dan ruwe identifiers omdat het ook self, crate en super dekt.
Kan het #[serde(rename_all)] gebruiken in plaats van renames per veld?
De tool geeft een #[serde(rename)] per veld uit omdat dat altijd werkt — zelfs wanneer één payload camelCase, snake_case en onregelmatige sleutels mengt. Als elk veld in een struct dezelfde conventie deelt, verwijder je die attributen en zet je in plaats daarvan één #[serde(rename_all = "camelCase")] op het struct; beide deserialiseren identiek.
Welk Rust-getaltype gebruikt het?
Gehele getallen worden i64, of u64 wanneer een waarde i64::MAX overschrijdt, en vallen voorbij u64 terug op f64 — zodat grote ID's nog steeds correct heen en weer gaan. Elk getal met een decimaalpunt of exponent (zoals 1.0 of 2e3) wordt f64, omdat serde een float in een integer-veld zou weigeren.
Hoe worden datums en tijdstempels getypeerd?
JSON heeft geen datumtype, dus ISO-strings zoals 2011-01-25 of RFC 3339-tijdstempels komen eruit als String. Voor echte datumverwerking wijzig je het veld naar een chrono-type — DateTime in de Utc-tijdzone, of NaiveDate — en schakel je de serde-feature van chrono in. serde parset RFC 3339 dan automatisch.
Hoe ga ik om met objecten met dynamische of onbekende sleutels?
Wanneer de sleutels variëren — bijvoorbeeld een map van ID's naar waarden — vervang je het gegenereerde struct door een HashMap met String als sleutel. Om een getypeerd struct te behouden en toch extra velden op te vangen, voeg je een #[serde(flatten)]-veld toe dat een HashMap is. Voor volledig dynamische waarden is serde_json::Value het opvangtype.
Zijn mijn JSON-gegevens privé en veilig?
Ja. De conversie draait 100% in je browser met JavaScript. Je JSON — inclusief tokens, ID's of klantgegevens — verlaat de pagina nooit en wordt nooit naar een server verzonden.
Kan ik kale Rust-structs zonder serde genereren?
Ja. Zet de serde-schakelaar uit om de use-serde-regel, de Serialize- en Deserialize-derives en alle #[serde(rename)]-attributen weg te laten — er blijven schone structs over. Je kunt ook de Debug- en Clone-derives en de pub-zichtbaarheid omschakelen.
Is de tool gratis? Heb ik een account nodig?
Hij is volledig gratis, zonder registratie, zonder limieten en zonder advertenties die de werkruimte vervuilen.

Gerelateerde tools

Alle tools bekijken →