Rust में Vec पर इंडेक्स के साथ Iteration: तुलना करने के 4 तरीके

शुरुआती लोगों के लिए ऑनलाइन Python प्रशिक्षक

Python आसानी से सीखें बिना सिद्धांत के बोझ के। स्वचालित जांच के साथ व्यावहारिक कार्य हल करें और ब्राउज़र में सीधे कोड लिखें।

पाठ्यक्रम शुरू करें

Rust में Vec को इंडेक्स के साथ Iterate करना: शुरुआत से विशेषज्ञ तक

\n\n

कल्पना करें: आप Rust में कोड लिख रहे हैं और आपको वेक्टर के तत्वों पर जाना है, लेकिन साथ ही न केवल मान बल्कि उसकी स्थिति भी जाननी है। यह एक सरल कार्य लगता है, लेकिन शुरुआती लोगों के लिए यह अक्सर अटकने का कारण बनता है। Python की तरह for i in range(len(vec)) कहाँ है? और अगर मैं तत्वों को बदलना चाहता हूँ? और कौन सा तेज़ है?

\n\n

इस लेख में, हम Rust में Vec को इंडेक्स के साथ Iterate करने के सभी लोकप्रिय तरीकों पर चर्चा करेंगे, उनके प्रदर्शन, पठनीयता और सुरक्षा की तुलना करेंगे। आप जानेंगे कि 2024 में कौन सी विधि चुननी है और क्यों enumerate हमेशा सबसे अच्छा समाधान नहीं है।

\n\n

यह क्यों महत्वपूर्ण है?

Rust में एकमात्र सही तरीके के रूप में क्लासिक for i in 0..vec.len() मौजूद नहीं है। भाषा कई प्रतिमान प्रदान करती है: कार्यात्मक iterators से लेकर निम्न-स्तरीय लूप तक। उनके बीच के अंतर को समझना कुशल और मुहावरेदार कोड लिखने की कुंजी है। यह विशेष रूप से वेक्टर के साथ काम करते समय महत्वपूर्ण है, जहाँ इंडेक्स की आवश्यकता पड़ोसी तत्वों को संशोधित करने या एल्गोरिदम में स्थिति को ट्रैक करने के लिए हो सकती है।

\n\n

विधि 1: क्लासिक — `enumerate`

सबसे सामान्य और अनुशंसित तरीका। enumerate विधि iterator को लपेटती है, प्रत्येक तत्व में उसका इंडेक्स जोड़ती है:

\n\n

let vec = vec!["a", "b", "c", "d"];\nfor (index, value) in vec.iter().enumerate() {\n    println!("स्थिति {}: {}", index, value);\n}

\n\n

लाभ:

मुहावरेदार और पढ़ने में आसान
सुरक्षित — सीमा से बाहर जाने का कोई जोखिम नहीं
केवल Vec ही नहीं, बल्कि किसी भी iterator के साथ काम करता है

नुकसान: सीधे वेक्टर के तत्वों को नहीं बदल सकते (iter_mut() की आवश्यकता है)।

\n\n

विधि 2: इंडेक्स द्वारा — `0..vec.len()`

C++ या Python से सभी को परिचित दृष्टिकोण। इंडेक्स की श्रेणी का उपयोग करें:

\n\n

let mut vec = vec![10, 20, 30, 40];\nfor i in 0..vec.len() {\n    vec[i] += i; // इंडेक्स द्वारा तत्व बदलें\n    println!("vec[{}] = {}", i, vec[i]);\n}

\n\n

लाभ:

इंडेक्स और तत्व पर पूर्ण नियंत्रण
vec[i] के माध्यम से तत्वों को बदल सकते हैं
शुरुआती लोगों के लिए सहज रूप से समझ में आता है

नुकसान: Iterators की तुलना में धीमा (अतिरिक्त सीमा जाँच)। Rust समुदाय इसे "गैर-मुहावरेदार" मानता है।

\n\n

विधि 3: काउंटर के साथ `while`

सबसे "मैन्युअल" तरीका, जो आपको पुराने कोड या ऑप्टिमाइज़ेशन में मिलेगा:

\n\n

let vec = vec![1.0, 2.0, 3.0];\nlet mut i = 0;\nwhile i < vec.len() {\n    println!("तत्व {}: {}", i, vec[i]);\n    i += 1;\n}

\n\n

लाभ: अधिकतम लचीलापन (इंडेक्स पर कूद सकते हैं, चरण बदल सकते हैं)।

नुकसान: शर्त में गलती करना आसान। बिना किसी ठोस कारण के अनुशंसित नहीं।

\n\n

विधि 4: श्रेणी के साथ `zip`

कार्यात्मक दृष्टिकोण, जब दो वेक्टर को इंडेक्स के साथ समानांतर रूप से Iterate करना हो:

\n\n

let names = vec!["Alice", "Bob", "Charlie"];\nlet scores = vec![95, 87, 92];\n\nfor (i, (name, score)) in (0..).zip(names.iter()).zip(scores.iter()) {\n    println!("{}: {} ने {} अंक प्राप्त किए", i, name, score);\n}

\n\n

लाभ: समानांतर iteration के लिए शक्तिशाली। अनंत श्रेणी 0.. स्वचालित रूप से कट जाती है।

नुकसान: पढ़ने में जटिल हो सकता है। सरल कार्यों के लिए अतिरिक्त।

\n\n