Ruby Language
कीवर्ड तर्क

टिप्पणियों

def say(message: "Hello World")
  puts message
end

say
# => "Hello World"

say message: "Today is Monday"
# => "Today is Monday"

def say(message = "Hello World")
  puts message
end

say
# => "Hello World"

say "Today is Monday"
# => "Today is Monday"

def say(options = {})
  message = options.fetch(:message, "Hello World")
  puts 
end

say
# => "Hello World"

say message: "Today is Monday"
# => "Today is Monday"

कीवर्ड तर्क का उपयोग करना

आप विधि परिभाषा में नाम निर्दिष्ट करके एक विधि में एक कीवर्ड तर्क को परिभाषित करते हैं:

def say(message: "Hello World")
  puts message
end

say
# => "Hello World"

say message: "Today is Monday"
# => "Today is Monday"

आप कई कीवर्ड तर्कों को परिभाषित कर सकते हैं, परिभाषा क्रम अप्रासंगिक है:

def say(message: "Hello World", before: "<p>", after: "</p>")
  puts "#{before}#{message}#{after}"
end

say
# => "<p>Hello World</p>"

say message: "Today is Monday"
# => "<p>Today is Monday</p>"

say after: "</p><hr>", message: "Today is Monday"
# => "<p>Today is Monday</p><hr>"

कीवर्ड तर्क को स्थैतिक तर्क के साथ मिलाया जा सकता है:

def say(message, before: "<p>", after: "</p>")
  puts "#{before}#{message}#{after}"
end

say "Hello World", before: "<span>", after: "</span>"
# => "<span>Hello World</span>"

रूबी 2.1 से पहले स्थिति तर्क के साथ कीवर्ड तर्क को मिलाना एक बहुत ही सामान्य दृष्टिकोण था, क्योंकि आवश्यक कीवर्ड तर्कों को परिभाषित करना संभव नहीं था।

इसके अलावा, रूबी <2.0 में, वैकल्पिक तर्कों के लिए उपयोग करने के लिए विधि परिभाषा के अंत में एक Hash जोड़ना बहुत आम था। सिंटैक्स कीवर्ड दलीलों से बहुत मिलता-जुलता है, उस बिंदु तक जहां Hash माध्यम से वैकल्पिक तर्क रूबी 2 कीवर्ड तर्कों के साथ संगत हैं।

def say(message, options = {})
  before = option.fetch(:before, "<p>")
  after  = option.fetch(:after, "</p>")
  puts "#{before}#{message}#{after}"
end

# The method call is syntactically equivalent to the keyword argument one
say "Hello World", before: "<span>", after: "</span>"
# => "<span>Hello World</span>"

ध्यान दें कि बिना परिभाषित खोजशब्द तर्क को पारित करने की कोशिश करने के परिणामस्वरूप त्रुटि होगी:

def say(message: "Hello World")
  puts message
end

say foo: "Hello"
# => ArgumentError: unknown keyword: foo

आवश्यक खोजशब्द तर्क

def say(message:)
  puts message
end

say
# => ArgumentError: missing keyword: message

say message: "Hello World"
# => "Hello World"

def say(before: "<p>", message:, after: "</p>")
  puts "#{before}#{message}#{after}"
end

say
# => ArgumentError: missing keyword: message

say message: "Hello World"
# => "<p>Hello World</p>"

say message: "Hello World", before: "<span>", after: "</span>"
# => "<span>Hello World</span>"

स्पैट ऑपरेटर के साथ मनमाना कीवर्ड तर्क का उपयोग करना

आप डबल स्पैट ( ** ) ऑपरेटर का उपयोग करके एक मनमानी संख्या को कीवर्ड तर्कों को स्वीकार करने के लिए परिभाषित कर सकते हैं:

def say(**args)
  puts args
end

say foo: "1", bar: "2"
# {:foo=>"1", :bar=>"2"}

तर्कों को एक Hash में कैद किया जाता है। उदाहरण के लिए वांछित तर्क निकालने के लिए आप Hash हेरफेर कर सकते हैं।

def say(**args)
  puts args[:message] || "Message not found"
end

say foo: "1", bar: "2", message: "Hello World"
# Hello World

say foo: "1", bar: "2"
# Message not found

कीवर्ड तर्कों के साथ एक स्पैट ऑपरेटर का उपयोग करना कीवर्ड तर्क सत्यापन को रोक देगा, अज्ञात कीवर्ड के मामले में विधि कभी भी ArgumentError नहीं उठाएगा।

मानक स्पैट ऑपरेटर के लिए, आप किसी विधि के लिए Hash को कीवर्ड तर्क में बदल सकते हैं:

def say(message: nil, before: "<p>", after: "</p>")
  puts "#{before}#{message}#{after}"
end

args = { message: "Hello World", after: "</p><hr>" }
say(**args)
# <p>Hello World</p><hr>

args = { message: "Hello World", foo: "1" }
say(**args)
# => ArgumentError: unknown keyword: foo

आम तौर पर इसका उपयोग तब किया जाता है जब आपको आने वाले तर्कों में हेरफेर करने की आवश्यकता होती है, और उन्हें एक अंतर्निहित विधि में पास करना होता है:

def inner(foo:, bar:)
  puts foo, bar
end

def outer(something, foo: nil, bar: nil, baz: nil)
  puts something
  params = {}
  params[:foo] = foo || "Default foo"
  params[:bar] = bar || "Default bar"
  inner(**params)
end

outer "Hello:", foo: "Custom foo"
# Hello:
# Custom foo
# Default bar