जंग में कार्यों को समझना

कार्य आवश्यक प्रोग्रामिंग निर्माण हैं क्योंकि वे कोड पुन: प्रयोज्यता के लिए नींव रखते हैं और मॉड्यूलर प्रोग्रामिंग की सुविधा प्रदान करते हैं। कार्य कोड के स्व-निहित ब्लॉक हैं जो विशिष्ट कार्य करते हैं। वे तर्कों के रूप में इनपुट प्राप्त कर सकते हैं और एक मान वापस कर सकते हैं।

जंग कोड संगठन, एनकैप्सुलेशन और कोड पुन: प्रयोज्यता के लिए कार्य प्रदान करता है।

जंग में कार्यों को परिभाषित करना

जंग के कार्य बहुत पसंद हैं किसी अन्य प्रोग्रामिंग भाषा में कार्य करता है, हालांकि छोटे अंतर हैं जिन्हें आपको समझने की आवश्यकता होगी।

आप अपने रस्ट प्रोग्राम के लिए कार्यों को इसके साथ परिभाषित करेंगे fn कीवर्ड के बाद फ़ंक्शन का नाम, वैकल्पिक तर्क और एक वैकल्पिक रिटर्न होता है डेटा प्रकार.

// फ़ंक्शन जो न तो तर्क लेता है और न ही कोई मान लौटाता है
एफएन function_name () {
// फंक्शन बॉडी यहाँ
}

यहां एक सरल रस्ट फ़ंक्शन है जो किसी भी तर्क को स्वीकार नहीं करता है या किसी भी मान को वापस नहीं करता है।

एफएन a_function () {
 चलो एक्स = 3;
println!("{}", एक्स)
}

एक समारोह एक साधारण रस्ट फ़ंक्शन है जो चर को प्रिंट करता है एक्स.

जंग समारोह हस्ताक्षर

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

यहाँ एक उदाहरण रस्ट फंक्शन सिग्नेचर है:

एफएन नाम ()
fn अभिवादन (नाम: &str)

नाम फ़ंक्शन एक न्यूनतम फ़ंक्शन हस्ताक्षर है, जबकि अभिवादन हस्ताक्षर निर्दिष्ट करता है कि फ़ंक्शन एक ही तर्क लेता है, नाम, प्रकार की स्ट्रिंग (&str).

तर्कों और वापसी मूल्यों के साथ कार्यों की घोषणा करना

रस्ट फ़ंक्शन कई तर्क ले सकता है, और सीमा स्पष्ट रूप से परिभाषित नहीं है। तर्कों वाले कार्य आम तौर पर अधिक लचीले होते हैं क्योंकि वे अन्य कार्यों और कोड के कुछ हिस्सों से मान ले सकते हैं।

यहाँ एक रस्ट फ़ंक्शन का विशिष्ट मॉडल है जो तर्कों को लेता है:

fn function_name (तर्क: प्रकार, तर्क2: प्रकार) {
// फंक्शन बॉडी यहाँ
}

फ़ंक्शन तर्क प्रकार एक रस्ट बिल्ट-इन प्रकार या आपके प्रोग्राम से एक कस्टम प्रकार हो सकता है।

यहां एक साधारण फ़ंक्शन का उदाहरण दिया गया है जो तर्कों के रूप में दो पूर्णांक लेता है:

fn add_numbers (x: i32, y: i32) {
println!("{}", एक्स + वाई);
}

add_numbers फ़ंक्शन दो 32-बिट पूर्णांक लेता है और पूर्णांकों का योग प्रिंट करता है।

जंग कार्य कई मान लौटा सकते हैं; आपको रिटर्न प्रकार निर्दिष्ट करना होगा और फ़ंक्शन से प्रकार के मान वापस करना होगा।

fn function_name (तर्क: प्रकार, तर्क2: प्रकार) -> (प्रकार, प्रकार) {
// फंक्शन बॉडी यहाँ
वापस करना तर्क, तर्क 2
}

यहां एक फ़ंक्शन है जो एक तर्क के रूप में एक स्ट्रिंग और एक 32-बिट पूर्णांक लेता है और तर्कों को एक टपल के रूप में लौटाता है।

fn string_and_integer (s: स्ट्रिंग, n: i32) -> (स्ट्रिंग, i32) {
वापस करना (एस, एन);
}

string_and_integer फ़ंक्शन एक स्ट्रिंग और 32-बिट पूर्णांक लेता है, उन्हें एक टपल के रूप में लौटाता है। आप रस्ट फ़ंक्शन से केवल एक ही मान लौटा सकते हैं।

आप छोड़ सकते हैं वापस करना कोड को अधिक संक्षिप्त बनाने के लिए किसी फ़ंक्शन से अंतिम अभिव्यक्ति लौटाते समय कीवर्ड।

fn string_and_integer (s: स्ट्रिंग, n: i32) -> (स्ट्रिंग, i32) {
वापस करना (एस, एन);
}
// कार्य समकक्ष हैं
fn str_and_int (s: स्ट्रिंग, n: i32) -> (स्ट्रिंग, i32) {
 (एस, एन)
}

इन दो कार्यों का व्यवहार समान है क्योंकि वे दोनों एक स्ट्रिंग और पूर्णांक लेते हैं और उन तर्कों को टपल के रूप में वापस करते हैं।

रस्ट फंक्शन्स को कॉल करना

आप एक फ़ंक्शन को दूसरे से उसका नाम लिखकर उसके बाद वे मान लिख सकते हैं जिन्हें आप कोष्ठक के अंदर पास करना चाहते हैं:

fn add_numbers (x: i32, y: i32) -> i32 {
 एक्स + वाई
}
एफएन मुख्य () {
 चलो परिणाम = add_numbers (3, 5);
println!("परिणाम है {}", परिणाम); // आउटपुट: परिणाम 8 है
}

मुख्य समारोह कॉल add_numbers, इसे दो पूर्णांक पास करना। यह फ़ंक्शन के परिणाम को एक चर के लिए असाइन करता है, परिणाम.

आप रस्ट स्ट्रक्चर्स के लिए कार्यों की घोषणा कर सकते हैं

आप रस्ट स्ट्रक्चर्स के भीतर कार्यों की घोषणा कर सकते हैं। ये उस संरचना के तरीके बन जाते हैं जो इसे एक्सेस और संशोधित कर सकते हैं।

जंग विशुद्ध रूप से वस्तु-उन्मुख नहीं है, लेकिन यह समूह से संबंधित डेटा को संरचना प्रदान करता है। आप तरीकों के साथ structs का उपयोग कर जंग में OOP अवधारणाओं को लागू करने की दिशा में काम कर सकते हैं।