डेवलपर / प्रकार

JSON से Rust Struct कन्वर्टर

JSON सैंपल को ऐसे Rust structs में बदलें जिनमें serde का Serialize और Deserialize derive हो, snake_case फ़ील्ड, renames, missing या null keys के लिए Option और arrays के लिए Vec हों।

JSON से Rust Struct कन्वर्टर: हर object public fields वाले struct में बदल जाता है। Keys snake_case में बदलती हैं; JSON की spelling अलग होने पर #[serde(rename = "…")] जोड़ा जाता है। type जैसे Rust keywords raw identifiers (r#type) बन जाते हैं, जिन्हें serde अपने-आप मूल रूप में मैप कर देता है। कुछ records में missing या null keys, Option<T> बन जाती हैं और जिन values का type स्पष्ट नहीं होता, वे serde_json::Value बनती हैं। कई samples के output को compile किया गया और उसके sample को serde 1 के साथ deserialize किया गया। यह आपके ब्राउज़र में 100% स्थानीय रूप से चलता है और सर्वर पर कोई फ़ाइल अपलोड नहीं होती।

श्रेणी: डेवलपर टूल्स
रन: आपके ब्राउज़र में
लागत: मुफ़्त · साइन अप की ज़रूरत नहीं
उपलब्धता: इस्तेमाल के लिए तैयार

JSON से Rustलोकल प्रोसेसिंग

पूरी तरह आपके ब्राउज़र में चलता है

JSON नमूना

[
  {
    "id": 42,
    "user_name": "ana",
    "avatar_url": "https://example.com/a.png",
    "score": 98.5,
    "tags": ["admin", "beta"],
    "address": { "city": "Lisbon", "zip_code": "1000-001" },
    "manager_id": null
  },
  {
    "id": 43,
    "user_name": "ben",
    "avatar_url": "https://example.com/b.png",
    "score": 71,
    "tags": [],
    "address": { "city": "Porto", "zip_code": "4000-001" },
    "manager_id": 42,
    "nickname": "B"
  }
]

टाइप का नाम सीरियलाइज़ करते समय None फ़ील्ड शामिल न करें

Rust

use serde::{Deserialize, Serialize};

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

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct User {
    pub id: i64,
    pub user_name: String,
    pub avatar_url: String,
    pub score: f64,
    pub tags: Vec<String>,
    pub address: Address,
    pub manager_id: Option<i64>,
    #[serde(default)]
    pub nickname: Option<String>,
}

pub type UserList = Vec<User>;

इसके लिए serde (derive फ़ीचर के साथ) और serde_json क्रेट आवश्यक हैं। जहाँ कुंजी अलग होती है, वहाँ फ़ील्ड के नाम #[serde(rename)] के साथ snake_case बन जाते हैं; कुछ ऑब्जेक्ट में मौजूद न रहने वाली या null कुंजियाँ Option बन जाती हैं। जब तक किसी नमूने में भिन्न उपलब्ध न हो, संख्याएँ i64 होती हैं।

डेटा पढ़ना और लिखना

serde_json::from_str::<Root>(&text)? से deserialize करें और serde_json::to_string(&value)? से serialize करें। इनपुट में मौजूद अज्ञात keys डिफ़ॉल्ट रूप से अनदेखी की जाती हैं; उन्हें अस्वीकार करने के लिए struct में #[serde(deny_unknown_fields)] जोड़ें।

Go में उसी सैंपल के लिए JSON से Go देखें; सैंपल को पहले व्यवस्थित करने के लिए JSON फ़ॉर्मैटर का उपयोग करें।

Option और गायब keys

गायब key और null value, दोनों Option फ़ील्ड के लिए None में deserialize होते हैं। अगर आपको दोनों में अंतर करना है, तो serde_with crate के साथ Option<Option<T>> का उपयोग करें या उस फ़ील्ड के लिए serde_json::Value रखें।

इस्तेमाल करने का तरीका

JSON सैंपल पेस्ट करें—बेहतर होगा कि इसमें कई सामान्य रिकॉर्ड वाला array हो।
टॉप-लेवल type का नाम दें और चुनें कि serializing के समय None फ़ील्ड हटाए जाएँ या नहीं।
इन structs को अपने crate में कॉपी करें; इसके लिए serde और serde_json की ज़रूरत होगी।

गोपनीयता और सीमाएँ

JSON आपके ब्राउज़र में convert होता है और कभी अपलोड नहीं किया जाता।

अक्सर पूछे जाने वाले सवाल

मुझे किन crates की ज़रूरत होगी?

derive feature वाला serde और serde_json: Cargo.toml में serde = { version = "1", features = ["derive"] } और serde_json = "1" जोड़ें।

i64 और f64 क्यों?

इनमें कोई भी JSON number सुरक्षित रूप से रखा जा सकता है। जहाँ आपको range पता हो, वहाँ इन्हें u32, u8 या f32 तक सीमित करें।

क्या मैं इसके बजाय #[serde(rename_all)] इस्तेमाल कर सकता हूँ?

हाँ: अगर हर key एक ही convention इस्तेमाल करती है, जैसे camelCase, तो struct पर लगा एक #[serde(rename_all = "camelCase")] अलग-अलग renames की जगह ले लेता है।

मुफ़्त टूल · आपके ब्राउज़र में बार चलता है · अकाउंट की ज़रूरत नहीं