HI
RU
EN
ES
ZH
FR
DE
PT
AR
शुरुआती Rust डेवलपर्स की शीर्ष गलतियाँ: A से Z तक
\n\nRust एक शक्तिशाली और सुरक्षित प्रोग्रामिंग भाषा है, लेकिन इसकी सख्त स्वामित्व और उधार प्रणाली अक्सर शुरुआती लोगों को भ्रमित करती है। इस लेख में, हम उन सबसे सामान्य गलतियों पर चर्चा करेंगे जिनका सामना शुरुआती Rust डेवलपर्स करते हैं। प्रत्येक गलती के साथ कोड उदाहरण, स्पष्टीकरण और सही समाधान दिया गया है। चलिए शुरू करते हैं!
\n\n1. स्वामित्व प्रणाली (Ownership) की अनदेखी
\n\nसबसे आम गलती किसी मान को स्थानांतरित करने के बाद उसका उपयोग करने का प्रयास करना है। Rust में, प्रत्येक मान का केवल एक मालिक हो सकता है।
\n\n❌ गलत कोड:
\nfn main() {\n let s1 = String::from("नमस्ते");\n let s2 = s1;\n println!("{}", s1); // त्रुटि! s1 अब स्ट्रिंग का मालिक नहीं है\n}\n✅ सही समाधान:
\nfn main() {\n let s1 = String::from("नमस्ते");\n let s2 = s1.clone(); // स्पष्ट प्रतिलिपि\n println!("{}", s1); // अब काम करता है\n println!("{}", s2);\n}\nसुझाव: .clone() का उपयोग केवल तभी करें जब वास्तव में आवश्यक हो। आदिम प्रकारों (i32, bool) के लिए, प्रतिलिपि स्वचालित रूप से होती है।
2. String और &str के बीच भ्रम
\n\nशुरुआती लोग अक्सर स्वामित्व वाली स्ट्रिंग String और स्ट्रिंग स्लाइस &str के बीच अंतर नहीं समझते हैं। इससे फ़ंक्शन में स्ट्रिंग पास करते समय त्रुटियाँ होती हैं।
❌ गलत कोड:
\nfn print_message(msg: String) {\n println!("{}", msg);\n}\n\nfn main() {\n let greeting = "नमस्ते"; // &str\n print_message(greeting); // त्रुटि! String अपेक्षित है\n}\n✅ सही समाधान:
\nfn print_message(msg: &str) {\n println!("{}", msg);\n}\n\nfn main() {\n let greeting = "नमस्ते";\n print_message(greeting); // काम करता है!\n \n let owned = String::from("दुनिया");\n print_message(&owned); // &String स्वचालित रूप से &str में बदल जाता है\n}\nसुनहरा नियम: फ़ंक्शन पैरामीटर में &str का उपयोग करें, जब तक कि आपको स्ट्रिंग का स्वामित्व स्थानांतरित करने की आवश्यकता न हो।
3. उधार नियमों (Borrowing) का उल्लंघन
\n\nRust एक ही ऑब्जेक्ट पर एक साथ परिवर्तनशील और अपरिवर्तनीय संदर्भ रखने की अनुमति नहीं देता है। यह डेटा रेस से बचाता है।
\n\n❌ गलत कोड:
\nfn main() {\n let mut data = vec![1, 2, 3];\n let ref1 = &data;\n let ref2 = &mut data; // त्रुटि! पहले से ही एक अपरिवर्तनीय संदर्भ है\n println!("{}", ref1);\n}\n✅ सही समाधान:
\nfn main() {\n let mut data = vec![1, 2, 3];\n {\n let ref1 = &data;\n println!("{}", ref1); // ref1 केवल इस ब्लॉक में जीवित है\n } // ref1 दायरे से बाहर चला जाता है\n let ref2 = &mut data; // अब संभव है\n ref2.push(4);\n println!("{:?}", ref2);\n}\nमहत्वपूर्ण: संदर्भ का दायरा अंतिम उपयोग पर समाप्त होता है। Rust कंपाइलर इसे ट्रैक करने के लिए पर्याप्त स्मार्ट है।
\n\n4. लाइफटाइम (Lifetimes) से संबंधित समस्याएँ
\n\nलाइफटाइम एनोटेशन से संबंधित त्रुटियाँ शुरुआती लोगों को सबसे अधिक डराती हैं। सबसे सामान्य गलती स्थानीय वेरिएबल का संदर्भ लौटाना है।
\n\n❌ गलत कोड:
\nfn get_reference() -> &str {\n let local = String::from("परीक्षण");\n &local // त्रुटि! फ़ंक्शन से बाहर निकलने पर local नष्ट हो जाएगा\n}\n✅ सही समाधान (स्वामित्व के माध्यम से):
\nfn get_reference() -> String {\n let local = String::from("परीक्षण");\n local // स्वामित्व लौटाएँ\n}\n\nfn main() {\n let s = get_reference();\n println!("{}", s);\n}\n✅ सही समाधान (पैरामीटर के माध्यम से):
\nfn get_reference<'a>(input: &'a str) -> &'a str {\n input // समान लाइफटाइम के साथ संदर्भ लौटाएँ\n}\n\nfn main() {\n let data = String::from("परीक्षण");\n let result = get_reference(&data);\n println!("{}", re 
