HI
RU
EN
ES
ZH
FR
DE
PT
AR
परिचय: Rust कठिन क्यों लगता है?
Rust एक आधुनिक सिस्टम प्रोग्रामिंग भाषा है, जो बिना garbage collector के मेमोरी सुरक्षा की गारंटी देती है। हालाँकि, इसकी सख्त type system और अद्वितीय ownership मॉडल अक्सर शुरुआती लोगों को भ्रमित करती है। यदि आप अभी Rust सीखना शुरू कर रहे हैं और लगातार compiler से लाल संदेश देखते हैं, तो निराश न हों - यह सामान्य है। इस लेख में, हम शुरुआती Rust डेवलपर्स की 10 सबसे आम गलतियों का विश्लेषण करेंगे और दिखाएंगे कि उन्हें कैसे ठीक किया जाए।
1. borrow checker को अनदेखा करना
सबसे आम गलती है किसी मान को move करने या mutable reference बनाने के बाद उसका उपयोग करने का प्रयास करना। Rust compiler (borrow checker) ownership के नियमों का सख्ती से पालन करता है।
समस्या
let s1 = String::from("नमस्ते");
let s2 = s1; // s1 को s2 में move कर दिया गया
println!("{}", s1); // त्रुटि! s1 के पास अब डेटा का ownership नहीं है
समाधान
यदि डेटा को कॉपी करने की आवश्यकता हो तो clone() का उपयोग करें, या references & पास करें:
let s1 = String::from("नमस्ते");
let s2 = &s1; // उधार लेना (borrowing)
println!("{} और {}", s1, s2); // काम करता है!
सुझाव: यदि compiler ownership पर आपत्ति करता है - तो संभवतः आपको पूर्ण move के बजाय एक reference की आवश्यकता है।
2. String और &str के बीच भ्रम
शुरुआती अक्सर owning type String और slice &str के बीच अंतर नहीं समझ पाते। इससे type errors और अनावश्यक allocations होते हैं।
समस्या
fn greet(name: &str) {
println!("नमस्ते, {}!", name);
}
let my_name = String::from("अन्ना");
greet(my_name); // त्रुटि: expected &str, found String
समाधान
String का reference पास करें - यह स्वचालित रूप से &str में बदल जाएगा:
greet(&my_name); // Deref रूपांतरण के कारण काम करता है
स्ट्रिंग्स के ownership और संशोधन के लिए String का उपयोग करें, और पढ़ने तथा फ़ंक्शन में पास करने के लिए &str का उपयोग करें।
3. unwrap() और expect() का अत्यधिक उपयोग
unwrap() और expect() विधियाँ Option या Result को संभालने का एक त्वरित तरीका हैं, लेकिन त्रुटि होने पर ये panic उत्पन्न करती हैं। production कोड में यह अस्वीकार्य है।
समस्या
let number: Option<i32> = None;
let value = number.unwrap(); // Panic!
समाधान
match या unwrap_or, unwrap_or_else विधियों का उपयोग करें:
let value = number.unwrap_or(0); // None होने पर 0 लौटाएगा
// या match के साथ
match number {
Some(v) => println!("{}", v),
None => println!("मान मौजूद नहीं है"),
}
Result के लिए, त्रुटि को ऊपर भेजने के लिए ? ऑपरेटर का उपयोग करें।
4. mutable references का गलत उपयोग
नियम "एक mutable reference या अनेक immutable references" का लगातार उल्लंघन किया जाता है।
समस्या
let mut data = vec![1, 2, 3];
let ref1 = &mut data;
let ref2 = &mut data; // त्रुटि!
println!("{}", ref1);
समाधान
कर्ली ब्रैकेट का उपयोग करके mutable references के scope को सीमित करें:
let mut data = vec![1, 2, 3];
{
let ref1 = &mut data;
ref1.push(4);
} // ref1 scope से बाहर चला जाता है
let ref2 = &mut data; // अब संभव है
ref2.push(5);
5. भूली हुई lifetimes
जब compiler को स्पष्ट रूप से lifetime निर्दिष्ट करने की आवश्यकता होती है, तो शुरुआती अटक जाते हैं। सबसे आम गलती स्थानीय वेरिएबल का reference लौटाना है।
समस्या
fn get_ref() -> &str {
let s = String::from("परीक्षण");
&s // त्रुटि: स्थानीय वेरिएबल का reference लौटा रहे हैं
}
समाधान
या तो owning type String लौटाएँ, या reference को argument के रूप में स्वीकार करें:
ब्लॉग
पुस्तक अनुशंसाएँ
यह भी पढ़ें
