कीवर्ड तर्क, हैश और स्प्लैट के साथ मज़ा

आपने शायद इस पैटर्न को पहले देखा होगा। एक विधि में एक options होता है हैश अपने अंतिम तर्क के रूप में, जिसमें अतिरिक्त पैरामीटर हैं:

def hello_message(name_parts = {})
  first_name = name_parts.fetch(:first_name)
  last_name = name_parts.fetch(:last_name)

  "Hello, #{first_name} #{last_name}"
end

दुर्भाग्य से, आपको उन मापदंडों को हैश से निकालने की आवश्यकता है। और इसका मतलब है कि आपके अच्छे हिस्से तक पहुंचने से पहले बहुत सारे सेटअप को पूरा करना होगा।

लेकिन यदि आपने रूबी 2.0+ में कीवर्ड तर्कों का उपयोग करने के लिए इस पद्धति को बदल दिया है, तो आपको :first_name खींचने की आवश्यकता नहीं होगी और :last_name आपके हैश से बाहर. रूबी आपके लिए करती है:

def hello_message(first_name:, last_name:)
  "Hello, #{first_name} #{last_name}"
end

इससे भी बेहतर, यदि आपका ऐप रूबी 1.9+ हैश सिंटैक्स का उपयोग करता है, तो आपके तरीके उन तरीकों के कॉलर्स को बदले बिना कीवर्ड तर्कों का उपयोग कर सकते हैं:

def hello_message_with_an_options_hash(name_parts = {})
  first_name = name_parts.fetch(:first_name)
  last_name = name_parts.fetch(:last_name)

  "Hello, #{first_name} #{last_name}"
end

def hello_message_with_keyword_arguments(first_name:, last_name:)
  "Hello, #{first_name} #{last_name}"
end

hello_message_with_an_options_hash(first_name: "Justin", last_name: "Weiss")

hello_message_with_keyword_arguments(first_name: "Justin", last_name: "Weiss")

देखना? वे तर्क समान हैं!

कीवर्ड तर्क सिंटैक्स को एक कदम बहुत दूर धकेलना

क्या होगा यदि आपने नहीं हालांकि, नए हैश सिंटैक्स पर स्विच किया गया है? आप अपना सारा कोड बदल सकते हैं। लेकिन, कम से कम रूबी 2.2.1 में, पुराना हैश सिंटैक्स कीवर्ड तर्कों के साथ ठीक काम करता है:

irb(main):007:0> hello_message_with_keyword_arguments(:first_name => "Justin", :last_name => "Weiss")
=> "Hello, Justin Weiss"

अच्छा! हैश ऑब्जेक्ट पास करने के बारे में क्या , तर्कों के बजाय?

irb(main):008:0> options = {:first_name => "Justin", :last_name => "Weiss"}
irb(main):009:0> hello_message_with_keyword_arguments(options)
=> "Hello, Justin Weiss"

वाह। क्या होगा अगर हम मिश्रण . करना चाहते हैं एक हैश और कीवर्ड तर्क?

irb(main):010:0> options = {last_name: "Weiss"}
irb(main):011:0> hello_message_with_keyword_arguments(first_name: "Justin", options)
SyntaxError: (irb):11: syntax error, unexpected ')', expecting =>
	from /usr/local/bin/irb:11:in `<main>'

ठीक है। मुझे लगता है कि हमने वह एक कदम बहुत दूर ले लिया है। इसे ठीक करने के लिए, आप एक हैश बनाने के लिए हैश # मर्ज का उपयोग कर सकते हैं जिसे आप स्वयं ही पास कर सकते हैं। लेकिन एक बेहतर तरीका है।

यदि आप कीवर्ड तर्कों के बजाय नियमित तर्कों का उपयोग कर रहे थे, तो आप * का उपयोग करके किसी सरणी से तर्कों को विभाजित कर सकते हैं :

def generate_thumbnail(name, width, height)
  # ...
end

dimensions = [240, 320]
generate_thumbnail("headshot.jpg", *dimensions)

लेकिन क्या कीवर्ड को विभाजित करने का कोई तरीका है तर्क सूची में तर्क?

यह पता चला है:** . यहां बताया गया है कि आप उस टूटे हुए उदाहरण को ** . के साथ कैसे ठीक करेंगे :

irb(main):010:0> options = {last_name: "Weiss"}
irb(main):011:0> hello_message_with_keyword_arguments(first_name: "Justin", **options)
=> "Hello, Justin Weiss"

और अगर आप वास्तव में . हैं पागल, आप नियमित तर्क, खोजशब्द तर्क, और विभाजन को मिला सकते हैं:

def hello_message(greeting, time_of_day, first_name:, last_name:)
  "#{greeting} #{time_of_day}, #{first_name} #{last_name}!"
end

args = ["Morning"]
keyword_args = {last_name: "Weiss"}

hello_message("Good", *args, first_name: "Justin", **keyword_args) # => "Good Morning, Justin Weiss!"

बेशक, अगर आप अपने आप को उस स्थिति में पाते हैं जहाँ यह आवश्यक है, तो आपने शायद बहुत पहले एक गलती की है!

कीवर्ड तर्कों को आसान तरीके से कैप्चर करें

क्या आप जानते हैं कि आप * . का उपयोग करके अपने सभी मेथड तर्कों को एक सरणी में कैसे बदल सकते हैं? ?

def argument_capturing_method(*args)
  args
end

argument_capturing_method(1, 2, 3) # => [1, 2, 3]

यह कीवर्ड तर्कों के साथ भी काम करता है। वे हैश में बदल गए हैं, और आपके args . के अंतिम तर्क के रूप में दिखाई देते हैं सरणी:

argument_capturing_method(1, 2, 3, key: "value") # => [1, 2, 3, {:key=>"value"}]

लेकिन args.last[:key] इस तरह से पकड़े गए कीवर्ड तर्कों को पढ़ने का सबसे अच्छा तरीका नहीं है। इसके बजाय, आप नए ** . का उपयोग कर सकते हैं कीवर्ड तर्क स्वयं प्राप्त करने के लिए सिंटैक्स:

def dual_argument_capturing_method(*args, **keyword_args)
  {args: args, keyword_args: keyword_args}
end

dual_argument_capturing_method(1, 2, 3, key: "value") # => {:args=>[1, 2, 3], :keyword_args=>{:key=>"value"}}

इस सिंटैक्स के साथ, आप args[0] . के साथ पहले नियमित तर्क तक पहुंच सकते हैं और :key keyword_args[:key] . के साथ कीवर्ड तर्क ।

... बेशक, अब हम विकल्प हैश पर वापस आ गए हैं।

आपके कोड से एक टन पैरामीटर निष्कर्षण बॉयलरप्लेट को हटाने के लिए कीवर्ड तर्क बहुत अच्छे हैं। और हो सकता है कि उनका लाभ उठाने के लिए आपको अपना कोई कोड बदलना भी न पड़े।

लेकिन जब आप अधिक सामान्य तरीके लिखते हैं, तो कुछ नई तकनीकें होती हैं जिन्हें आपको कीवर्ड तर्कों को अच्छी तरह से संभालना सीखना होगा। आपको उन तकनीकों का बहुत बार उपयोग नहीं करना पड़ सकता है। लेकिन जब आप ऐसा करेंगे, तो यह शक्ति और लचीलापन आपकी प्रतीक्षा में रहेगा।