ब्याज दिलचस्प है

लूप एक कंट्रोल स्ट्रक्चर है जो किसी दी गई शर्त के आधार पर कोड को बार-बार चलाने देता है।

while लूप

while लूप एक कंट्रोल स्ट्रक्चर है जो किसी दी गई शर्त के आधार पर कोड को बार-बार चलाने देता है। while लूप के अंदर का कोड तब तक चलता रहता है जब तक शर्त ट्रुथी होती है। while लूप अक्सर तब इस्तेमाल किए जाते हैं जब इटरेशन की संख्या पहले से पता न हो। इन्हें हर उस जगह इस्तेमाल किया जा सकता है जहाँ लूप की ज़रूरत हो।

लूप के अंदर का कोड चलने से पहले शर्त की जाँच होती है। इसका मतलब है कि अगर शर्त गलत है, तो लूप के अंदर का कोड कभी नहीं चलेगा।

i = 0
while i < 3
  puts i
  i += 1
end

# Output:
# 0
# 1
# 2

जब आपको किसी स्ट्रिंग पर इटरेशन करना हो, तो आप स्ट्रिंग की लंबाई पर लूप चला सकते हैं।

str = "Hello"
i = 0
while i < str.size
  puts str[i]
  i += 1
end

# Output:
# H
# e
# l
# l
# o

until लूप

until लूप वैसे ही काम करते हैं जैसे while लूप, बस फर्क यह है कि लूप के अंदर का कोड तब तक चलता रहता है जब तक शर्त ट्रुथी न हो जाए। यह वही अंतर है जो if और unless के बीच होता है।

i = 0
until i == 3
  puts i
  i += 1
end

अनंत लूप

while लूप के साथ एक आम गलती है अनंत लूप में फँस जाना, जो कभी खत्म नहीं होता। अनंत लूप तब होता है जब कोई शर्त कभी ट्रुथी या फॉल्सी नहीं होती। ऐसा अक्सर प्रोग्रामर की गलती से होता है, जैसे लूप वेरिएबल को बढ़ाना भूल जाना। लेकिन कभी-कभी प्रोग्राम का लॉजिक लिखने का सबसे साफ तरीका अनंत लूप ही होता है। या फिर हमेशा के लिए लूप चलाना ज़रूरी होता है। उदाहरण के लिए, एक HTTP सर्वर किसी आने वाले कनेक्शन का इंतज़ार करता है, उसे संभालता है, और फिर अगले कनेक्शन का इंतज़ार करता है।

break

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

i = 0
while i <= 3
  puts i
  i += 1
  if i == 2
    break
  end
end

# Output:
# 0
# 1

next

next कीवर्ड का इस्तेमाल लूप के अगले इटरेशन पर जाने के लिए किया जा सकता है। यह तब काम आता है जब आप लूप के कुछ खास इटरेशन छोड़ना चाहते हों।

i = 0
while i <= 3
  i += 1
  if i == 2
    next
  end
  puts i
end

# Output:
# 1
# 3

लूप के दौरान टाइप

लूप के दौरान वेरिएबल का टाइप बदल सकता है। नीचे दिए उदाहरण में a का टाइप Int32 | String है, क्योंकि लूप के पहले हिस्से में यह Int32 या String हो सकता है। वेरिएबल a लूप के पहले हिस्से में ही Int32 | String टाइप रखता है, क्योंकि लूप शुरू होते समय उसमें Int32 रहता है और दूसरे इटरेशन में String। इस बहु-टाइप सिस्टम को आगे विस्तार से समझाया जाएगा। लेकिन चूँकि हमें पक्का है कि लूप के दूसरे हिस्से में सिर्फ String रहेगा, इसलिए लूप के दूसरे हिस्से में a का टाइप String है। रनटाइम पर यह कभी एक साथ Int32 और String नहीं रखेगा।

i = 0
a = 4
while i < 3
  p typeof(a)
  # => Int32 | String
  a = "4"
  p typeof(a)
  # => String
  i += 1
end

Crystal में मेथड का आखिरी एक्सप्रेशन उसकी वैल्यू लौटाता है। लेकिन कभी-कभी आपको आखिरी एक्सप्रेशन से पहले ही कोई वैल्यू लौटानी होती है। इसके लिए आप return कीवर्ड का इस्तेमाल कर सकते हैं, जो उसके बाद वाले एक्सप्रेशन की वैल्यू लौटाता है। return कीवर्ड के बाद लिखा कोड नहीं चलेगा।

def speed_limit(road_number)
    if road_number == 1
        return 50
        puts "This will not be executed"
    elsif road_number == 2
        return 80
        puts "This will not be executed"
    end
    100
end

p speed_limit(1) # => 50
p speed_limit(2) # => 80
p speed_limit(3) # => 100