Ruby Language
बहाव को काबू करें

यदि, एल्सिफ, और अंत

रूबी की उम्मीद प्रदान करता है if और else तर्क शाखाओं में, इन्हें समाप्त के लिए भाव end कीवर्ड:

# Simulate flipping a coin
result = [:heads, :tails].sample

if result == :heads
  puts 'The coin-toss came up "heads"'
else
  puts 'The coin-toss came up "tails"'
end

रूबी में, if कथन ऐसे भाव हैं जो किसी मूल्य का मूल्यांकन करते हैं, और परिणाम एक चर को सौंपा जा सकता है:

status = if age < 18
           :minor
         else
           :adult
         end

रूबी सी-स्टाइल टर्नरी ऑपरेटर भी प्रदान करता है ( विवरण के लिए यहां देखें ) जिसे निम्न के रूप में व्यक्त किया जा सकता है:

some_statement ? if_true : if_false  

इसका अर्थ है कि यदि और-का उपयोग करके उपरोक्त उदाहरण भी लिखा जा सकता है

status = age < 18 ? :minor : :adult

इसके अतिरिक्त, रूबी elsif कीवर्ड प्रदान करता है, जो अतिरिक्त elsif तर्क को सक्षम करने के लिए एक अभिव्यक्ति स्वीकार करता है:

label = if shirt_size == :s
          'small'
        elsif shirt_size == :m
          'medium'
        elsif shirt_size == :l
          'large'
        else
          'unknown size'
        end

एक में स्थिति से कोई भी तो if / elsif श्रृंखला सत्य हैं, और कोई है else खंड, शून्य करने के लिए तो अभिव्यक्ति मूल्यांकन करता है। यह स्ट्रिंग nil.to_s अंदर उपयोगी हो सकता है, क्योंकि nil.to_s खाली स्ट्रिंग है:

"user#{'s' if @users.size != 1}"

सत्य और मिथ्या मूल्य

रूबी में, वहाँ वास्तव में दो मानों जो "falsy" माना जाता है कर रहे हैं, और जब एक के लिए एक शर्त के रूप में परीक्षण अवास्तविक लौटाते हैं if अभिव्यक्ति। वो हैं:

• nil
• बूलियन false

अन्य सभी मूल्यों को "सत्य" माना जाता है, जिनमें शामिल हैं:

• 0 - संख्यात्मक शून्य (पूर्णांक या अन्यथा)
• "" - खाली तार
• "\n" - केवल व्हाट्सएप युक्त स्ट्रिंग्स
• [] - खाली सरणियाँ
• {} - खाली हैश

उदाहरण के लिए, निम्न कोड लें:

def check_truthy(var_name, var)
  is_truthy = var ? "truthy" : "falsy"
  puts "#{var_name} is #{is_truthy}"
end

check_truthy("false", false)
check_truthy("nil", nil)
check_truthy("0", 0)
check_truthy("empty string", "")
check_truthy("\\n", "\n")
check_truthy("empty array", [])
check_truthy("empty hash", {})

उत्पादन होगा:

false is falsy
nil is falsy
0 is truthy
empty string is truthy
\n is truthy
empty array is truthy
empty hash is truthy

जब तक,

एक while पाश ब्लॉक निष्पादित करता है, जबकि दिए गए स्थिति उत्पन्न होने पर:

i = 0
while i < 5
  puts "Iteration ##{i}"
  i +=1
end

until लूप ब्लॉक को निष्पादित until करता है until कि स्थिति झूठी नहीं होती है:

i = 0
until i == 5
  puts "Iteration ##{i}"
  i +=1
end

अगर / जब तक इनलाइन न हो

एक सामान्य पैटर्न इनलाइन या ट्रेलिंग का उपयोग करना है, if या unless :

puts "x is less than 5" if x < 5

यह एक सशर्त संशोधक के रूप में जाना जाता है, और सरल गार्ड कोड और शुरुआती रिटर्न जोड़ने का एक आसान तरीका है:

