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

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

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

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

स्वामित्व Rust का आधार है। Rust में प्रत्येक मान का एक ही स्वामी होता है। जब स्वामी दायरे से बाहर हो जाता है, तो मान स्वचालित रूप से हटा दिया जाता है।

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

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

2. उधार (borrowing) कैसे काम करता है?

उधार स्वामित्व को स्थानांतरित किए बिना अस्थायी रूप से मान का उपयोग करने की अनुमति देता है। उधार दो प्रकार के होते हैं: अपरिवर्तनीय (&T) और परिवर्तनीय (&mut T)।

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

मुख्य नियम: किसी भी समय, या तो एक परिवर्तनीय उधार हो सकता है या अपरिवर्तनीय उधारों की कोई भी संख्या हो सकती है।

3. जीवनकाल (lifetimes) क्या हैं?

जीवनकाल एनोटेशन हैं जिनकी Rust कंपाइलर को यह जांचने के लिए आवश्यकता होती है कि संदर्भ हैंगिंग (dangling) न हों। इनका उपयोग अक्सर उन फ़ंक्शनों में किया जाता है जो संदर्भ लौटाते हैं।

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

fn main() {    let s1 = String::from("लंबा");    let s2 = "छोटा";    let result = longest(&s1, s2);    println!("सबसे लंबी स्ट्रिंग: {}", result);}

टिप: अधिकांश मामलों में, कंपाइलर स्वयं जीवनकाल का अनुमान लगाता है (elision)। एनोटेशन केवल जटिल मामलों के लिए आवश्यक हैं।

4. ट्रेट्स (traits) क्या हैं और उनका उपयोग कैसे करें?

ट्रेट्स अन्य भाषाओं में इंटरफेस के समान हैं। वे विभिन्न प्रकारों के लिए सामान्य व्यवहार को परिभाषित करते हैं।

trait Summary {    fn summarize(&self) -> String;}

struct Article {    title: String,    content: String,}

impl Summary for Article {    fn summarize(&self) -> String {        format!("{}: {}...", self.title, &self.content[..20])    }}

fn main() {    let article = Article {        title: String::from("Rust"),        content: String::from("Rust एक सुरक्षित और तेज़ भाषा है"),    };    println!("{}", article.summarize());}

महत्वपूर्ण: ट्रेट्स में डिफ़ॉल्ट कार्यान्वयन हो सकते हैं और उन्हें पैरामीटराइज़ (सामान्यीकृत ट्रेट्स) किया जा सकता है।

5. String और &str में क्या अंतर है?

यह सबसे सामान्य प्रश्नों में से एक है। String एक परिवर्तनीय, स्वामित्व वाली स्ट्रिंग है जो हीप (heap) में संग्रहीत होती है। &str एक स्ट्रिंग स्लाइस का अपरिवर्तनीय उधार है, जो String, एक स्ट्रिंग लिटरल या स्ट्रिंग के एक भाग को संदर्भित कर सकता है।

fn main() {    let s1 = String::from("hello");  // String    let s2: &st
```