संदर्भ और उधार लेना: व्याख्या
संदर्भों और उधार लेने के बारे में सीखिए, जिससे आपके कोड के कई हिस्से स्वामित्व लिए बिना सुरक्षित रूप से डेटा तक पहुँच सकते हैं।
संदर्भ और उधार लेना: व्याख्या, CoddyKit पर Rust कोडिंग सीखें का एक निःशुल्क पाठ है। यह 3 में से 2वाँ पाठ है। इस अध्ययन पथ के 3 तक कोई भी पाठ पूरा पढ़ना निःशुल्क है — इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ व्यावहारिक अभ्यास भी उपलब्ध कराता है। यह Rust कोडिंग सीखें सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Rust कोडिंग सीखें पाठ्यक्रम में कुल 3 पाठ शामिल हैं।
संदर्भ क्या होते हैं
Rust में चर अपने डेटा के स्वामी होते हैं। लेकिन यदि आपको अपने कोड के अन्य हिस्सों को स्वामित्व लिए बिना उस डेटा को देखने या बदलने देना हो, तो क्या करेंगे?
यहीं संदर्भ काम आते हैं! संदर्भ किसी मान के पॉइंटर की तरह होता है, लेकिन Rust संकलक द्वारा लागू किए गए कड़े नियमों के साथ।
इसे वस्तु का स्वामी बनने के बजाय खिड़की से उसके पार देखने जैसा समझें।
आपका पहला संदर्भ
हम & ऑपरेटर का उपयोग करके संदर्भ बनाते हैं। यह किसी मान का गैर-स्वामित्व वाला पॉइंटर बनाता है। आइए इसे प्रयोग में देखें:
fn print_length(s: &String) {
println!("The length is: {}", s.len());
}
fn main() {
let message = String::from("Hello, CoddyKit!");
print_length(&message); // Pass a reference
println!("Original message still here: {}", message);
}उधार लेना समझना
जब आप किसी मान का संदर्भ बनाते हैं, तो आप उस मान को उधार लेते हैं। स्वामी उसका स्वामी बना रहता है, लेकिन आपको अस्थायी पहुँच मिल जाती है।
- बिना दिए उधार देना: आप उधार लिए गए डेटा का उपयोग कर सकते हैं।
- स्वामित्व का स्थानांतरण नहीं: मूल चर अभी भी डेटा का स्वामी रहता है और कार्यक्षेत्र से बाहर जाने पर उसे हटा देगा।
- सुरक्षा पहले: Rust के उधार लेने के नियम डेटा रेस जैसी सामान्य प्रोग्रामिंग त्रुटियों को रोकते हैं।
अपरिवर्तनीय उधार: केवल-पठन पहुँच
डिफ़ॉल्ट रूप से Rust में संदर्भ अपरिवर्तनीय होते हैं। इसका अर्थ है कि आप उनके द्वारा दर्शाए गए डेटा को पढ़ सकते हैं, लेकिन उसे बदल नहीं सकते।
यह सुरक्षा की एक मुख्य विशेषता है! यदि आपके कोड के कई हिस्सों को केवल-पठन की पहुँच हो, तो वे गलती से एक-दूसरे के डेटा में हस्तक्षेप नहीं कर सकते।
अपरिवर्तनीय उधार का प्रयोग
यहाँ calculate_sum फ़ंक्शन एक वेक्टर का अपरिवर्तनीय संदर्भ लेता है। यह तत्वों को पढ़ सकता है, लेकिन उन्हें जोड़ या हटा नहीं सकता।
fn calculate_sum(numbers: &Vec<i32>) -> i32 {
let mut total = 0;
for num in numbers {
total += num;
}
total
}
fn main() {
let my_numbers = vec![10, 20, 30, 40];
let sum = calculate_sum(&my_numbers); // Immutable borrow
println!("The sum is: {}", sum);
println!("Original vector: {:?}", my_numbers);
}परिवर्तनीय उधार: डेटा बदलना
कभी-कभी आपको उस डेटा में बदलाव करना पड़ता है जिसे आपने उधार लिया है। इसके लिए आप परिवर्तनीय संदर्भ का उपयोग करते हैं, जिसे &mut द्वारा दर्शाया जाता है।
परिवर्तनीय संदर्भों के साथ एक महत्वपूर्ण नियम जुड़ा है: किसी विशेष डेटा के लिए एक समय में केवल एक परिवर्तनीय संदर्भ हो सकता है। इससे डेटा रेस रुकती हैं और सुरक्षा सुनिश्चित होती है।
&mut से डेटा में बदलाव
add_suffix फ़ंक्शन String का एक परिवर्तनीय संदर्भ लेता है। यह मूल String में सीधे बदलाव कर सकता है।
fn add_suffix(text: &mut String) {
text.push_str(" (modified)");
}
fn main() {
let mut my_string = String::from("Original text");
add_suffix(&mut my_string); // Mutable borrow
println!("Modified string: {}", my_string);
}उधार लेने के स्वर्णिम नियम
Rust का कंपाइलर मेमोरी सुरक्षा की गारंटी देने के लिए इन नियमों को कंपाइल करते समय लागू करता है:
- आपके पास किसी डेटा के लिए एक समय में एक परिवर्तनीय संदर्भ हो सकता है।
- या, आपके पास एक समय में कितने भी अपरिवर्तनीय संदर्भ हो सकते हैं।
- सक्रिय अपरिवर्तनीय संदर्भ होने पर आपके पास परिवर्तनीय संदर्भ नहीं हो सकता।
- संदर्भ हमेशा मान्य होने चाहिए (वे जिस डेटा की ओर संकेत करते हैं, उसकी अवधि से अधिक समय तक जीवित नहीं रह सकते)।
ये नियम डेटा रेस को रोकते हैं और आपके प्रोग्राम को सुरक्षित तथा पूर्वानुमेय बनाए रखते हैं।
परस्पर विरोधी उधार
यह कोड my_value के लिए एक अपरिवर्तनीय और एक परिवर्तनीय संदर्भ एक ही समय में बनाने का प्रयास करता है, जो Rust के उधार लेने के नियमों का उल्लंघन है। यह कंपाइल नहीं होगा।
इसे चलाकर कंपाइलर की त्रुटि देखें!
fn main() {
let mut my_value = 100;
let r1 = &my_value; // Immutable reference
let r2 = &mut my_value; // Mutable reference (problem here!)
println!("r1: {}", r1);
// println!("r2: {}", r2); // This line would also cause an error if uncommented
}अपनी समझ जाँचें
निम्नलिखित Rust कोड अंश पर विचार करें:
fn process_data(data: &mut Vec<i32>) {
data.push(4);
}
fn main() {
let mut numbers = vec![1, 2, 3];
let first_ref = &numbers[0]; // Line A
process_data(&mut numbers); // Line B
println!("First element: {}", first_ref); // Line C
}Rust के उधार लेने के नियमों के कारण कौन-सी पंक्ति या पंक्तियाँ कंपाइल करते समय त्रुटि उत्पन्न करेंगी?
पुनरावृत्ति: संदर्भ और उधार
बहुत अच्छा! आपने Rust में संदर्भों और उधार लेने की मूल बातें सीख ली हैं:
- संदर्भ (
&) आपको स्वामित्व लिए बिना डेटा तक पहुँचने देते हैं। - उधार लेना संदर्भ बनाने और डेटा तक पहुँच उधार देने की प्रक्रिया है।
- अपरिवर्तनीय संदर्भ (
&) केवल पढ़ने की सुविधा देते हैं। - परिवर्तनीय संदर्भ (
&mut) पढ़ने और लिखने, दोनों की सुविधा देते हैं। - Rust के कठोर उधार लेने के नियम (एक परिवर्तनीय या अनेक अपरिवर्तनीय) डेटा रेस को रोकते हैं और कंपाइल करते समय मेमोरी सुरक्षा सुनिश्चित करते हैं।
सुरक्षित और कुशल Rust कोड लिखने के लिए ये अवधारणाएँ अत्यंत महत्वपूर्ण हैं!
एआई शिक्षक के साथ Rust सीखें — निःशुल्क
अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।
- पाठ्यक्रम
- 39
- पाठ
- 144
अक्सर पूछे जाने वाले प्रश्न
क्या “संदर्भ और उधार लेना: व्याख्या” पाठ निःशुल्क है?
हाँ — Rust कोडिंग सीखें अध्ययन पथ के 3 तक कोई भी पाठ, जिसमें “संदर्भ और उधार लेना: व्याख्या” भी शामिल है, यहाँ वेब पर पूरा पढ़ना निःशुल्क है। इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ इंटरैक्टिव अभ्यास भी उपलब्ध कराता है। Rust कोडिंग सीखें पाठ्यक्रम में कुल 3 पाठ शामिल हैं।
“संदर्भ और उधार लेना: व्याख्या” में मैं क्या सीखूँगा?
संदर्भों और उधार लेने के बारे में सीखिए, जिससे आपके कोड के कई हिस्से स्वामित्व लिए बिना सुरक्षित रूप से डेटा तक पहुँच सकते हैं। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Rust कोडिंग सीखें का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।
क्या Rust कोडिंग सीखें शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?
पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Rust कोडिंग सीखें शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 3 में से 2वाँ पाठ है।
“संदर्भ और उधार लेना: व्याख्या” पाठ पूरा करने में कितना समय लगता है?
CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।
क्या मैं इस Rust कोडिंग सीखें पाठ में कोड लिख और चला सकता हूँ?
हाँ। हर Rust कोडिंग सीखें पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।
इस पाठ्यक्रम के सभी पाठ
- Rust के स्वामित्व मॉडल को समझना
- संदर्भ और उधार लेना: व्याख्या
- सुरक्षित संदर्भों के लिए जीवनकाल