def save_to_file(data, filename)
  raise "no filename given" if filename.empty?
  return false unless data.valid?

  File.write(filename, data)
end

इन संशोधकों में एक else खंड जोड़ना संभव नहीं है। जटिल कोड एक के लिए उपयोग करना चाहिए सामान्य - इसके अलावा यह आम तौर पर मुख्य तर्क अंदर सशर्त संशोधक का उपयोग करने की सलाह नहीं दी जाती है if , elsif , else के बजाय।

जब तक

एक सामान्य कथन है if !(some condition) ! रूबी unless बयान का विकल्प प्रस्तुत unless है।

संरचना बिल्कुल वैसा ही है जैसा कि if कथन है, तो स्थिति नकारात्मक है। इसके अलावा, unless बयान elsif समर्थन नहीं करता है, लेकिन यह else समर्थन करता else :

# Prints not inclusive
unless 'hellow'.include?('all')
  puts 'not inclusive'
end

केस का बयान

रूबी स्विच स्टेटमेंट के लिए case कीवर्ड का उपयोग करती है।

रूबी डॉक्स के अनुसार:

प्रकरण विवरण एक वैकल्पिक हालत है, जो करने के लिए एक बहस की स्थिति में है से मिलकर case , और शून्य या अधिक when खंड। पहली बार when क्लॉज कंडीशन से मेल खाता हो (या बूलियन सत्य का मूल्यांकन करने के लिए, यदि स्थिति अशक्त है) "जीत", और इसके कोड श्लोक को निष्पादित किया जाता है। केस स्टेटमेंट का मूल्य क्लॉज या nil when पर सफल का मूल्य है, यदि ऐसा कोई क्लॉज नहीं है।

एक केस स्टेटमेंट एक else क्लॉज के साथ समाप्त हो सकता है। प्रत्येक when एक बयान में कई उम्मीदवार मान हो सकते हैं, तो अल्पविराम द्वारा अलग किए जाते हैं।

उदाहरण:

case x
when 1,2,3
  puts "1, 2, or 3"
when 10
  puts "10"
else
  puts "Some other number"
end

छोटा संस्करण:

case x
when 1,2,3 then puts "1, 2, or 3"
when 10 then puts "10"
else puts "Some other number"
end

case क्लॉज का मान प्रत्येक के साथ मेल खाता है, when क्लॉज === विधि ( == नहीं) का उपयोग करते हुए। इसलिए इसका उपयोग विभिन्न प्रकार की वस्तुओं के साथ किया जा सकता है।

एक case स्टेटमेंट का उपयोग रेंज के साथ किया जा सकता है :

case 17
when 13..19
  puts "teenager"
end

रेगेक्स के साथ एक case स्टेटमेंट का उपयोग किया जा सकता है:

case "google"
when /oo/
  puts "word contains oo"
end

प्रोक या लैम्बडा के साथ case स्टेटमेंट का उपयोग किया जा सकता है:

case 44
when -> (n) { n.even? or n < 0 }
  puts "even or less than zero"
end

क्लास के साथ case स्टेटमेंट का उपयोग किया जा सकता है:

case x
when Integer
  puts "It's an integer"
when String
  puts "It's a string"
end

=== विधि को लागू करके आप अपनी खुद की मैच कक्षाएं बना सकते हैं:

class Empty
  def self.===(object)
    !object or "" == object
  end
end

case ""
when Empty
  puts "name was empty"
else
  puts "name is not empty"
end

किसी case स्टेटमेंट का उपयोग बिना मिलान के लिए किया जा सकता है:

case
when ENV['A'] == 'Y'
  puts 'A'
when ENV['B'] == 'Y'
  puts 'B'
else
  puts 'Neither A nor B'
end

एक case स्टेटमेंट का एक मूल्य होता है, इसलिए आप इसे विधि तर्क के रूप में या असाइनमेंट में उपयोग कर सकते हैं:

description = case 16
              when 13..19 then "teenager"
              else ""
              end

ब्रेक, नेक्स्ट, और रीडो के साथ लूप कंट्रोल

