Rust साक्षात्कार कैसे पास करें: A से Z तक शीर्ष प्रश्न

परिचय: Rust साक्षात्कारकर्ता के लिए एक चुनौती क्यों है

Rust एक ऐसी भाषा है जो डेवलपर से मेमोरी प्रबंधन, टाइप सिस्टम और समवर्ती मॉडल की गहरी समझ की मांग करती है। Rust साक्षात्कार सिंटैक्स की जांच नहीं है, बल्कि भाषा के दर्शन की समझ का परीक्षण है। इस लेख में, हम उन प्रमुख प्रश्नों पर चर्चा करेंगे जो आपसे साक्षात्कार में पूछे जा सकते हैं - स्वामित्व की मूल बातों से लेकर एसिंक्रोनसी जैसे उन्नत विषयों तक। आप जानेंगे कि साक्षात्कारकर्ता किस प्रकार के उत्तरों की अपेक्षा करता है और सामान्य गलतियों से कैसे बचें।

1. स्वामित्व, उधार और जीवनकाल

1.1. स्वामित्व (ownership) क्या है और यह कैसे काम करता है?

यह Rust की नींव है। प्रत्येक मान का ठीक एक मालिक होता है। जब मालिक दायरे से बाहर हो जाता है, तो मान हटा दिया जाता है। यह कचरा संग्रह से बचाता है और संकलन चरण में मेमोरी सुरक्षा सुनिश्चित करता है।

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

सुझाव: स्थानांतरण (move) और प्रतिलिपि (copy) के बीच अंतर समझाएं। Copy ट्रेट (जैसे पूर्णांक) को लागू करने वाले प्रकारों के लिए, स्थानांतरण नहीं होता है - डेटा कॉपी किया जाता है।

1.2. उधार लेने के नियम (borrowing)

उधार लेना स्वामित्व हस्तांतरित किए बिना डेटा पर संदर्भ का उपयोग करने की अनुमति देता है। दो प्रकार के संदर्भ हैं:

\n
• अपरिवर्तनीय (&T): जितने चाहें उतने हो सकते हैं, डेटा को बदला नहीं जा सकता।
\n
• परिवर्तनीय (&mut T): वर्तमान दायरे में डेटा का केवल एक संदर्भ।
\n

fn main() {\n    let mut s = String::from("hello");\n    let r1 = &s; // अपरिवर्तनीय संदर्भ\n    let r2 = &s; // एक और अपरिवर्तनीय - ठीक है\n    // let r3 = &mut s; // त्रुटि! एक साथ अपरिवर्तनीय और परिवर्तनीय संदर्भ नहीं हो सकते\n    println!("{} {}", r1, r2);\n}

ट्रिकी प्रश्न: "Rust एक साथ परिवर्तनीय और अपरिवर्तनीय संदर्भों को क्यों प्रतिबंधित करता है?" उत्तर: संकलन चरण में डेटा रेस (data races) को रोकने के लिए।

1.3. जीवनकाल (lifetimes) - सरल शब्दों में कैसे समझाएं

जीवनकाल एनोटेशन हैं जो कंपाइलर को बताते हैं कि संदर्भ कितने समय तक मान्य रहेंगे। अक्सर कंपाइलर उन्हें स्वयं निकाल लेता है, लेकिन जटिल फ़ंक्शन में उन्हें स्पष्ट रूप से निर्दिष्ट करना पड़ता है।

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

मुख्य विचार: 'a का अर्थ है कि लौटाया गया संदर्भ दोनों इनपुट संदर्भों से अधिक जीवित नहीं रहेगा। यह सुनिश्चित करता है कि संदर्भ लटकता हुआ (dangling) नहीं बनेगा।

2. एनम, पैटर्न मैचिंग और ट्रेट्स

2.1. Rust में Enum - यह अन्य भाषाओं की तुलना में अधिक शक्तिशाली क्यों है

Rust में, एनम किसी भी प्रकार का डेटा संग्रहीत कर सकते हैं - स्ट्रिंग, संख्याएं, संरचनाएं और यहां तक कि अन्य एनम भी। यह बीजगणितीय डेटा प्रकार (ADT) बनाने की अनुमति देता है।

enum Message {\n    Quit,\n    Move { x: i32, y: i32 },\n    Write(String),\n    ChangeColor(i32, i32, i32),\n}

सामान्य प्रश्न: "Option<T> कैसे काम करता है और Rust में null क्यों नहीं है?" उत्तर: Option एक एनम है जो Some(T) या None हो सकता है। कंपाइलर दोनों विकल्पों को संभालने के लिए बाध्य करता है, जो शून्य पॉइंटर त्रुटियों को समाप्त करता है।

2.2. पैटर्न मैचिंग (pattern matching)

match संरचना Rust का हृदय है। यह संपूर्ण (exhaustive) होना चाहिए।

fn describe_point(point: (i32, i32)) -> &'static str {\n    match point {\n        (0, 0) => "मूल बिंदु",\n        (0, _) => "X-अक्ष पर",\n        (_, 0) => "Y-अक्ष पर",\n        _ => "समतल में कहीं",\n    }\n}

साक्षात्कार के लिए टिप: सरल मामलों के लिए if let का उपयोग करें