JSON ke Rust

Kode Rust

Belum ada konten

Siap

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.

Rekomendasi Terkait

Pemformat JSON

Perbaikan JSON

JSON ke TypeScript

JSON ke Go

JSON ke Python

JSON → YAML

Tentang JSON ke Rust: Mengonversi data JSON menjadi struct Rust yang dapat dikompilasi

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.

Kasus penggunaan

Integrasi REST API
Pengembangan backend Actix-web
Pengembangan backend axum
Definisi antarmuka mikroservis
Pengembangan alat CLI
Proyek WebAssembly
Aplikasi desktop Tauri
Parsing data web scraper
Pengembangan game
IoT dan embedded
Migrasi basis data
Blockchain/Web3
Konstruksi data uji
Parsing log terstruktur
Migrasi pusat konfigurasi
Kolaborasi cross-language
Pemeliharaan SDK open source
Contoh didaktis Rust
Konversi nama field

Cara Penggunaan

Tempel JSON di editor kiri atau unggah file
Tunggu 400ms untuk konversi otomatis
Jika JSON salah format klik «Perbaiki JSON»
Klik «Salin» atau «Unduh» untuk menyimpan file .rs
Tambahkan dependensi serde dan serde_json ke Cargo.toml
(Opsional) Sesuaikan tipe field secara manual

Fitur

Konversi lokal di browser
Output siap Serde
Inferensi tipe cerdas
Pemisahan otomatis objek bersarang
Penanganan otomatis Vec dan Option
Siap Actix-web/axum/reqwest
Auto-konversi dengan debounce 400ms
Perbaikan kesalahan JSON dalam satu klik
Salin dan unduh
Riwayat localStorage
Panel terbagi responsif
Data contoh + unggah file

Contoh Kode

Rust: Handler Actix-web menerima body request JSON

rust

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
}

Rust: Rute axum + parsing respons klien reqwest

rust

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();
}

Pertanyaan Umum

Bagaimana cara mengonversi JSON ke struct Rust?

Tempel JSON di editor kiri, alat akan menghasilkan kode Rust secara otomatis.

Apakah kode Rust yang dihasilkan menyertakan anotasi serde?

Ya, termasuk #[derive(Serialize, Deserialize)] dan pernyataan use.

Struktur JSON apa yang didukung?

Semua struktur JSON yang valid: tipe primitif, array, objek bersarang.

Bagaimana tipe JSON dipetakan ke tipe Rust?

String→String, integer→i64, float→f64, boolean→bool, array→Vec<T>, objek bersarang→struct independen, null→Option<serde_json::Value>.

Tipe apa yang dihasilkan untuk nilai null?

Nilai null menghasilkan Option<serde_json::Value>.

Apakah array dikonversi ke Vec?

Ya, array JSON menjadi Vec<T>.

Bagaimana objek bersarang ditangani?

Setiap objek bersarang menghasilkan struct independen.

Dapatkah saya menyesuaikan nama struct yang dihasilkan?

Ya, ubah nama secara manual setelah generasi.

Dapatkah kode yang dihasilkan digunakan langsung dalam proyek Cargo?

Ya, tambahkan serde dan serde_json ke Cargo.toml.

Dapatkah digunakan untuk Actix-web/axum?

Ya, langsung sebagai parameter web::Json<T> atau Json<T>.

Mendukung parameter perintah Tauri?

Ya, gunakan sebagai tipe parameter #[tauri::command].

Mendukung tipe presisi seperti chrono::DateTime?

Ya, ubah tipe secara manual setelah generasi.

Apakah data dikirim ke server?

Tidak, semuanya berjalan lokal di browser.

Apakah perlu registrasi?

Tidak, sepenuhnya gratis tanpa registrasi.

Pemecahan Masalah

Menampilkan «Masukkan data JSON» atau sisi kanan kosong

Menampilkan kesalahan parsing JSON

Tipe field tidak cukup akurat

Kesalahan kompilasi crate serde/serde_json tidak ada

Glosarium

struct: Kata kunci di Rust untuk mendefinisikan tipe data komposit.
Serde: Framework serialisasi/deserialisasi paling populer di ekosistem Rust.
Vec<T>: Tipe array dinamis di pustaka standar Rust.
Option<T>: Tipe nilai opsional di pustaka standar Rust.
Cargo: Sistem build dan manajer paket resmi Rust.
serde_json: Crate framework Serde khusus untuk pemrosesan JSON.
Serialize: Trait serialisasi Serde.
Deserialize: Trait deserialisasi Serde.
quicktype-core: Pustaka inferensi tipe dan generasi kode multibahasa.
chrono: Pustaka tanggal/waktu paling populer di ekosistem Rust.
no_std: Mode kompilasi Rust yang menonaktifkan pustaka standar.
tokio: Runtime asinkron paling populer di ekosistem Rust.

Tabel referensi tipe JSON → tipe Rust

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

Privacy & Security

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.