रूबी ब्लॉक के निष्पादन के प्रवाह को break , next और redo बयान के साथ नियंत्रित किया जा सकता है।

break

break स्टेटमेंट ब्लॉक से तुरंत बाहर निकल जाएगा। ब्लॉक के किसी भी शेष निर्देश को छोड़ दिया जाएगा, और पुनरावृत्ति समाप्त हो जाएगी:

actions = %w(run jump swim exit macarena)
index = 0

while index < actions.length
  action = actions[index]

  break if action == "exit"

  index += 1
  puts "Currently doing this action: #{action}"
end

# Currently doing this action: run
# Currently doing this action: jump
# Currently doing this action: swim

next

next बयान तुरंत ब्लॉक के शीर्ष पर वापस आ जाएगा, और अगले पुनरावृत्ति के साथ आगे बढ़ेगा। ब्लॉक में किसी भी शेष निर्देश को छोड़ दिया जाएगा:

actions = %w(run jump swim rest macarena)
index = 0

while index < actions.length
  action = actions[index]
  index += 1

  next if action == "rest"

  puts "Currently doing this action: #{action}"
end

# Currently doing this action: run
# Currently doing this action: jump
# Currently doing this action: swim
# Currently doing this action: macarena

redo

redo बयान तुरंत ब्लॉक के शीर्ष पर वापस, और एक ही यात्रा फिर से प्रयास करेगा। ब्लॉक में किसी भी शेष निर्देश को छोड़ दिया जाएगा:

actions = %w(run jump swim sleep macarena)
index = 0
repeat_count = 0

while index < actions.length
  action = actions[index]
  puts "Currently doing this action: #{action}"

  if action == "sleep"
    repeat_count += 1
    redo if repeat_count < 3
  end

  index += 1
end

# Currently doing this action: run
# Currently doing this action: jump
# Currently doing this action: swim
# Currently doing this action: sleep
# Currently doing this action: sleep
# Currently doing this action: sleep
# Currently doing this action: macarena

Enumerable यात्रा

लूप के अलावा, ये स्टेटमेंट Enumerable पुनरावृत्ति विधियों के साथ काम करते हैं, जैसे each और map :

[1, 2, 3].each do |item|
  next if item.even?
  puts "Item: #{item}"
end

# Item: 1
# Item: 3

परिणाम मानों को अवरुद्ध करें

break और next कथन दोनों में, एक मूल्य प्रदान किया जा सकता है, और इसका उपयोग ब्लॉक परिणाम मान के रूप में किया जाएगा:

even_value = for value in [1, 2, 3]
  break value if value.even?
end

puts "The first even value is: #{even_value}"

# The first even value is: 2

फेंक, पकड़

कई अन्य प्रोग्रामिंग भाषाओं के विपरीत, throw और catch कीवर्ड रूबी में अपवाद हैंडलिंग से संबंधित नहीं हैं।

रूबी में, throw और catch अन्य भाषाओं में लेबल की तरह एक सा काम करता है। उनका उपयोग नियंत्रण प्रवाह को बदलने के लिए किया जाता है, लेकिन "त्रुटि" की अवधारणा से संबंधित नहीं हैं जैसे अपवाद हैं।

catch(:out) do
  catch(:nested) do
    puts "nested"
  end

  puts "before"
  throw :out
  puts "will not be executed"
end
puts "after"
# prints "nested", "before", "after"

तर्क बयानों के साथ नियंत्रण प्रवाह

हालांकि यह प्रतिवादपूर्ण लग सकता है, आप यह निर्धारित करने के लिए तार्किक संचालकों का उपयोग कर सकते हैं कि कोई कथन चलाया गया है या नहीं। उदाहरण के लिए:

File.exist?(filename) or STDERR.puts "#{filename} does not exist!"

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

एक सामान्य उपयोग डिफ़ॉल्ट मान सेट करने के लिए है:

glass = glass or 'full' # Optimist! 

