রুবিতে কিওয়ার্ড আর্গুমেন্ট, হ্যাশ এবং স্প্ল্যাট অপারেটরে দক্ষতা অর্জন

आपने शायद इस पैटर्न को पहले देखा है। एक मेथड के पास अपने अंतिम आर्गुमेंट के रूप में एक 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>'

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

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

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] के साथ एक्सेस कर सकते हैं।

… बेशक, अब हम वापस ऑप्शन्स हैश पर हैं।

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

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