Rust में फ़ंक्शंस – Functions in Rust

इस अध्याय में हम Rust प्रोग्रामिंग में फ़ंक्शंस (Functions) के उपयोग और उनके महत्व को समझेंगे। फ़ंक्शंस प्रोग्रामिंग में कोड को पुनः उपयोग करने योग्य, संगठित और मॉड्यूलर बनाने में मदद करते हैं। Rust में फ़ंक्शंस को कैसे परिभाषित किया जाता है, फ़ंक्शंस में पैरामीटर्स और रिटर्न वैल्यू कैसे काम करते हैं, इस अध्याय में आप इन सभी को विस्तार से जानेंगे। इसके अलावा, हम यह भी देखेंगे कि फ़ंक्शंस का उपयोग कैसे किया जाता है ताकि आपका कोड अधिक संगठित और पढ़ने में आसान हो सके।

Functions का परिचय (Introduction to Functions)

Rust प्रोग्रामिंग में फ़ंक्शंस (Functions) एक बहुत ही महत्वपूर्ण भूमिका निभाते हैं। फ़ंक्शंस का मुख्य उद्देश्य कोड को छोटे, पुन: उपयोग करने योग्य हिस्सों में विभाजित करना है। इससे कोड न केवल अधिक संगठित और पठनीय बनता है, बल्कि इसे डिबग और बनाए रखना भी आसान हो जाता है।

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

फ़ंक्शन डेफिनेशन (Function Definition)

Rust में फ़ंक्शन को परिभाषित करने के लिए fn कीवर्ड का उपयोग किया जाता है। फ़ंक्शन में एक नाम, पैरामीटर्स (यदि हो), और कोड का ब्लॉक होता है जो उस फ़ंक्शन द्वारा किया जाने वाला कार्य परिभाषित करता है। फ़ंक्शन का नाम हमेशा snake_case में होता है, यानी सभी अक्षर छोटे होते हैं और शब्दों को _ से अलग किया जाता है।

सिंटैक्स (Syntax):

fn function_name() {
    // यहाँ फ़ंक्शन का कोड आता है
}

उदाहरण:

fn main() {
    // 'greet' फ़ंक्शन को कॉल करना
    greet();
}

// फ़ंक्शन डेफिनेशन
fn greet() {
    println!("नमस्ते, यह मेरा पहला फ़ंक्शन है!");
}

इस उदाहरण में, greet नाम का एक फ़ंक्शन परिभाषित किया गया है जो सिर्फ एक लाइन को प्रिंट करता है। main फ़ंक्शन के अंदर, हम greet फ़ंक्शन को कॉल करते हैं, और जब प्रोग्राम चलता है, तो यह “नमस्ते, यह मेरा पहला फ़ंक्शन है!” प्रिंट करेगा।

फ़ंक्शंस के लाभ (Benefits of Using Functions)

1. कोड का पुन: उपयोग (Code Reusability): एक बार फ़ंक्शन बनाने के बाद, आप इसे जितनी बार चाहें कॉल कर सकते हैं। इससे कोड को बार-बार लिखने की जरूरत नहीं पड़ती।
2. कोड की पठनीयता (Code Readability): फ़ंक्शंस को नाम देने से प्रोग्राम के विभिन्न हिस्सों को समझना आसान हो जाता है। आप देख सकते हैं कि कौन सा फ़ंक्शन क्या कर रहा है।
3. कोड का रखरखाव (Maintainability): जब कोड को छोटे-छोटे हिस्सों में बांटा जाता है, तो उसे डिबग करना और उसमें बदलाव करना आसान होता है।
4. मॉड्यूलरिटी (Modularity): फ़ंक्शंस के साथ, आप अपने प्रोग्राम को छोटे-छोटे हिस्सों में विभाजित कर सकते हैं। इससे जटिलता को कम किया जा सकता है।

फ़ंक्शन का उपयोग कैसे करें? (How to Use a Function?)

फ़ंक्शंस को कॉल करने के लिए बस फ़ंक्शन का नाम और कोष्ठक ( ) का उपयोग किया जाता है। Rust में, फ़ंक्शन को कॉल करते समय फ़ंक्शन का नाम लिखना होता है और उसके बाद कोष्ठक होते हैं, भले ही फ़ंक्शन में कोई पैरामीटर न हो।

fn main() {
    say_hello();
    say_hello();
}

fn say_hello() {
    println!("नमस्ते!");
}

इस उदाहरण में, say_hello फ़ंक्शन को दो बार कॉल किया गया है, और आउटपुट में “नमस्ते!” दो बार प्रिंट होगा।

फ़ंक्शन डेफिनेशन, पैरामीटर्स और रिटर्न वैल्यू (Function Definition, Parameters, and Return Values)

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

