बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala · पाठ

Closures

State capture करना

पाठ 4, कुल 4 में से13 चरण

Closures, CoddyKit पर बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala का एक निःशुल्क पाठ है। यह 4 में से 4वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

क्लोज़र क्या है?

क्लोज़र वह फ़ंक्शन है जो उस बाहरी स्कोप से चर ग्रहण करता है, जहाँ उसे परिभाषित किया गया था। वह उन चरों को अपने साथ बाँध लेता है, इसलिए उस स्कोप के समाप्त हो जाने के बाद भी उन तक पहुँच बनी रहती है।

object Main {
  def main(args: Array[String]): Unit = {
    val factor = 3
    val multiply = (x: Int) => x * factor
    println(multiply(5))
  }
}

मुक्त चर को ग्रहण करना

x => x * factor में x एक पैरामीटर है, लेकिन factor बाहरी स्कोप से लिया गया मुक्त चर है। फ़ंक्शन अपने साथ उसका संदर्भ रखता है।

object Main {
  def main(args: Array[String]): Unit = {
    val greeting = "Hello"
    val greet = (name: String) => s"$greeting, $name!"
    println(greet("Ann"))
    println(greet("Bob"))
  }
}

क्लोज़र अपने स्कोप से अधिक समय तक जीवित रहते हैं

जब कोई फ़ंक्शन क्लोज़र लौटाता है, तो ग्रहण किए गए चर तब तक बने रहते हैं जब तक क्लोज़र बना रहता है, भले ही उसे परिभाषित करने वाला फ़ंक्शन पहले ही समाप्त हो चुका हो।

object Main {
  def makeAdder(n: Int): Int => Int = x => x + n
  def main(args: Array[String]): Unit = {
    val add10 = makeAdder(10)
    val add100 = makeAdder(100)
    println(add10(5))
    println(add100(5))
  }
}

हर क्लोज़र का अपना ग्रहण होता है

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

object Main {
  def prefixer(p: String): String => String = s => p + s
  def main(args: Array[String]): Unit = {
    val withDr = prefixer("Dr. ")
    val withMr = prefixer("Mr. ")
    println(withDr("Smith"))
    println(withMr("Jones"))
  }
}

परिवर्तनीय स्थिति को ग्रहण करना

क्लोज़र किसी var को ग्रहण करके उसे पढ़ और अपडेट कर सकता है। इससे क्लोज़र कॉल के बीच स्थिति बनाए रख सकता है, जैसे कोई काउंटर।

object Main {
  def main(args: Array[String]): Unit = {
    var count = 0
    val increment = () => { count += 1; count }
    println(increment())
    println(increment())
    println(increment())
  }
}

काउंटर फ़ैक्टरी

इन विचारों को मिलाकर, ऐसा फ़ंक्शन जो अपना निजी var ग्रहण करने वाला क्लोज़र लौटाता है, आपको एक समाहित और स्वतंत्र काउंटर देता है।

object Main {
  def counter(): () => Int = {
    var n = 0
    () => { n += 1; n }
  }
  def main(args: Array[String]): Unit = {
    val c1 = counter()
    val c2 = counter()
    println(c1())
    println(c1())
    println(c2())
  }
}

क्लोज़र संदर्भ ग्रहण करते हैं, प्रतिलिपियाँ नहीं

क्लोज़र चर को ग्रहण करता है, उसका स्नैपशॉट नहीं। यदि क्लोज़र बनने के बाद ग्रहण किया गया var बदलता है, तो क्लोज़र नया मान देखता है।

object Main {
  def main(args: Array[String]): Unit = {
    var msg = "first"
    val show = () => println(msg)
    show()
    msg = "second"
    show()
  }
}

val को ग्रहण करना बेहतर है

अपरिवर्तनीय val को ग्रहण करने से अनपेक्षित परिणामों से बचा जा सकता है: ग्रहण किया गया मान कभी नहीं बदलता, इसलिए क्लोज़र का व्यवहार अनुमानित रहता है। फ़ंक्शनल कोड में val को ग्रहण करना प्राथमिकता दें।

object Main {
  def main(args: Array[String]): Unit = {
    val taxRate = 0.2
    val withTax = (price: Double) => price * (1 + taxRate)
    println(withTax(100))
  }
}

संग्रह विधियों के साथ क्लोज़र

map, filter आदि में पास किए गए लैम्ब्डा तब क्लोज़र होते हैं, जब वे बाहरी चरों का संदर्भ लेते हैं। रोज़मर्रा के Scala में यह बहुत सामान्य है।

object Main {
  def main(args: Array[String]): Unit = {
    val threshold = 3
    val nums = List(1, 2, 3, 4, 5)
    val big = nums.filter(_ > threshold)
    println(big)
  }
}

लूप में ग्रहण करने की एक समस्या

Scala में for लूप का चर हर पुनरावृत्ति में नया बाइंडिंग होता है, इसलिए क्लोज़र अलग-अलग मान ग्रहण करते हैं। इससे कुछ अन्य भाषाओं में दिखाई देने वाले एक सामान्य बग से बचा जाता है।

object Main {
  def main(args: Array[String]): Unit = {
    val fns = for (i <- 1 to 3) yield () => i
    println(fns.map(f => f()))
  }
}

क्लोज़र व्यवहार और डेटा को समाहित करते हैं

क्लोज़र व्यवहार (फ़ंक्शन का मुख्य भाग) और डेटा (ग्रहण किए गए चर) को एक साथ बाँधता है। यह एक विधि वाली छोटी ऑब्जेक्ट का हल्का विकल्प है।

object Main {
  def discounter(rate: Double): Double => Double = price => price * (1 - rate)
  def main(args: Array[String]): Unit = {
    val sale = discounter(0.25)
    println(sale(80))
    println(sale(200))
  }
}

त्वरित जाँच

क्लोज़र अपने बाहरी स्कोप से क्या ग्रहण करता है?

पुनरावृत्ति

आपने क्लोज़र के बारे में सीखा:

  • क्लोज़र अपने बाहरी स्कोप से मुक्त चर ग्रहण करता है
  • ग्रहण किए गए चर परिभाषित करने वाले फ़ंक्शन से अधिक समय तक जीवित रहते हैं
  • हर क्लोज़र इंस्टेंस की अपनी ग्रहण की हुई स्थिति होती है
  • क्लोज़र संदर्भ ग्रहण करते हैं, इसलिए परिवर्तनीय ग्रहण बदले जा सकते हैं
  • map/filter के लैम्ब्डा रोज़मर्रा के क्लोज़र हैं
शुरुआत निःशुल्क

एआई शिक्षक के साथ Scala सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम
39
पाठ
143

अक्सर पूछे जाने वाले प्रश्न

क्या “Closures” पाठ निःशुल्क है?

हाँ—“Closures” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“Closures” में मैं क्या सीखूँगा?

State capture करना आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 4वाँ पाठ है।

“Closures” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ में कोड लिख और चला सकता हूँ?

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

इस पाठ्यक्रम के सभी पाठ

  1. Functions को Values की तरह उपयोग करना
  2. Currying
  3. Composition
  4. Closures
← बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पर वापस जाएँ