Functions को Values की तरह उपयोग करना
First-class functions
Functions को Values की तरह उपयोग करना, CoddyKit पर बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala का एक निःशुल्क पाठ है। यह 4 में से 1वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
फ़ंक्शन मान होते हैं
Scala में फ़ंक्शन प्रथम-श्रेणी के मान होते हैं। आप उन्हें चरों में रख सकते हैं, तर्क के रूप में पास कर सकते हैं और अन्य फ़ंक्शन से लौटा सकते हैं, ठीक संख्याओं या स्ट्रिंग की तरह।
object Main {
def main(args: Array[String]): Unit = {
val increment: Int => Int = x => x + 1
println(increment(5))
}
}फ़ंक्शन प्रकार का वाक्यविन्यास
प्रकार Int => String का अर्थ है ऐसी फ़ंक्शन जो Int लेती है और String लौटाती है। कई पैरामीटर के लिए कोष्ठक का उपयोग करें: (Int, Int) => Int।
object Main {
def main(args: Array[String]): Unit = {
val add: (Int, Int) => Int = (a, b) => a + b
val label: Int => String = n => s"value=$n"
println(add(3, 4))
println(label(7))
}
}लैम्ब्डा (अनाम फ़ंक्शन) का वाक्यविन्यास
अनाम फ़ंक्शन, या लैम्ब्डा, (params) => body के रूप में लिखी जाती है। इसका कोई नाम नहीं होता और इसे अक्सर सीधे किसी अन्य फ़ंक्शन को पास किया जाता है।
object Main {
def main(args: Array[String]): Unit = {
val square = (x: Int) => x * x
println(square(6))
}
}उच्च-क्रम फ़ंक्शन
उच्च-क्रम फ़ंक्शन वह फ़ंक्शन है जो पैरामीटर के रूप में कोई फ़ंक्शन लेती है या कोई फ़ंक्शन लौटाती है। map और filter इसके सामान्य उदाहरण हैं।
object Main {
def applyTwice(f: Int => Int, x: Int): Int = f(f(x))
def main(args: Array[String]): Unit = {
println(applyTwice(_ + 3, 10))
}
}फ़ंक्शन को विधियों में पास करना
संग्रह की विधियाँ फ़ंक्शन स्वीकार करती हैं। आप लैम्ब्डा को उसी स्थान पर लिखकर या किसी नामित फ़ंक्शन मान को पास कर सकते हैं।
object Main {
def main(args: Array[String]): Unit = {
val triple = (x: Int) => x * 3
println(List(1, 2, 3).map(triple))
println(List(1, 2, 3).map(x => x * 3))
}
}फ़ंक्शन लौटाना
कोई फ़ंक्शन दूसरी फ़ंक्शन लौटा सकती है। यहाँ multiplier एक ऐसी फ़ंक्शन लौटाता है जो किसी निश्चित गुणक से गुणा करती है—यह एक छोटी फ़ंक्शन-निर्माता है।
object Main {
def multiplier(factor: Int): Int => Int = x => x * factor
def main(args: Array[String]): Unit = {
val timesTen = multiplier(10)
println(timesTen(5))
}
}विधियाँ बनाम फ़ंक्शन
def एक विधि परिभाषित करता है। आप eta-विस्तार अंडरस्कोर से किसी विधि को फ़ंक्शन मान में बदल सकते हैं: methodName _; या जहाँ फ़ंक्शन अपेक्षित हो, वहाँ उसका सीधे उपयोग कर सकते हैं।
object Main {
def doubleIt(x: Int): Int = x * 2
def main(args: Array[String]): Unit = {
val f: Int => Int = doubleIt
println(f(8))
println(List(1, 2, 3).map(doubleIt))
}
}बिना पैरामीटर वाली फ़ंक्शन
कोई फ़ंक्शन कोई तर्क लिए बिना भी हो सकती है। इसका प्रकार () => T लिखा जाता है। यह गणना को बाद के लिए टालने में उपयोगी है।
object Main {
def main(args: Array[String]): Unit = {
val greeting: () => String = () => "Hello!"
println(greeting())
}
}संग्रहों में फ़ंक्शन रखना
क्योंकि फ़ंक्शन मान होते हैं, आप उन्हें सूचियों या मानचित्रों में रखकर गतिशील रूप से खोज सकते हैं और एक छोटा कमांड-वितरक बना सकते हैं।
object Main {
def main(args: Array[String]): Unit = {
val ops: Map[String, (Int, Int) => Int] = Map(
"add" -> (_ + _),
"mul" -> (_ * _)
)
println(ops("add")(3, 4))
println(ops("mul")(3, 4))
}
}विन्यास के रूप में फ़ंक्शन
फ़ंक्शन पास करने से कॉल करने वाले व्यवहार को अनुकूलित कर सकते हैं। यहाँ एक सामान्य transformAll सूची के प्रत्येक तत्व पर कोई भी फ़ंक्शन लागू करता है।
object Main {
def transformAll(xs: List[Int], f: Int => Int): List[Int] = xs.map(f)
def main(args: Array[String]): Unit = {
println(transformAll(List(1, 2, 3), _ + 100))
println(transformAll(List(1, 2, 3), _ * 10))
}
}अनुकूलन का अधिक साफ़ उदाहरण
यही विचार यहाँ साफ़ ढंग से लिखा गया है: कॉल करने वाले रूपांतरण देते हैं, जिससे सहायक फ़ंक्शन सामान्य और पुनः उपयोग योग्य रहती है।
object Main {
def transformAll(xs: List[Int], f: Int => Int): List[Int] = xs.map(f)
def main(args: Array[String]): Unit = {
println(transformAll(List(1, 2, 3), x => x + 100))
println(transformAll(List(1, 2, 3), x => x * x))
}
}त्वरित जाँच
उच्च-क्रम फ़ंक्शन क्या होती है?
पुनरावलोकन
आपने सीखा कि फ़ंक्शन प्रथम-श्रेणी के मान होते हैं:
valमें फ़ंक्शन, सूचियाँ और मानचित्र रखेंInt => Stringजैसे फ़ंक्शन प्रकार- लैम्ब्डा:
(x) => bodyऔर_का संक्षिप्त रूप - उच्च-क्रम फ़ंक्शन फ़ंक्शन लेती या लौटाती हैं
- विधियाँ eta-विस्तार के माध्यम से फ़ंक्शन मान बन जाती हैं
एआई शिक्षक के साथ Scala सीखें — निःशुल्क
अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।
- पाठ्यक्रम
- 39
- पाठ
- 143
अक्सर पूछे जाने वाले प्रश्न
क्या “Functions को Values की तरह उपयोग करना” पाठ निःशुल्क है?
हाँ—“Functions को Values की तरह उपयोग करना” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
“Functions को Values की तरह उपयोग करना” में मैं क्या सीखूँगा?
First-class functions आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।
क्या बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?
पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 1वाँ पाठ है।
“Functions को Values की तरह उपयोग करना” पाठ पूरा करने में कितना समय लगता है?
CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।
क्या मैं इस बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ में कोड लिख और चला सकता हूँ?
हाँ। हर बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।
इस पाठ्यक्रम के सभी पाठ
- Functions को Values की तरह उपयोग करना
- Currying
- Composition
- Closures