Rust में Vec प्रिंट करना: शुरुआत से विशेषज्ञ तक

«Vec कैसे प्रिंट करें?» — हर Rust डेवलपर ने यह सवाल पूछा है

अगर आपने कभी Rust में कोड लिखा है और स्क्रीन पर वेक्टर प्रिंट करने की कोशिश की है, तो आपको यह एरर ज़रूर मिली होगी:

fn main() {\n    let numbers = vec![1, 2, 3, 4, 5];\n    println!("{}", numbers); // Error!\n}

कंपाइलर आपको लाल रंग में बताता है: `Vec<{integer}>` doesn't implement `std::fmt::Display`। यह परिचित लग रहा है? Stack Overflow पर इस सवाल के हज़ारों व्यूज़ हैं, और यह कोई संयोग नहीं है। Rust में कोई «जादू» नहीं है — कंपाइलर चाहता है कि आप बताएं कि आप कलेक्शन को कैसे दिखाना चाहते हैं। और यह अच्छी बात है, क्योंकि यह आपको पूरा नियंत्रण देता है।

इस लेख में हम Rust में Vec प्रिंट करने के सभी मुख्य तरीकों को समझेंगे: त्वरित डीबग आउटपुट से लेकर यूज़र के लिए खूबसूरत फ़ॉर्मेटिंग तक। आप जानेंगे कि कब कौन सा तरीका इस्तेमाल करना है, और कंपाइलर एरर से डरना छोड़ देंगे।

Vec Display को क्यों इम्प्लीमेंट नहीं करता?

कोड में कूदने से पहले, Rust की फ़िलॉसफ़ी को समझते हैं। Display ट्रेट यूज़र को डेटा दिखाने के लिए है — जैसा आप इंटरफ़ेस में देखना चाहते हैं। और Debug डीबगिंग और लॉग्स के लिए है।

वेक्टर के लिए यह अनुमान लगाना असंभव है कि आपको कौन सा फ़ॉर्मैट चाहिए:

\n
• एलिमेंट्स को कॉमा से अलग करके दिखाना?
\n
• हर एलिमेंट को नई लाइन पर?
\n
• स्क्वेयर ब्रैकेट में, ऐरे की तरह?
\n
• या टेबल के रूप में?
\n

इसलिए Rust डेवलपर्स ने एक ही फ़ॉर्मैट थोपने के बजाय, प्रोग्रामर पर चुनाव छोड़ दिया। आइए देखें कि हमारे पास कौन से विकल्प हैं।

तरीका 1: त्वरित डीबग आउटपुट (Debug)

सबसे आसान तरीका है {:?} या {:#?} (pretty-print) का उपयोग करना। इसके लिए वेक्टर के एलिमेंट टाइप को Debug ट्रेट इम्प्लीमेंट करना होगा।

fn main() {\n    let numbers = vec![1, 2, 3, 4, 5];\n    println!("{:?}", numbers);    // [1, 2, 3, 4, 5]\n    println!("{:#?}", numbers);   // खूबसूरत आउटपुट:\n                                  // [\n                                  //     1,\n                                  //     2,\n                                  //     3,\n                                  //     4,\n                                  //     5\n                                  // ]\n}

कब उपयोग करें: डीबगिंग, लॉगिंग, त्वरित जांच। प्रोडक्शन के लिए आमतौर पर उपयुक्त नहीं — फ़ॉर्मैट लचीला नहीं है।

महत्वपूर्ण: अगर आपका टाइप Debug इम्प्लीमेंट नहीं करता, तो कंपाइलर बता देगा। अपनी स्ट्रक्चर के लिए #[derive(Debug)] जोड़ सकते हैं:

#[derive(Debug)]\nstruct Point {\n    x: f64,\n    y: f64,\n}\n\nfn main() {\n    let points = vec![Point { x: 1.0, y: 2.0 }, Point { x: 3.0, y: 4.0 }];\n    println!("{:?}", points);\n}

तरीका 2: इटरेटर के साथ मैन्युअल लूप

सबसे लचीला तरीका — अपना खुद का लूप लिखना। आपको फ़ॉर्मैट पर पूरा नियंत्रण मिलता है।

fn main() {\n    let words = vec!["hello", "world", "rust"];\n    \n    // विकल्प 1: कॉमा से अलग करके\n    for (i, word) in words.iter().enumerate() {\n        if i > 0 {\n            print!(", ");\n        }\n        print!("{}", word);\n    }\n    println!(); // hello, world, rust\n\n    // विकल्प 2: हर एक नई लाइन पर\n    for word in &words {\n        println!("- {}", word);\n    }\n    // - hello\n    // - world\n    // - rust\n}

यह तरीका अधिकतम लचीलापन देता है, लेकिन इसमें ज़्यादा कोड लिखना पड़ता है। जब अनोखी फ़ॉर्मेटिंग चाहिए तो यह बढ़िया है।

तरीका 3: इटरेटर के साथ collect और join का उपयोग

अगर आपको सिर्फ़ एलिमेंट्स को एक स्ट्रिंग में जोड़ना है, तो SliceConcatExt ट्रेट (स्लाइस के लिए उपलब्ध) से join का उपयोग कर सकते हैं:

fn main() {\n    let words = vec!["hello", "world", "rust"];\n    let joined = words.join(", ");\n    println!("{}", joined); //