स्काला में निहित पैरामीटर और रूपांतरण

हैबर पर पिछले लेखों को चलाने के बाद, टायट्स और टायट्स जल्दी से समझ नहीं पा रहे थे कि स्केला में क्या निहित है। आइए इसे एक साथ जानने का प्रयास करें।


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

उदाहरण के लिए, हम फ्लोट से इंट (फ्लोटटाइंट) में बदलने के लिए एक फ़ंक्शन लिख सकते हैं और, इस फ़ंक्शन को स्पष्ट रूप से कॉल करने के बजाय, कंपाइलर इसे हमारे लिए निहित करेगा:

def double(value: Int) = value * 2 implicit def FloatToInt(value: Float):Int = value.toInt println(double(2.5F)) 

भ्रमित? चलो सब कुछ क्रम में मिलता है।

तो, आज हम दो निहित श्रेणियों को देखते हैं, अर्थात्:

• निहित पैरामीटर (मान)। वे संकलक के माध्यम से घोषित संकलक मूल्यों द्वारा स्वचालित रूप से पारित हो जाते हैं।
• निष्प्राण रूपांतरण यदि अपेक्षित पैरामीटर का प्रकार इनपुट पैरामीटर से मेल नहीं खाता है, तो संकलक निहितार्थ के साथ चिह्नित गुंजाइश में किसी भी विधि की खोज करता है और इस स्थिति में आवश्यक पैरामीटर और इनपुट पैरामीटर के साथ और स्वचालित रूप से इसे पास करता है।

इम्प्लिमेंट पैरामीटर

एक अंतर्निहित पैरामीटर एक फ़ंक्शन पैरामीटर है जो अंतर्निहित कीवर्ड से पहले है। इसका अर्थ है कि यदि फ़ंक्शन को कॉल करने पर कोई मान पारित नहीं किया जाता है, तो संकलक व्यक्तिगत रूप से निहित पैरामीटर की खोज करेगा और इसे हमारे लिए पास करेगा।

उदाहरण के लिए, ऐसा फ़ंक्शन जो इनपुट के रूप में एक अंतर्निहित पैरामीटर मान लेता है और इसे दोगुना करता है:

 def double(implicit value: Int) = value * 2 

एक अंतर्निहित पैरामीटर के बिना, यह एक त्रुटि के साथ विफल हो जाएगा:

 def double(implicit value: Int) = value * 2 println(double) // error: could not find implicit value for parameter value 

एक स्पष्ट पैरामीटर पास होने के साथ, यह काम करेगा:

 def double(implicit value: Int) = value * 2 println(double(3)) // 6 

एक अंतर्निहित पैरामीटर के साथ, यह इस तरह दिखेगा:

 def double(implicit value: Int) = value * 2 implicit val multiplier = 2 println(double) // 4 

लेकिन आपको सावधान रहने की जरूरत है:

 def double(implicit value: Int) = value * 2 implicit val multiplier = 2 implicit val multiplier2 = 1 println(double) // error: ambiguous implicit values 

और अंत में, एक अंतर्निहित पैरामीटर के रूप में पासिंग डिफ के साथ एक उदाहरण:

 def double(implicit value: Int) = value * 2 val cappucinoLarge: Boolean = false implicit def cappucinoPrice: Int = if (cappucinoLarge) 200 else 100 println(double) // 200 

यानी अंत में हम सफल होंगे

 double(cappucinoPrice()) 

सिंटैक्स नोट्स:

 def func1(implicit value1: Int) // value1  def func2(implicit value1: Int, value2: Int) // value1  value2  def func3(value1: Int, implicit value2: Int) //   def func4(value1: Int)(implicit value2: Int) //  value2  def func5(implicit value1: Int)(value2: Int) //   def func6(implicit value1: Int)(implicit value2: Int) //   

निष्प्राण रूपांतरण

फ्लोट से इंट में उदाहरण पर लौटना:

 def double(value: Int) = value * 2 implicit def FloatToInt(value: Float):Int = value.toInt println(double(2.5F)) 

डबल कॉल करते समय, हमारे पास इनपुट पैरामीटर (फ्लोट) के साथ अपेक्षित पैरामीटर (Int) का एक प्रकार का बेमेल है। इसलिए, कंपाइलर इस स्थिति में किसी भी विधि की तलाश कर रहा है, जो अनुमानित है और अपेक्षित पैरामीटर (इंट) और इनपुट पैरामीटर (फ्लोट) आवश्यक है। फ्लोटटाइंट ढूँढता है, रूपांतरण करता है, और वांछित मूल्य को दोगुना करने के लिए आगे बढ़ता है।

अब, मुझे आशा है, यह स्पष्ट हो गया है। स्काला को महारत हासिल करने में सारी सफलता!