फ़ंक्शंस में पैरामीटर्स (Parameters in Functions)

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

सिंटैक्स (Syntax):

fn function_name(parameter1: type, parameter2: type) {
    // कोड जो पैरामीटर्स का उपयोग करता है
}

उदाहरण:

fn main() {
    greet("राज");  // 'राज' पैरामीटर के रूप में पास किया गया है
}

fn greet(name: &str) {
    println!("नमस्ते, {}!", name);
}

इस उदाहरण में, greet फ़ंक्शन एक पैरामीटर name को स्वीकार करता है। जब हम greet("राज") को कॉल करते हैं, तो यह आउटपुट देगा: “नमस्ते, राज!”

कई पैरामीटर्स (Multiple Parameters)

आप एक से अधिक पैरामीटर्स भी पास कर सकते हैं, और उनके बीच कॉमा , का उपयोग किया जाता है।

उदाहरण:

fn main() {
    add(5, 3);  // दो पैरामीटर्स पास किए गए हैं
}

fn add(a: i32, b: i32) {
    println!("योगफल है: {}", a + b);
}

इस उदाहरण में, add फ़ंक्शन को दो integers, a और b पास किए जाते हैं, और फ़ंक्शन उनका योग प्रदर्शित करता है।

रिटर्न वैल्यू (Return Values)

फ़ंक्शंस न केवल पैरामीटर्स को स्वीकार कर सकते हैं, बल्कि परिणामस्वरूप वैल्यू भी वापस कर सकते हैं। रिटर्न वैल्यू को फ़ंक्शन के सिग्नेचर में -> के बाद डेटा प्रकार के रूप में परिभाषित किया जाता है। फ़ंक्शन के अंदर आखिरी expression ही रिटर्न होता है। ध्यान दें कि आखिरी expression में सेमी-कोलन (;) नहीं होना चाहिए।

सिंटैक्स (Syntax):

fn function_name(parameters) -> return_type {
    // कोड
    return_value  // रिटर्न की जाने वाली वैल्यू
}

उदाहरण:

fn main() {
    let result = add(5, 3);
    println!("योगफल है: {}", result);
}

fn add(a: i32, b: i32) -> i32 {
    a + b  // यहाँ आखिरी expression रिटर्न होगा
}

इस उदाहरण में, add फ़ंक्शन दो integers को जोड़ता है और परिणामस्वरूप integer वैल्यू को रिटर्न करता है। यह वैल्यू result नाम के वैरिएबल में स्टोर की जाती है और प्रिंट की जाती है।

रिटर्न स्टेटमेंट (Return Statement)

हालांकि Rust में आखिरी expression को स्वतः रिटर्न किया जाता है, फिर भी आप चाहें तो return कीवर्ड का उपयोग करके किसी भी समय फ़ंक्शन से वैल्यू रिटर्न कर सकते हैं।

उदाहरण:

fn main() {
    let result = add(5, 3);
    println!("योगफल है: {}", result);
}

fn add(a: i32, b: i32) -> i32 {
    return a + b;  // रिटर्न कीवर्ड का उपयोग
}

इस उदाहरण में, हमने return कीवर्ड का उपयोग किया है, जो वैल्यू को तुरंत वापस कर देता है।

पैरामीटर्स और रिटर्न वैल्यू के साथ फ़ंक्शंस का उपयोग (Using Functions with Parameters and Return Values)

पैरामीटर्स और रिटर्न वैल्यू के साथ फ़ंक्शंस कोड को अधिक शक्तिशाली और लचीला बनाते हैं। आप एक ही फ़ंक्शन को विभिन्न इनपुट्स के साथ कॉल कर सकते हैं और आवश्यकतानुसार परिणाम प्राप्त कर सकते हैं।

उदाहरण:

fn main() {
    let result = multiply(5, 3);
    println!("गुणनफल है: {}", result);
}

fn multiply(a: i32, b: i32) -> i32 {
    a * b
}

इस उदाहरण में, हमने दो integers को multiply फ़ंक्शन में पास किया, और फ़ंक्शन ने उनका गुणनफल रिटर्न किया।

Expressions और Statements (Difference Between Expressions and Statements in Rust)

Rust में expressions और statements दोनों ही कोड के महत्वपूर्ण हिस्से हैं। प्रोग्रामिंग के दौरान, यह समझना ज़रूरी है कि कौन सा कोड expression है और कौन सा statement, क्योंकि यह Rust के कार्य करने के तरीके को प्रभावित करता है। इस खंड में हम विस्तार से जानेंगे कि Rust में expressions और statements क्या होते हैं और इन दोनों में क्या अंतर है।

Statements (स्टेटमेंट्स)

