Scala Language
कार्य
खोज…
टिप्पणियों
स्काला में प्रथम श्रेणी के कार्य हैं।
कार्यों और विधियों के बीच अंतर:
फ़ंक्शन स्कैला में एक विधि नहीं है: फ़ंक्शन एक मूल्य हैं, और इस तरह से असाइन किया जा सकता है। तरीके (उपयोग कर बनाई गई def , दूसरे हाथ पर), एक वर्ग, विशेषता या वस्तु से संबंधित होना चाहिए।
- संकलनों को संकलन-समय पर एक विशेषता (जैसे
Function1) के रूप में संकलित करने के लिए संकलित किया जाता है, और रनटाइम पर एक मूल्य के लिएFunction1जाता है। दूसरी ओर, विधियाँ, उनके वर्ग, गुण या वस्तु के सदस्य हैं, और उस से बाहर मौजूद नहीं हैं। - एक विधि को एक फ़ंक्शन में बदला जा सकता है, लेकिन एक फ़ंक्शन को एक विधि में परिवर्तित नहीं किया जा सकता है।
- विधियों में टाइप पैरामीटर हो सकता है, जबकि फ़ंक्शन नहीं होते हैं।
- विधियों में पैरामीटर डिफ़ॉल्ट मान हो सकते हैं, जबकि फ़ंक्शन नहीं कर सकते।
अनाम कार्य
बेनामी फ़ंक्शंस ऐसे फ़ंक्शंस हैं जिन्हें परिभाषित किया गया है लेकिन नाम निर्दिष्ट नहीं किया गया है।
निम्नलिखित एक अनाम फ़ंक्शन है जो दो पूर्णांकों में लेता है और योग देता है।
(x: Int, y: Int) => x + y
परिणामी अभिव्यक्ति को एक val को सौंपा जा सकता है:
val sum = (x: Int, y: Int) => x + y
बेनामी कार्यों को मुख्य रूप से अन्य कार्यों के तर्क के रूप में उपयोग किया जाता है। उदाहरण के लिए, एक संग्रह पर map कार्य एक अन्य फ़ंक्शन को उसके तर्क के रूप में उम्मीद करता है:
// Returns Seq("FOO", "BAR", "QUX")
Seq("Foo", "Bar", "Qux").map((x: String) => x.toUpperCase)
अनाम फ़ंक्शन के तर्कों को छोड़ा जा सकता है: प्रकार स्वचालित रूप से अनुमानित हैं :
Seq("Foo", "Bar", "Qux").map((x) => x.toUpperCase)
यदि केवल एक तर्क है, तो उस तर्क के आसपास के कोष्ठक को छोड़ा जा सकता है:
Seq("Foo", "Bar", "Qux").map(x => x.toUpperCase)
अंडरशोर शॉर्टहैंड
वहाँ भी एक छोटे वाक्यविन्यास है कि तर्क के लिए नाम की आवश्यकता नहीं है। उपरोक्त स्निपेट लिखा जा सकता है:
Seq("Foo", "Bar", "Qux").map(_.toUpperCase)
_ से अनाम फ़ंक्शन तर्कों का प्रतिनिधित्व करता है। एक अनाम फ़ंक्शन के साथ जिसमें कई पैरामीटर हैं, _ की प्रत्येक घटना एक अलग तर्क को संदर्भित करेगी। उदाहरण के लिए, दो निम्नलिखित भाव समतुल्य हैं:
// Returns "FooBarQux" in both cases
Seq("Foo", "Bar", "Qux").reduce((s1, s2) => s1 + s2)
Seq("Foo", "Bar", "Qux").reduce(_ + _)
इस आशुलिपि का उपयोग करते समय, स्थिति _ द्वारा प्रस्तुत किसी भी तर्क को केवल एक बार और उसी क्रम में संदर्भित किया जा सकता है।
अनाम पैरामीटर कोई पैरामीटर के साथ
एक अनाम फ़ंक्शन के लिए मान बनाने के लिए जो पैरामीटर नहीं लेता है, पैरामीटर सूची को खाली छोड़ दें:
val sayHello = () => println("hello")
रचना
फ़ंक्शन रचना दो कार्यों को संचालित करने और एकल फ़ंक्शन के रूप में देखने की अनुमति देती है। गणितीय शब्दों में व्यक्त, एक फ़ंक्शन f(x) और एक फ़ंक्शन g(x) , फ़ंक्शन h(x) = f(g(x)) ।
जब कोई फ़ंक्शन संकलित किया जाता है, तो इसे Function1 से संबंधित एक प्रकार से संकलित किया जाता है। स्काला में दो तरीके प्रदान Function1 : रचना से संबंधित कार्यान्वयन andThen और compose । इस तरह से ऊपर गणितीय परिभाषा के साथ compose विधि फिट बैठता है:
val f: B => C = ...
val g: A => B = ...
val h: A => C = f compose g
andThen (थिंक h(x) = g(f(x)) ) में अधिक 'डीएसएल-जैसी' भावना होती है:
val f: A => B = ...
val g: B => C = ...
val h: A => C = f andThen g
एक नया अनाम फ़ंक्शन आवंटित किया गया है जो f और g पर बंद है। यह फ़ंक्शन दोनों मामलों में नए फ़ंक्शन h लिए बाध्य है।
def andThen(g: B => C): A => C = new (A => C){
def apply(x: A) = g(self(x))
}
यदि या तो f या g एक साइड-इफ़ेक्ट के माध्यम से काम करता है, तो h को कॉल करने से f और g सभी साइड-इफेक्ट्स ऑर्डर में हो जाएंगे। वही किसी भी परिवर्तनशील राज्य परिवर्तनों का सच है।
आंशिक संबंधों का संबंध
trait PartialFunction[-A, +B] extends (A => B)
हर एक-तर्क PartialFunction भी एक Function1 । यह एक औपचारिक गणितीय अर्थ में काउंटर-सहज ज्ञान युक्त है, लेकिन बेहतर वस्तु उन्मुख डिजाइन फिट बैठता है। इस कारण से Function1 को एक निरंतर true isDefinedAt विधि प्रदान करने की आवश्यकता नहीं है।
आंशिक फ़ंक्शन (जो एक फ़ंक्शन भी है) को परिभाषित करने के लिए, निम्नलिखित सिंटैक्स का उपयोग करें:
{ case i: Int => i + 1 } // or equivalently { case i: Int ⇒ i + 1 }
अधिक जानकारी के लिए, PartialFunctions पर एक नज़र डालें ।
