रस्ट साक्षात्कार कैसे पास करें: शीर्ष प्रश्न

परिचय: रस्ट साक्षात्कार में इतना मांग क्यों करता है?

Rust एक सिस्टम प्रोग्रामिंग भाषा है जो अपनी मेमोरी सुरक्षा और उच्च प्रदर्शन के लिए प्रसिद्ध है। Rust कंपाइलर सख्त लेकिन निष्पक्ष है: यह स्वामित्व (ownership) त्रुटि या लटकते संदर्भ (dangling reference) को नहीं छोड़ेगा। यही कारण है कि Rust साक्षात्कारों में शायद ही कभी "किताबी" सिंटैक्स पूछा जाता है। इसके बजाय, साक्षात्कारकर्ता मेमोरी मॉडल, संसाधन प्रबंधन और मुहावरेदार कोड की गहरी समझ की जाँच करते हैं।

इस लेख में, हम शीर्ष 10 प्रश्नों का विश्लेषण करेंगे जो अक्सर जूनियर और मिडिल Rust डेवलपर्स के साक्षात्कारों में पूछे जाते हैं। प्रत्येक प्रश्न के साथ स्पष्टीकरण और कोड उदाहरण दिया गया है। यदि आप साक्षात्कार की तैयारी कर रहे हैं, तो यह लेख आपकी चेकलिस्ट होगा।

1. स्वामित्व (Ownership) और उधार (Borrowing)

यह Rust की नींव है। स्वामित्व की समझ के बिना आप साक्षात्कार पास नहीं कर पाएंगे। साक्षात्कारकर्ता String और &str के बीच अंतर समझाने के लिए कह सकता है या पूछ सकता है कि कोड कंपाइल क्यों नहीं हो रहा है।

प्रश्न: समझाइए कि स्वामित्व क्या है और फ़ंक्शन में डेटा कैसे स्थानांतरित होता है।

उत्तर: Rust में, प्रत्येक मान का ठीक एक मालिक होता है। जब कोई वेरिएबल दायरे से बाहर होता है, तो मान हटा दिया जाता है (drop)। फ़ंक्शन में स्थानांतरण का अर्थ है स्वामित्व का स्थानांतरण (move), यदि प्रकार Copy ट्रेट को लागू नहीं करता है।

fn main() {    let s1 = String::from("hello");    let s2 = s1; // s1 को s2 में स्थानांतरित किया गया    // println!("{}", s1); // त्रुटि! s1 के पास अब स्ट्रिंग का स्वामित्व नहीं है    println!("{}", s2);}

यदि आप स्वामित्व खोए बिना डेटा स्थानांतरित करना चाहते हैं, तो संदर्भों (&) का उपयोग करें:

fn main() {    let s1 = String::from("hello");    let len = calculate_length(&s1); // उधार    println!("'{}' की लंबाई {} है।", s1, len);}

fn calculate_length(s: &String) -> usize {    s.len()}

प्रश्न: परिवर्तनीय उधार (mutable borrowing) क्या है और केवल एक ही क्यों हो सकता है?

उत्तर: परिवर्तनीय उधार (&mut) संदर्भ के माध्यम से मान को बदलने की अनुमति देता है। कंपाइलर गारंटी देता है कि डेटा रेस (data races) को रोकने के लिए दायरे में केवल एक परिवर्तनीय संदर्भ मौजूद है।

fn main() {    let mut s = String::from("hello");    let r1 = &mut s;    // let r2 = &mut s; // त्रुटि! दो परिवर्तनीय संदर्भ नहीं हो सकते    r1.push_str(", world");    println!("{}", r1);}

2. जीवनकाल (Lifetimes)

जीवनकाल वह चीज़ है जो शुरुआती लोगों को डराती है। साक्षात्कार में, आपसे 'a एनोटेशन की आवश्यकता और कंपाइलर lifetimes कैसे निकालता है, यह समझाने के लिए कहा जाएगा।

प्रश्न: जीवनकाल को स्पष्ट रूप से कब निर्दिष्ट करने की आवश्यकता है?

उत्तर: जब कोई फ़ंक्शन एक संदर्भ लौटाता है, और कंपाइलर स्वयं यह निर्धारित नहीं कर सकता कि यह कितने समय तक जीवित रहेगा। क्लासिक उदाहरण एक फ़ंक्शन है जो दो में से सबसे लंबी स्ट्रिंग लौटाता है:

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {    if x.len() > y.len() { x } else { y }}

fn main() {    let string1 = String::from("लंबी स्ट्रिंग");    let result;    {        let string2 = String::from("छोटी");        result = longest(&string1, &string2);    }    // println!("{}", result); // त्रुटि! string2 हटा दी गई, संदर्भ लटक रहा है}

एनोटेशन 'a कहता है: "लौटाए गए संदर्भ का जीवनकाल इनपुट संदर्भों के जीवनकाल में से छोटे के बराबर है"।

प्रश्न: elision (lifetimes छोड़ने के नियम) क्या है?

उत्तर: कंपाइलर सरल मामलों में स्वचालित रूप से lifetimes सम्मिलित करता है। यदि कोई फ़ंक्शन एक संदर्भ लेता है और एक संदर्भ लौटाता है - lifetime निकाला जाता है। यदि कई इनपुट संदर्भ हैं - तो इसे स्पष्ट रूप से निर्दिष्ट करने की आवश्यकता है।

3. Enum, Pattern Matching और Option/Result

Rust सक्रिय रूप से बीजगणितीय प्रकारों का उपयोग करता है