Rust कोडिंग सीखें · पाठ

एलिजन नियम

लाइफ़टाइम का अनुमान कब लगाया जाता है

पाठ 4, कुल 4 में से13 चरण

एलिजन नियम, CoddyKit पर Rust कोडिंग सीखें का एक निःशुल्क पाठ है। यह 4 में से 4वाँ पाठ है। इस अध्ययन पथ के 3 तक कोई भी पाठ पूरा पढ़ना निःशुल्क है — इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ व्यावहारिक अभ्यास भी उपलब्ध कराता है। यह Rust कोडिंग सीखें सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Rust कोडिंग सीखें पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

वे Lifetimes जिन्हें आप नहीं लिखते

कई functions बिना किसी lifetime annotation के references लेते और लौटाते हैं, फिर भी वे compile हो जाते हैं। ऐसा lifetime elision के कारण होता है: compiler आपके लिए स्पष्ट lifetimes का अनुमान लगा लेता है।

Elision केवल एक Shortcut है

Elision lifetimes को हटाता नहीं है; compiler कुछ निश्चित नियमों का उपयोग करके पर्दे के पीछे उन्हें भर देता है। जब ये नियम आपके मामले पर लागू होते हैं, तो आप annotations छोड़ सकते हैं।

एक Elided Function

इस function में कोई स्पष्ट lifetimes नहीं हैं, फिर भी compiler समझता है कि लौटाया गया reference input से उधार लिया गया है। ये नियम इसे अस्पष्ट नहीं रहने देते।

fn first_word(s: &str) -> &str {
    s.split(' ').next().unwrap_or("")
}

fn main() {
    let phrase = String::from("rust is fun");
    println!("{}", first_word(&phrase));
}

नियम 1: हर Input को अपनी Lifetime मिलती है

पहला नियम: parameters में छोड़ी गई हर lifetime को अलग lifetime मिलती है। दो reference parameters को दो अलग lifetimes मिलती हैं।

नियम 2: एक Input, एक Output

दूसरा नियम: यदि ठीक एक input lifetime है, तो उसे सभी output lifetimes को दे दिया जाता है। यह first_word जैसे functions पर लागू होता है, जो एक reference लेते और लौटाते हैं।

fn trim_start(s: &str) -> &str {
    s.trim_start()
}

fn main() {
    println!("[{}]", trim_start("   hi"));
}

नियम 3: Methods और &self

तीसरा नियम: यदि किसी method में &self या &mut self है, तो self की lifetime सभी output lifetimes को दे दी जाती है। इसी कारण methods में annotations की आवश्यकता बहुत कम होती है।

struct Holder { value: String }

impl Holder {
    fn get(&self) -> &str {
        &self.value
    }
}

fn main() {
    let h = Holder { value: String::from("stored") };
    println!("{}", h.get());
}

जब Elision विफल हो जाती है

यदि तीनों नियम लागू करने के बाद भी कोई output lifetime अज्ञात रहती है, तो compiler आपसे उसे स्पष्ट रूप से annotate करने को कहता है। longest function इसका पारंपरिक उदाहरण है: दो inputs और अस्पष्ट output।

longest Function फिर से

दो reference inputs और एक reference output हैं: नियम 2 लागू नहीं होता (एक से अधिक inputs हैं) और कोई self भी नहीं है। इसलिए आपको annotation देनी होगी।

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

fn main() {
    println!("{}", longest("abcd", "ab"));
}

कई Inputs, self से Output

कई parameters वाले method को भी नियम 3 के अनुसार अपना output lifetime self से मिलता है, भले ही अन्य reference parameters मौजूद हों।

struct Doc { body: String }

impl Doc {
    fn announce(&self, _note: &str) -> &str {
        &self.body
    }
}

fn main() {
    let d = Doc { body: String::from("content") };
    println!("{}", d.announce("ping"));
}

ये नियम क्यों हैं

ये तीन नियम वास्तविक code के बहुत बड़े हिस्से को cover करते हैं, इसलिए अधिकांश functions में lifetime syntax की बिल्कुल आवश्यकता नहीं होती। आप annotations तभी लिखते हैं जब आशय वास्तव में अस्पष्ट हो।

एक त्वरित Checklist

यह तय करने के लिए कि elision लागू होती है या नहीं, पूछें:

क्या ठीक एक input reference है? Output उसी से उधार लिया गया है।
क्या कोई &self है? Output self से उधार लिया गया है।
अन्यथा, स्पष्ट रूप से annotation दें।

त्वरित जाँच

Elision rules की अपनी समझ जाँचें।

इंटरैक्टिव पाठ में इसका उत्तर दें

पुनरावलोकन

आपने सीखा कि lifetimes का अनुमान कब लगाया जाता है:

नियम 1: हर input reference को अपनी lifetime मिलती है
नियम 2: एक input lifetime सभी outputs को दी जाती है
नियम 3: Methods में &self output lifetime देता है
यदि outputs अस्पष्ट रहें, तो आप स्पष्ट रूप से annotation देते हैं

शुरुआत निःशुल्क

एआई शिक्षक के साथ Rust सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 39
पाठ: 144

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “एलिजन नियम” पाठ निःशुल्क है?

हाँ — Rust कोडिंग सीखें अध्ययन पथ के 3 तक कोई भी पाठ, जिसमें “एलिजन नियम” भी शामिल है, यहाँ वेब पर पूरा पढ़ना निःशुल्क है। इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ इंटरैक्टिव अभ्यास भी उपलब्ध कराता है। Rust कोडिंग सीखें पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“एलिजन नियम” में मैं क्या सीखूँगा?

लाइफ़टाइम का अनुमान कब लगाया जाता है आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Rust कोडिंग सीखें का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या Rust कोडिंग सीखें शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Rust कोडिंग सीखें शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 4वाँ पाठ है।

“एलिजन नियम” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस Rust कोडिंग सीखें पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर Rust कोडिंग सीखें पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

← Rust कोडिंग सीखें पर वापस जाएँ