रूबी की शक्तिशाली विधि तर्क और उनका सही उपयोग कैसे करें

मुझे एक ईमेल मिला है जिसमें कीवर्ड तर्कों का उपयोग करने के बारे में मेरी राय पूछी गई है।

मैंने सोचा कि मैं अपने उत्तर को रूबी विधि तर्कों के बारे में एक पूर्ण लेख में विस्तारित करूंगा ताकि सभी को लाभ हो सके !

जब विधि तर्कों की बात आती है तो रूबी बहुत लचीली होती है।

हमारे पास सब कुछ है :

मानक आवश्यक तर्कों से लेकर वैकल्पिक तर्कों और यहां तक ​​कि कीवर्ड (नामांकित) तर्कों तक।

इस लेख में, आप मतभेदों के बारे में जानेंगे इन सभी तर्क प्रकारों के बीच, और आपकी स्थिति के आधार पर किन तर्कों का उपयोग करना है।

सही प्रकार के तर्कों का उपयोग करने से आपका कोड पढ़ने में आसान और काम करने में आसान हो जाएगा।

संदेह होने पर मानक तर्कों का उपयोग करें

आवश्यक तर्क वे हैं जो आपको डिफ़ॉल्ट रूप से मिलते हैं।

यहां एक उदाहरण है :

def write(file, data, mode)
end

write("cats.txt", "cats are cool!", "w")

यदि आप आवश्यक तर्कों की सटीक संख्या पास नहीं करते हैं तो आपको यह परिचित त्रुटि संदेश मिलेगा:

write("shopping_list.txt", "bacon")

ArgumentError: wrong number of arguments (2 for 3)

इसका मतलब है कि आपने विधि दी 2 तर्क, लेकिन इसके लिए 3 . की आवश्यकता है !

वैकल्पिक तर्कों के साथ लचीले तरीके

आप डिफ़ॉल्ट मान प्रदान करके अपने कुछ तर्कों को वैकल्पिक बनाना चाह सकते हैं।

उदाहरण के लिए :

def write(file, data, mode = "w")
end

अब आप कॉल कर सकते हैं write 2 तर्कों के साथ, किस स्थिति में mode डिफ़ॉल्ट मान के बराबर होगा ("w" ), या आप डिफ़ॉल्ट मान को ओवरराइड करने और अलग-अलग परिणाम प्राप्त करने के लिए 3 तर्कों में पास कर सकते हैं।

इस विधि को कॉल करते समय यह डिफ़ॉल्ट मान आपको कुछ काम बचाता है जबकि आपको इसे बदलने का विकल्प भी देता है।

स्पष्टता बढ़ाने के लिए कीवर्ड तर्कों का उपयोग करें

आवश्यक और डिफ़ॉल्ट तर्कों में से एक यह है कि वे ऑर्डर पर निर्भर हैं।

मतलब कि आपको तर्कों को उसी क्रम में पास करना है

यदि आप उन्हें गलत क्रम में पास करते हैं :

आपको अप्रत्याशित परिणाम मिलेंगे!

उदाहरण के लिए, write . में विधि, आपको इसे file . के साथ कॉल करना होगा पहले, फिर data और अंत में mode ।

def write(file, data, mode)
end

कीवर्ड तर्क आपको तर्कों के क्रम को बदलने की अनुमति देते हैं।

यहां एक उदाहरण दिया गया है :

def write(file:, data:, mode: "ascii")
end

यह आपको एक अलग क्रम में विधि को कॉल करने की अनुमति देता है:

write(data: 123, file: "test.txt")

लेकिन इससे भी महत्वपूर्ण बात यह है कि जब आप विधि को कॉल करते हैं तो आप स्पष्ट रूप से तर्कों का अर्थ देख सकते हैं ।

मैं अपने आप को अक्सर कीवर्ड तर्कों का उपयोग करते हुए नहीं पाता, लेकिन जब आप विधि कॉल में स्पष्टता जोड़ना चाहते हैं तो वे उपयोगी हो सकते हैं।

मान लें कि हमारे पास Point है कक्षा।

आप इसे इस तरह लिख सकते हैं :

class Point
  def initialize(x: , y:)
    @x, @y = x, y
  end
end

point = Point.new(x: 10, y: 20)

इस तरह इस बारे में कोई भ्रम नहीं है कि दोनों में से कौन सी संख्या (10 और 20) x . से मेल खाती है मान या y मूल्य।