यदि यह पहले से सेट नहीं है, तो glass का मान 'पूर्ण' पर सेट होता है। अधिक संक्षेप में, आप का प्रतीक संस्करण का उपयोग कर सकते हैं or :

glass ||= 'empty' # Pessimist. 

दूसरा कथन केवल तभी चलाना संभव है, जब पहला गलत हो:

File.exist?(filename) and puts "#{filename} found!"

फिर से, and आलसी है तो यह केवल दूसरे बयान को निष्पादित करेगा यदि आवश्यक हो तो एक मूल्य पर पहुंचें।

or ऑपरेटर की तुलना में कम पूर्वता है and । इसी तरह, || की तुलना में कम वरीयता है && । शब्द रूपों की तुलना में प्रतीक रूपों में उच्चता होती है। यह जानना आसान है कि आप इस तकनीक को कब असाइन करना चाहते हैं:

a = 1 and b = 2
#=> a==1
#=> b==2

a = 1 && b = 2; puts a, b
#=> a==2
#=> b==2

ध्यान दें कि रूबी स्टाइल गाइड सिफारिश करती है :

and और or कीवर्ड पर प्रतिबंध लगा दिया गया है। न्यूनतम जोड़ा पठनीयता सूक्ष्म कीड़े को पेश करने की उच्च संभावना के लायक नहीं है। बूलियन अभिव्यक्तियों के लिए, हमेशा && और || बजाय। प्रवाह नियंत्रण के लिए, if और unless उपयोग करें; && और || स्वीकार्य भी हैं लेकिन कम स्पष्ट हैं।

शुरू, अंत

begin ब्लॉक एक नियंत्रण संरचना है जो कई बयानों को एक साथ समूहित करता है।

begin
  a = 7
  b = 6
  a * b
end

एक begin ब्लॉक में अंतिम विवरण का मान लौटाया जाएगा। निम्नलिखित उदाहरण 3 वापस आएगा।

begin
  1
  2
  3
end

begin ब्लॉक ||= संचालक के उपयोग से सशर्त असाइनमेंट के लिए उपयोगी है, जहां परिणाम वापस करने के लिए कई बयानों की आवश्यकता हो सकती है।

circumference ||=
  begin
    radius = 7
    tau = Math::PI * 2
    tau * radius
  end

इसे प्रोग्राम ब्लॉक के अधिक नियंत्रण प्रदान करने के लिए अन्य ब्लॉक संरचनाओं जैसे कि rescue , ensure , while , if , unless , आदि के साथ जोड़ा जा सकता है।

Begin ब्लॉक कोड ब्लॉक नहीं हैं, जैसे { ... } या do ... end ; वे कार्यों के लिए पारित नहीं किया जा सकता है।

वापसी बनाम अगला: एक ब्लॉक में गैर-स्थानीय वापसी

इस टूटी हुई स्निपेट पर विचार करें:

def foo
  bar = [1, 2, 3, 4].map do |x|
    return 0 if x.even?
    x
  end
  puts 'baz'
  bar
end
foo # => 0

एक उम्मीद कर सकते हैं return के लिए एक मूल्य की उपज के लिए map ब्लॉक परिणामों की की सरणी। तो foo का वापसी मूल्य [1, 0, 3, 0] । इसके बजाय, return विधि से एक मान देता है foo । ध्यान दें कि baz प्रिंट नहीं है, जिसका अर्थ है कि निष्पादन कभी भी उस रेखा तक नहीं पहुंचा है।

एक मूल्य के साथ next चाल है। यह ब्लॉक-स्तरीय return रूप में कार्य करता है।

def foo
  bar = [1, 2, 3, 4].map do |x|
    next 0 if x.even?
    x
  end
  puts 'baz'
  bar
end
foo # baz
    # => [1, 0, 3, 0]

return की अनुपस्थिति में, ब्लॉक द्वारा लौटाया गया मान उसकी अंतिम अभिव्यक्ति का मूल्य है।

या-समान / सशर्त असाइनमेंट ऑपरेटर (= =)

