JSON in Rust

Raccomandazioni correlate

Informazioni su JSON in Rust: Convertire dati JSON in struct Rust compilabili

Casi d'uso

• Integrazione REST API
• Sviluppo backend Actix-web
• Sviluppo backend axum
• Definizione interfaccia microservizi
• Sviluppo strumenti CLI
• Progetti WebAssembly
• App desktop Tauri
• Parsing dati web scraper
• Sviluppo giochi
• IoT e embedded
• Migrazione database
• Blockchain/Web3
• Costruzione dati di test
• Parsing log strutturati
• Migrazione centro di configurazione
• Collaborazione cross-language
• Manutenzione SDK open source
• Esempi didattici Rust
• Conversione nomi campo

Come utilizzare

1. Incolla JSON nell'editor a sinistra o carica un file
2. Attendi 400ms per la conversione automatica
3. Se JSON è malformato clicca «Ripara JSON»
4. Clicca «Copia» o «Scarica» per salvare il file .rs
5. Aggiungi dipendenze serde e serde_json a Cargo.toml
6. (Opzionale) Regola manualmente i tipi di campo

Funzionalità

• Conversione locale nel browser: Parsing JSON e generazione codice Rust nel browser tramite quicktype-core Web Worker
• Output pronto per Serde: Genera automaticamente use serde::{Serialize, Deserialize}; e #[derive(...)]
• Inferenza intelligente dei tipi: String→String, intero→i64, float→f64, bool→bool, array→Vec<T>, oggetto annidato→struct indipendente, null→Option<serde_json::Value>
• Suddivisione automatica oggetti annidati
• Gestione automatica Vec e Option
• Pronto per Actix-web/axum/reqwest
• Auto-conversione con debounce 400ms
• Correzione errori JSON in un clic
• Copia e download
• Cronologia localStorage
• Pannelli reattivi
• Dati di esempio + caricamento file

Esempi di codice

// Cargo.toml
// [dependencies]
// actix-web = "4"
// serde = { version = "1", features = ["derive"] }
// serde_json = "1"

use actix_web::{web, App, HttpServer, HttpResponse, Responder};
use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize, Debug)]
pub struct CreateUserRequest {
    name: String,
    email: String,
    age: i64,
    tags: Vec<String>,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct User {
    id: i64,
    name: String,
    email: String,
    age: i64,
    tags: Vec<String>,
}

async fn create_user(payload: web::Json<CreateUserRequest>) -> impl Responder {
    let req = payload.into_inner();
    let user = User { id: 1, name: req.name, email: req.email, age: req.age, tags: req.tags };
    HttpResponse::Ok().json(user)
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| { App::new().route("/users", web::post().to(create_user)) })
    .bind("127.0.0.1:8080")?.run().await
}

// Cargo.toml
// axum = "0.7"
// tokio = { version = "1", features = ["full"] }
// serde = { version = "1", features = ["derive"] }
// reqwest = { version = "0.12", features = ["json"] }

use axum::{routing::get, Json, Router};
use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct Address { city: String, zip: String }

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct User { id: i64, name: String, email: String, address: Address, tags: Vec<String> }

async fn get_user() -> Json<User> {
    Json(User { id:1, name:"Alice".into(), email:"a@b.com".into(), address: Address{city:"Beijing".into(),zip:"100000".into()}, tags:vec!["rust".into(),"axum".into()] })
}

#[tokio::main]
async fn main() {
    let app = Router::new().route("/user", get(get_user));
    let listener = tokio::net::TcpListener::bind("127.0.0.1:8080").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

Domande frequenti

Risoluzione dei problemi

Glossario

struct

Parola chiave in Rust per definire tipi di dati composti.

Serde

Il framework di serializzazione/deserializzazione più popolare nell'ecosistema Rust.

Vec<T>

Tipo array dinamico nella libreria standard Rust.

Option<T>

Tipo valore opzionale nella libreria standard Rust.

Cargo

Sistema di build e gestore pacchetti ufficiale di Rust.

serde_json

Crate del framework Serde specifico per l'elaborazione JSON.

Serialize

Trait di serializzazione di Serde.

Deserialize

Trait di deserializzazione di Serde.

quicktype-core

Libreria di inferenza tipi e generazione codice multi-linguaggio.

chrono

Libreria data/ora più popolare nell'ecosistema Rust.

no_std

Modalità di compilazione Rust che disabilita la libreria standard.

tokio

Runtime asincrono più popolare nell'ecosistema Rust.

Tabella di riferimento tipi JSON → tipi Rust

Lo strumento deduce automaticamente i tipi Rust corrispondenti:

Privacy & Security

Tutte le operazioni di questo strumento JSON in Rust avvengono completamente localmente nel browser: parsing JSON, generazione codice Rust e download file sono eseguiti tutti lato client tramite il modulo WebAssembly quicktype-core; nessun contenuto JSON, file caricati o codice generato viene inviato in rete a server.

Authoritative References

• SerdeDocumentazione ufficiale Serde
• RustDocumentazione ufficiale Rust - Capitolo Structs