Rust में दूसरी फ़ाइल से मॉड्यूल कैसे कनेक्ट करें: शुरुआती लोगों के लिए गाइड

Rust में दूसरी फ़ाइल से मॉड्यूल कैसे शामिल करें: शुरुआती से आत्मविश्वासी उपयोगकर्ता तक

क्या आपने कभी Rust में कोड लिखा है और अचानक महसूस किया है कि आपका main.rs 500 लाइनों का एक विशाल राक्षस बन गया है? परिचित लगता है? या हो सकता है कि आप अभी Rust सीखना शुरू कर रहे हों और यह समझना चाहते हों कि कोड को कई फ़ाइलों में विभाजित करके सही तरीके से कैसे व्यवस्थित किया जाए। सवाल "How can I include a module from another file from the same project?" Stack Overflow पर सबसे लोकप्रिय प्रश्नों में से एक है, और यह व्यर्थ नहीं है। Rust की मॉड्यूलर प्रणाली एक साथ शक्तिशाली और... शुरुआती लोगों के लिए थोड़ी अस्पष्ट है।

इस लेख में हम A से Z तक सब कुछ समझेंगे: मॉड्यूल कैसे बनाएं, इसे कैसे कनेक्ट करें, क्या नुकसान हैं और गलतियों से कैसे बचें। चलिए शुरू करते हैं!

Rust में मॉड्यूल सिर्फ "include" क्यों नहीं हैं?

यदि आप Python या JavaScript से आए हैं, तो आप import या require के आदी हैं। Rust में सब कुछ थोड़ा अलग है। यहाँ कोई जादुई "फ़ाइल उठाओ और उपयोग करो" नहीं है। इसके बजाय, Rust घोषणात्मक मॉड्यूल प्रणाली का उपयोग करता है। आपको कंपाइलर को स्पष्ट रूप से बताना होगा: "अरे, यह फ़ाइल मेरे प्रोजेक्ट का हिस्सा है, और इसका नाम यह है।"

याद रखने वाला मुख्य नियम: प्रत्येक फ़ाइल एक मॉड्यूल है, लेकिन प्रत्येक मॉड्यूल एक फ़ाइल नहीं है। यह एक पहेली की तरह लगता है, है ना? अब हम समझेंगे।

प्रोजेक्ट संरचना: कहाँ से शुरू करें

मान लीजिए कि आपके पास इस संरचना वाला एक प्रोजेक्ट है:

my_project/\n├── Cargo.toml\n├── src/\n│   ├── main.rs\n│   ├── greetings.rs\n│   └── utils/\n│       ├── mod.rs\n│       └── helpers.rs

यहाँ greetings.rs एक सरल मॉड्यूल है, और utils/ मॉड्यूल वाला एक फ़ोल्डर है। आइए इन्हें कनेक्ट करना सीखें।

तरीका 1: सरल फ़ाइल-मॉड्यूल कनेक्ट करना

सबसे बुनियादी मामला। आपके पास फ़ंक्शन के साथ greetings.rs है:

// greetings.rs\npub fn say_hello() {\n    println!("ग्रीटिंग्स मॉड्यूल से नमस्ते!");\n}

main.rs में इस मॉड्यूल का उपयोग करने के लिए, दो काम करने होंगे:

\n
1. मॉड्यूल घोषित करें कीवर्ड mod के साथ
\n
2. आवश्यक तत्वों को इम्पोर्ट करें use के साथ
\n

// main.rs\nmod greetings; // मॉड्यूल घोषित करें\n\nuse greetings::say_hello; // फ़ंक्शन इम्पोर्ट करें\n\nfn main() {\n    say_hello(); // उपयोग करें\n}

बस इतना ही! Rust स्वचालित रूप से उसी फ़ोल्डर में greetings.rs फ़ाइल ढूंढता है जहाँ main.rs है। यदि फ़ाइल मिल जाती है, तो मॉड्यूल कनेक्ट हो जाता है।

महत्वपूर्ण: फ़ंक्शन say_hello को pub के रूप में चिह्नित किया गया है। यदि pub भूल जाते हैं, तो कंपाइलर कहेगा कि फ़ंक्शन निजी है और बाहर से उपलब्ध नहीं है। यह शुरुआती लोगों की सबसे आम गलतियों में से एक है।

तरीका 2: फ़ोल्डर में मॉड्यूल (mod.rs या lib.rs)

जब आपका प्रोजेक्ट बढ़ता है, तो मॉड्यूल को फ़ोल्डरों में समूहित करना सुविधाजनक होता है। इसके लिए फ़ोल्डर के अंदर mod.rs फ़ाइल का उपयोग किया जाता है। यह मॉड्यूल में "प्रवेश बिंदु" के रूप में कार्य करता है।

एक फ़ोल्डर utils/ बनाएं और उसके अंदर mod.rs:

// utils/mod.rs\npub mod helpers; // नेस्टेड मॉड्यूल घोषित करें

अब helpers.rs बनाएं:

// utils/helpers.rs\npub fn do_something() {\n    println!("कुछ उपयोगी कर रहे हैं");\n}

main.rs में इस तरह कनेक्ट करें:

// main.rs\nmod utils; // मॉड्यूल utils घोषित करें (utils/mod.rs ढूंढता है)\n\nuse utils::helpers::do_something;\n\nfn main() {\n    do_something();\n}

ध्यान दें: mod utils; Rust को utils/mod.rs या utils.rs खोजने के लिए कहता है। यदि mod.rs मिलता है - बढ़िया, यदि utils.rs मिलता है - तो भी काम करेगा। लेकिन दोनों फ़ाइलें एक साथ नहीं हो सकतीं - कंपाइलर भ्रमित हो जाएगा।

तरीका 3: आधुनिक दृष्टिकोण (Rust 201