Statements वे निर्देश (instructions) होते हैं जो कुछ क्रिया (action) करते हैं लेकिन किसी वैल्यू को रिटर्न नहीं करते। दूसरे शब्दों में, वे कोड के एक हिस्से को निष्पादित (execute) करते हैं, लेकिन कोई परिणाम वापस नहीं देते। Statements कोड की संरचना में निर्देशात्मक भूमिका निभाते हैं।

सिंटैक्स (Syntax):

Rust में statements आमतौर पर वैरिएबल डिक्लेरेशन (variable declaration) या फ़ंक्शन कॉल्स होती हैं, और वे हमेशा ; से समाप्त होती हैं।

उदाहरण:

fn main() {
    let x = 5;  // यह एक statement है
    let y = 6;  // यह भी एक statement है
}

ऊपर दिए गए उदाहरण में, let x = 5; और let y = 6; दोनों statements हैं। ये statements वैरिएबल्स को डिक्लेयर और असाइन करते हैं, लेकिन वे किसी वैल्यू को रिटर्न नहीं करते।

Expressions (एक्सप्रेशन्स)

Expressions वे कोड होते हैं जो एक वैल्यू को रिटर्न करते हैं। Rust में लगभग हर चीज़ एक expression होती है, जिसका मतलब है कि यह एक वैल्यू को प्रोसेस करती है और परिणामस्वरूप एक वैल्यू प्रदान करती है। Expressions के बाद सेमी-कोलन (;) नहीं होता, क्योंकि सेमी-कोलन उन्हें statement बना देता है।

सिंटैक्स (Syntax):

Expressions की एक विशेषता यह है कि वे एक वैल्यू रिटर्न करते हैं, और उन्हें अन्य कोड के हिस्से में उपयोग किया जा सकता है।

उदाहरण:

fn main() {
    let x = 5;  // यह एक statement है
    let y = {
        let z = 3;
        z + 1  // यह एक expression है
    };

    println!("y का मान है: {}", y);
}

यहाँ, { z + 1 } एक expression है, और यह एक वैल्यू (4) रिटर्न करता है। इस expression के परिणामस्वरूप y को वैल्यू मिलती है। Expression के बाद कोई सेमी-कोलन नहीं है, क्योंकि अगर सेमी-कोलन होता, तो यह statement बन जाता और कोई वैल्यू रिटर्न नहीं होती।

Statements और Expressions के बीच अंतर (Difference Between Statements and Expressions)

1. Statements:
   • Statements कुछ क्रिया करते हैं, लेकिन वैल्यू रिटर्न नहीं करते।
   • वे कोड के निर्देश होते हैं और अक्सर ; से समाप्त होते हैं।
   • उदाहरण: let x = 5;, फ़ंक्शन कॉल्स।
2. Expressions:
   • Expressions वैल्यू को प्रोसेस करते हैं और परिणामस्वरूप एक वैल्यू रिटर्न करते हैं।
   • Expressions कोड के हिस्से के रूप में वैल्यू उत्पन्न करते हैं।
   • उदाहरण: x + 1, ब्लॉक { z + 1 }।

Example with Both Statements and Expressions:

fn main() {
    let x = 5;  // statement
    let y = {
        let z = 2;  // statement
        z + 1  // expression, इसका परिणाम y को असाइन होगा
    };

    println!("y का मान है: {}", y);
}

इस कोड में, let x = 5; और let z = 2; दोनों statements हैं। वहीं, { z + 1 } एक expression है, जो z + 1 की वैल्यू (यानि 3) को रिटर्न करता है और इसे y में असाइन किया जाता है।

सेमी-कोलन और Expressions (Semicolon and Expressions)

यदि आप एक expression के अंत में सेमी-कोलन जोड़ देते हैं, तो वह expression एक statement बन जाता है और वैल्यू रिटर्न करना बंद कर देता है। इसे बेहतर तरीके से समझने के लिए, निम्नलिखित उदाहरण देखें:

उदाहरण:

fn main() {
    let x = {
        let y = 3;
        y + 1  // यह expression वैल्यू रिटर्न करेगा
    };

    println!("x का मान है: {}", x);
}

ऊपर दिए गए उदाहरण में, { y + 1 } एक expression है जो x को वैल्यू (4) रिटर्न करता है। अब इसे सेमी-कोलन के साथ देखें:

fn main() {
    let x = {
        let y = 3;
        y + 1;  // सेमी-कोलन की वजह से यह अब expression नहीं रहा
    };

    println!("x का मान है: {:?}", x);
}

इस उदाहरण में, y + 1; के बाद सेमी-कोलन होने की वजह से यह एक statement बन गया है, और अब यह किसी वैल्यू को रिटर्न नहीं करता। परिणामस्वरूप, x को () (unit type) वैल्यू मिलती है, जो Rust में “कुछ भी नहीं” का प्रतिनिधित्व करता है।