रूबी के पास एक या-बराबर ऑपरेटर है जो किसी वैरिएबल को मान असाइन करने की अनुमति देता है यदि और केवल तभी वैरिएबल या तो nil या false मूल्यांकन करता है।

 ||= # this is the operator that achieves this. 

इस ऑपरेटर के साथ डबल पाइप का प्रतिनिधित्व करता है या बराबर होता है जो किसी मान के असाइन करने का प्रतिनिधित्व करता है। आप सोच सकते हैं कि यह कुछ इस तरह का प्रतिनिधित्व करता है:

 x = x || y

यह उपरोक्त उदाहरण सही नहीं है। या-बराबर ऑपरेटर वास्तव में इसका प्रतिनिधित्व करता है:

 x || x = y

यदि x nil या false मूल्यांकन करता है तो x को y का मान दिया जाता है, और अन्यथा अपरिवर्तित छोड़ दिया जाता है।

यहाँ या इसके बराबर के ऑपरेटर का व्यावहारिक उपयोग है। कल्पना कीजिए कि आपके पास अपने कोड का एक हिस्सा है जो उपयोगकर्ता को एक ईमेल भेजने की उम्मीद है। यदि इस कारण से इस उपयोगकर्ता के लिए कोई ईमेल नहीं है तो आप क्या करते हैं। आप कुछ इस तरह लिख सकते हैं:

 if user_email.nil?
    user_email = "[email protected]"
 end

या-समतुल्य ऑपरेटर के उपयोग से हम कोड के इस पूरे हिस्से को साफ, स्पष्ट नियंत्रण और कार्यक्षमता प्रदान कर सकते हैं।

 user_email ||= "[email protected]"

ऐसे मामलों में जहां false एक वैध मूल्य है, ध्यान रखना चाहिए कि इसे गलती से ओवरराइड न करें:

has_been_run = false
has_been_run ||= true
#=> true

has_been_run = false
has_been_run = true if has_been_run.nil?
#=> false

टर्नरी ऑपरेटर

रूबी के पास एक टर्नरी ऑपरेटर है ?: ( ?: ), जो दो स्थितियों में से एक को लौटाता है, जिसके आधार पर यदि कोई सत्यता के रूप में मूल्यांकन करता है:

conditional ? value_if_truthy : value_if_falsy

value = true
value ? "true" : "false"
#=> "true"

value = false
value ? "true" : "false"
#=> "false"

यह लेखन के समान है if a then b else c end , हालांकि टर्नरी को प्राथमिकता दी जाती है

उदाहरण:

puts (if 1 then 2 else 3 end) # => 2

puts 1 ? 2 : 3                # => 2

x = if 1 then 2 else 3 end
puts x                        # => 2

फ्लिप-फ्लॉप ऑपरेटर

फ्लिप फ्लॉप ऑपरेटर .. का उपयोग सशर्त विवरण में दो स्थितियों के बीच किया जाता है:

(1..5).select do |e|
  e if (e == 2) .. (e == 4)
end
# => [2, 3, 4]

स्थिति तब तक false मूल्यांकन करती है जब तक कि पहला भाग true हो जाता। तो यह करने के लिए मूल्यांकन करता है true जब तक दूसरा हिस्सा बन जाता है true । इसके बाद यह फिर से false जाता है।

यह उदाहरण दिखाता है कि क्या चुना जा रहा है:

[1, 2, 2, 3, 4, 4, 5].select do |e|
  e if (e == 2) .. (e == 4)
end
# => [2, 2, 3, 4]

फ्लिप-फ्लॉप ऑपरेटर केवल ifs के अंदर काम करता है ( unless शामिल unless ) और टर्नरी ऑपरेटर। अन्यथा इसे रेंज ऑपरेटर माना जा रहा है।

(1..5).select do |e|
  (e == 2) .. (e == 4)
end
# => ArgumentError: bad value for range

यह कई बार false से true और पीछे से बदल सकता है:

((1..5).to_a * 2).select do |e|
  e if (e == 2) .. (e == 4)
end
# => [2, 3, 4, 2, 3, 4]