लूप में

लूप के बारे में

मूल रूप से लूप दो तरह के होते हैं:

1. किसी शर्त के पूरा होने तक लूप चलाना।
2. किसी कलेक्शन के एलिमेंट पर लूप चलाना।

दोनों ही Julia में संभव हैं, हालाँकि दूसरा तरीका ज़्यादा आम हो सकता है।

while लूप

ऐसी समस्याओं के लिए जिनका कोई तय अंत नहीं होता और जिनमें पहले से पता नहीं होता कि लूप कितनी बार चलेगा, Julia में while लूप होता है।

इसका मूल रूप काफी आसान है:

while condition
    do_something()
end

इस स्थिति में प्रोग्राम तब तक लूप में चलता रहता है जब तक condition true न रहे।

लूप से जल्दी बाहर निकलने के दो तरीके उपलब्ध हैं:

• break लूप को खत्म कर देता है, और उसके बाद कोड लूप के end के बाद वाली अगली लाइन से चलना शुरू करता है।
• return x मौजूदा फंक्शन को चलना रोक देता है और रिटर्न वैल्यू x को कॉल करने वाले को लौटा देता है।

इन दोनों विकल्पों के रहते, कभी-कभी while true ... end से एक "अनंत" लूप बनाना सुविधाजनक हो सकता है। फिर लूप के अंदर का कोड में कोई रुकने वाली शर्त मिलने पर break या return चलाया जा सकता है।

किसी कलेक्शन पर लूप चलाना

सबसे आसान उदाहरण किसी रेंज पर लूप चलाना है।

अगर हमें कोई काम 10 बार करना है:

for n in 1:10
    do_something(n)
end

अगर मौजूदा इटरेशन कोई शर्त पूरी नहीं करता, तो continue की मदद से सीधे अगले इटरेशन पर पहुँचा जा सकता है:

for n in 1:10
    if is_useless(n)
        continue
    end
    
    # we decided this iteration could be useful
    do_something_slow(n)
end

छोटे रूप में, if ब्लॉक की जगह is_useless(n) && continue लिखा जा सकता है।

बहुत से दूसरे कलेक्शन टाइप पर भी लूप चलाया जा सकता है: किसी ऐरे के एलिमेंट, किसी स्ट्रिंग के अक्षर, किसी डिक्शनरी की कुंजियाँ...

शर्त यह है कि कलेक्शन iterable होना चाहिए। इसे आगे किसी कॉन्सेप्ट में और विस्तार से समझाया जाएगा, लेकिन मूल बात यह है कि कलेक्शन के पास पूछने पर अगला आइटम देने का तरीका होना चाहिए, और यह बताने का तरीका भी कि कलेक्शन खत्म हो गया है और अब कोई आइटम नहीं बचा।

अब तक के उदाहरण रेंज 1:10 पर लूप चलाते हैं, जहाँ वैल्यू ही लूप का इंडेक्स भी है।

आम तौर पर सिर्फ वैल्यू ही नहीं, इंडेक्स की भी ज़रूरत पड़ सकती है। इसके लिए eachindex() फंक्शन इस्तेमाल किया जाता है, जैसे for i in eachindex(my_array) ... end.

कॉम्प्रिहेंशन

Julia में साफ-साफ लिखे गए लूप कई पुरानी भाषाओं की तुलना में कम आम हैं, क्योंकि यहाँ कई और संक्षिप्त तरीके मौजूद हैं।

एक खास तौर पर आम स्थिति तब आती है जब हमें किसी दूसरे कलेक्शन (वेक्टर, स्ट्रिंग, सेट ... कई और भी हो सकते हैं) के एलिमेंट से एक नया वेक्टर बनाना होता है।

जिन्हें Python में लिस्ट कॉम्प्रिहेंशन पसंद हैं, उन्हें यह जानकर खुशी होगी कि Julia में भी इसी तरह का सिंटैक्स इस्तेमाल किया जा सकता है।

इसका मूल विचार यह है कि एक वेक्टर के अंदर बहुत ही छोटा लूप लिखा जाता है।

सबसे आसान रूप result = [f(x) for x in some_collection] जैसा होता है।

पारंपरिक लूप से यह ऐसे लिखा जा सकता है:

result = []
for x in some_collection
    push!(result, f(x))
end

चाहें तो अंत में एक शर्त भी जोड़ी जा सकती है, ताकि कलेक्शन के सिर्फ मेल खाने वाले एलिमेंट चुने जाएँ:

# multiples of 3
julia> [n^2 for n in 1:10 if n%3 == 0]
3-element Vector{Int64}:
  9
 36
 81

# letters beyond 'h' in the alphabet
julia> [uppercase(c) for c in "Julia" if c > 'h']
3-element Vector{Char}:
 'U': ASCII/Unicode U+0055 (category Lu: Letter, uppercase)
 'L': ASCII/Unicode U+004C (category Lu: Letter, uppercase)
 'I': ASCII/Unicode U+0049 (category Lu: Letter, uppercase)

यह सिंटैक्स Python जैसा मिलता-जुलता है, लेकिन बिल्कुल एक जैसा नहीं है। कई वेरिएबल और/या बहु-आयामी ऐरे के मामले में कुछ अंतर हैं, इसलिए इस विषय को आगे किसी कॉन्सेप्ट में और विस्तार से समझाया जाएगा।

दूसरे विकल्प

एक आधुनिक और ज़्यादातर फंक्शनल भाषा होने के नाते Julia में (बेशक) कलेक्शन पर काम करने के कई तरीके हैं, सिर्फ साफ-साफ लिखा लूप या कॉम्प्रिहेंशन में छोटा किया गया लूप ही नहीं।

आगे के कॉन्सेप्ट में ब्रॉडकास्टिंग और हायर-ऑर्डर फंक्शन जैसे विकल्पों पर चर्चा होगी।