भ्रम और गलतफहमी से बचने के लिए कोड लिखते समय यह आपका एक मुख्य लक्ष्य है। ।

यदि कीवर्ड तर्कों का उपयोग करने से आपको ऐसा करने में मदद मिलती है तो उनका उपयोग करें।

इसके बारे में सोचें :

"क्या कीवर्ड तर्क जोड़ने से इसे समझना आसान हो जाएगा या यह मेरे कोड में अतिरिक्त काम और अव्यवस्था जोड़ देगा?"

कीवर्ड तर्कों के बारे में एक और बात यह है कि वे उन तर्कों के बारे में बहुत स्पष्ट हैं जो आप खो रहे हैं।

उदाहरण :

point = Point.new

# missing keywords: x, y

आप कीवर्ड तर्कों को नियमित तर्कों के साथ भी जोड़ सकते हैं।

रूबी बिल्ट-इन विधियों पर मैं जो एक रणनीति देख रहा हूं, वह यह है कि नए संस्करण नए, वैकल्पिक तर्कों को जोड़ते हैं, जैसे कि कीवर्ड तर्क ।

इसके उदाहरण Float#round . के लिए कीवर्ड तर्क हैं , Kernel#clone &String#lines रूबी 2.4 में पेश किया गया।

वेरिएबल तर्कों का उपयोग जितने आवश्यक हो उतने मान कैप्चर करने के लिए करें

क्या होगा यदि आप असीमित मात्रा में मूल्य लेना चाहते हैं?

फिर आप चर तर्कों . का उपयोग कर सकते हैं :

def print_all(*args)
end

print_all(1, 2, 3, 4, 5)

यह आपको विधि को किसी भी संख्या में तर्कों के साथ कॉल करने की अनुमति देता है, जिसमें कोई भी शामिल नहीं है। एक चर तर्क एक सरणी है जिसमें सभी मान पास किए जाते हैं।

आप इसे अन्य प्रकार के तर्कों के साथ जोड़ सकते हैं।

उदाहरण :

def print_all(title, *chapters)
end

यह पहला तर्क title . के रूप में लेगा , और शेष chapters . के रूप में सरणी। ध्यान दें कि एक चर तर्क बाद . होना चाहिए आपके सभी आवश्यक और वैकल्पिक तर्क, और किसी भी कीवर्ड तर्क से पहले।

सही क्रम का उपयोग करें

यदि आप उन्हें संयोजित करना चाहते हैं और सिंटैक्स त्रुटि से बचना चाहते हैं तो तर्कों का मान्य क्रम यहां दिया गया है:

required -> optional -> variable -> keyword

यहां एक तरीका दिया गया है जो हर संभव तर्क प्रकार को दिखाता है :

def testing(a, b = 1, *c, d: 1, **x)
  p a,b,c,d,x
end

testing('a', 'b', 'c', 'd', 'e', d: 2, x: 1)

**x परिवर्तनीय तर्कों के समान है, लेकिन कीवर्ड तर्कों के लिए। यह एक सरणी के बजाय हैश होगा।

द कैच-ऑल आर्गुमेंट

कुछ दुर्लभ अवसरों में आप इसे देख सकते हैं:

def print_all(*)
end

इसका मतलब है कि विधि किसी भी तर्क को स्वीकार कर रही है, लेकिन यह उनके साथ कुछ नहीं कर रही है। यह अंडरस्कोर वर्ण (_ . का उपयोग करने के समान है ) एक ब्लॉक के अंदर यह दिखाने के लिए कि आप किन तर्कों का उपयोग नहीं कर रहे हैं।

इसके लिए एक व्यावहारिक उपयोग सुपर कीवर्ड के संयोजन में किया जा सकता है:

class Food
  def nutrition(vitamins, minerals)
    puts vitamins
    puts minerals
  end
end

class Bacon < Food
  def nutrition(*)
    super
  end
end

bacon = Bacon.new

bacon.nutrition("B6", "Iron")

अब जब भोजन का nutrition इसकी तर्क सूची को बदलता है, आपको Bacon . में तर्क बदलने की आवश्यकता नहीं है भी।

सारांश

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

आशा है कि आपको यह उपयोगी और दिलचस्प लगा होगा!

इस पोस्ट को ट्विटर पर शेयर करें ताकि और लोग इसे देख सकें 🙂