Belum ada konten
Alat online gratis JSON ke Rust. Tempel JSON respons API untuk menghasilkan struct dengan derive Serde secara otomatis, objek bersarang terbagi secara independen, Vec dan Option disimpulkan secara cerdas, konversi lokal murni di browser, tanpa perlu registrasi.
JSON ke Rust adalah proses mengonversi data dalam format JSON menjadi definisi tipe struct Rust.
Alat ini berjalan lokal di browser berbasis quicktype-core.
Inferensi tipe adalah inti dari JSON ke Rust.
Semua perhitungan terjadi di browser, tidak ada data yang dikirim ke server.
Kode yang dihasilkan biasanya digunakan dalam proyek Cargo.
Kode yang dihasilkan secara otomatis adalah titik awal, bukan titik akhir.
Gunakan Actix-web 4.x dengan struct yang dihasilkan sebagai parameter web::Json<T>.
// 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
}Server axum menggunakan ekstraktor Json<T>, klien reqwest menggunakan .json::<T>().
// 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();
}Tempel JSON di editor kiri, alat akan menghasilkan kode Rust secara otomatis.
Ya, termasuk #[derive(Serialize, Deserialize)] dan pernyataan use.
Semua struktur JSON yang valid: tipe primitif, array, objek bersarang.
String→String, integer→i64, float→f64, boolean→bool, array→Vec<T>, objek bersarang→struct independen, null→Option<serde_json::Value>.
Nilai null menghasilkan Option<serde_json::Value>.
Ya, array JSON menjadi Vec<T>.
Setiap objek bersarang menghasilkan struct independen.
Ya, ubah nama secara manual setelah generasi.
Ya, tambahkan serde dan serde_json ke Cargo.toml.
Ya, langsung sebagai parameter web::Json<T> atau Json<T>.
Ya, gunakan sebagai tipe parameter #[tauri::command].
Ya, ubah tipe secara manual setelah generasi.
Tidak, semuanya berjalan lokal di browser.
Tidak, sepenuhnya gratis tanpa registrasi.
Alat secara otomatis menyimpulkan tipe Rust yang sesuai:
| Contoh JSON | Tipe Rust yang dihasilkan | Deskripsi |
|---|---|---|
null | Option<serde_json::Value> | Nilai null, Option sebagai fallback |
true / false | bool | Boolean JSON → bool |
42 | i64 | Integer JSON → i64 |
3.14 | f64 | Float JSON → f64 |
"hello" | String | String JSON → String |
["a","b"] | Vec<String> | Array string → Vec<String> |
[1,2,3] | Vec<i64> | Array integer → Vec<i64> |
[{...},{...}] | Vec<Item> | Array objek → Vec<Item> |
[] | Vec<serde_json::Value> | Array kosong |
{...} objek bersarang | struct independen | Objek bersarang menghasilkan struct independen |
Semua operasi alat JSON ke Rust ini berjalan sepenuhnya secara lokal di browser: parsing JSON, generasi kode Rust, dan unduhan file semuanya dieksekusi di sisi klien melalui modul WebAssembly quicktype-core; tidak ada konten JSON, file yang diunggah, atau kode yang dihasilkan dikirim melalui jaringan ke server.