Groovy क्लोज़र को समझना
क्लोज़र की अवधारणा, उन्हें परिभाषित करने का तरीका और Groovy में उनके बहुमुखी उपयोग सीखें।
Groovy क्लोज़र को समझना, CoddyKit पर Groovy और Gradle: JVM स्वचालन और बिल्ड इंजीनियरिंग का एक निःशुल्क पाठ है। यह 4 में से 2वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह Groovy और Gradle: JVM स्वचालन और बिल्ड इंजीनियरिंग सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Groovy और Gradle: JVM स्वचालन और बिल्ड इंजीनियरिंग पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
Groovy क्लोज़र क्या हैं?
Groovy क्लोज़र की दुनिया में आपका स्वागत है! क्लोज़र मूल रूप से कोड का ऐसा खंड है जिसे वेरिएबल की तरह इस्तेमाल किया जा सकता है।
इसे एक छोटे फ़ंक्शन की तरह समझिए, जिसे आप परिभाषित, सहेज और इधर-उधर भेज सकते हैं। क्लोज़र Groovy की ऐसी शक्तिशाली सुविधा हैं जो कोड को बहुत लचीला और संक्षिप्त बनाती हैं।
- ये प्रथम-श्रेणी इकाइयाँ हैं, अर्थात इन्हें वेरिएबल में रखा जा सकता है, तर्क के रूप में भेजा जा सकता है और मेथड से लौटाया जा सकता है।
- ये अपने आसपास के कार्य-क्षेत्र से वेरिएबल कैप्चर कर सकते हैं, यहाँ तक कि उस कार्य-क्षेत्र का निष्पादन समाप्त होने के बाद भी।
क्लोज़र का मूल वाक्य-विन्यास
क्लोज़र परिभाषित करना सरल है। अपने कोड-खंड को घुंघराले कोष्ठकों {} के भीतर लिखिए। एक सरल उदाहरण देखते हैं:
class Main {
static void main(String[] args) {
// Define a simple closure
def sayHello = {
println "Hello from a closure!"
}
// Call (execute) the closure
sayHello()
}
}पैरामीटर वाले क्लोज़र
मेथड की तरह क्लोज़र भी पैरामीटर स्वीकार कर सकते हैं। पैरामीटरों को -> (तीर) ऑपरेटर से पहले लिखिए और उसके बाद क्लोज़र का मुख्य भाग लिखिए।
इससे आपका क्लोज़र प्राप्त इनपुट के आधार पर कार्य कर सकता है।
class Main {
static void main(String[] args) {
// Closure that takes two parameters
def add = { num1, num2 ->
return num1 + num2
}
// Call the closure with arguments
def result = add(10, 5)
println "Sum: ${result}"
// You can also omit 'return' for the last statement
def multiply = { a, b -> a * b }
println "Product: ${multiply(4, 3)}"
}
}`it` कीवर्ड
जब कोई क्लोज़र ठीक एक पैरामीटर लेता है, तो Groovy it नाम का एक विशेष अंतर्निहित वेरिएबल उपलब्ध कराती है। आपको it को स्पष्ट रूप से घोषित करने की आवश्यकता नहीं होती।
इससे एक-पैरामीटर वाले क्लोज़र और भी संक्षिप्त व पठनीय बनते हैं, विशेषकर संग्रह मेथड के साथ उपयोग करते समय।
class Main {
static void main(String[] args) {
// Closure using 'it' for a single parameter
def square = { it * it }
println "Square of 7: ${square(7)}"
def greetPerson = { "Hello, ${it}!" }
println greetPerson("Alice")
}
}मेथड तर्क के रूप में क्लोज़र
Groovy में क्लोज़र के सबसे सामान्य और शक्तिशाली उपयोगों में से एक है उन्हें मेथड के तर्क के रूप में भेजना। Groovy के अनेक मेथड, विशेषकर संग्रहों वाले मेथड, क्लोज़र स्वीकार करने के लिए बनाए गए हैं।
यदि क्लोज़र किसी मेथड का अंतिम तर्क हो, तो आप उसे कोष्ठकों के बाहर लिख सकते हैं, जिससे कोड बहुत साफ़ और DSL-जैसा दिखता है।
class Main {
static void main(String[] args) {
def numbers = [1, 2, 3, 4, 5]
// Using 'each' with a closure to iterate
numbers.each { num ->
println "Number: ${num}"
}
println "---"
// Using 'collect' with a closure to transform
def doubledNumbers = numbers.collect { it * 2 }
println "Doubled: ${doubledNumbers}"
}
}वेरिएबल कैप्चर करना: शाब्दिक कार्य-क्षेत्र
क्लोज़र का शाब्दिक कार्य-क्षेत्र होता है, अर्थात उन्हें उस कार्य-क्षेत्र के वेरिएबल याद रहते हैं और वे उन तक पहुँच सकते हैं जहाँ उन्हें परिभाषित किया गया था, भले ही वह कार्य-क्षेत्र अब मौजूद न हो।
यह एक प्रमुख विशेषता है जो क्लोज़र को सामान्य मेथड से अलग करती है और उन्हें संदर्भ अपने साथ रखने देती है।
class Main {
static void main(String[] args) {
def name = "Groovy User" // Variable in the outer scope
def introduce = {
// The closure 'introduce' captures 'name'
println "My name is ${name}."
}
introduce() // Calls the closure, accessing 'name'
name = "CoddyKit Enthusiast" // Change the outer variable
introduce() // The closure still references the updated 'name'
}
}कैप्चर किए गए वेरिएबल बदलना
क्लोज़र न केवल कैप्चर किए गए वेरिएबल तक पहुँच सकते हैं, बल्कि उन्हें बदल भी सकते हैं। इससे क्लोज़र अपने आसपास के वातावरण के साथ संवाद करने का शक्तिशाली तरीका बन जाते हैं।
क्लोज़र के भीतर बाहरी वेरिएबल बदलते समय सावधान रहें, क्योंकि सावधानी से प्रबंधित न करने पर कोड का व्यवहार कभी-कभी कम अनुमानित हो सकता है।
class Main {
static void main(String[] args) {
def counter = 0 // A variable to be captured
def increment = {
counter++ // Closure modifies the outer 'counter'
println "Counter is now: ${counter}"
}
increment() // Counter: 1
increment() // Counter: 2
increment() // Counter: 3
println "Final counter value: ${counter}"
}
}क्लोज़र का 'call()' मेथड
क्लोज़र को केवल कोष्ठकों का उपयोग करके चलाया जा सकता है, जैसे myClosure(); लेकिन वास्तव में क्लोज़र groovy.lang.Closure क्लास के उदाहरण होते हैं।
इसलिए उनमें call() मेथड भी होता है। call() का उपयोग सीधे चलाने के बराबर है और स्पष्टता के लिए या क्लोज़र को गतिशील रूप से कॉल करते समय कभी-कभी उपयोगी हो सकता है।
class Main {
static void main(String[] args) {
def greet = { name ->
println "Hello, ${name}!"
}
// Direct execution
greet("World")
// Execution using the call() method
greet.call("Groovy")
def add = { a, b -> a + b }
println add.call(5, 7)
}
}व्यावहारिक उपयोग: सूचियों को छाँटना
आइए, एक व्यावहारिक उदाहरण के साथ क्लोज़र का उपयोग करें: सूची से तत्वों को छाँटना। Groovy के संग्रह मेथड, जैसे findAll, इसके लिए बिल्कुल उपयुक्त हैं।
आप एक ऐसा क्लोज़र देते हैं जो शामिल किए जाने की शर्त तय करता है, और findAll केवल उन तत्वों वाली नई सूची लौटाता है जो उस शर्त को पूरा करते हैं।
class Main {
static void main(String[] args) {
def numbers = [10, 25, 12, 30, 5, 45, 20]
// Find numbers greater than 20
def largeNumbers = numbers.findAll { it > 20 }
println "Numbers > 20: ${largeNumbers}"
// Find even numbers
def evenNumbers = numbers.findAll { it % 2 == 0 }
println "Even numbers: ${evenNumbers}"
}
}क्लोज़र अवधारणाओं की जाँच
Groovy क्लोज़र के बारे में निम्नलिखित में से कौन-से कथन सही हैं?
पुनरावलोकन: क्लोज़र को समझना
बहुत बढ़िया! आपने Groovy के शक्तिशाली क्लोज़र को समझने की दिशा में महत्वपूर्ण कदम उठाया है।
आइए, अब तक सीखी बातों का संक्षिप्त सारांश देखें:
- क्लोज़र कोड ब्लॉक होते हैं, जिन्हें प्रथम श्रेणी के नागरिकों की तरह माना जाता है।
- इनकी परिभाषा के लिए
{}और पैरामीटर के लिए->का उपयोग किया जाता है। itकीवर्ड एकल-पैरामीटर वाले क्लोज़र को सरल बनाता है।- क्लोज़र को अक्सर मेथड आर्ग्युमेंट के रूप में पास किया जाता है, जिससे Groovy की अभिव्यक्तिपूर्ण क्षमता बढ़ती है।
- इनका लेक्सिकल स्कोप होता है, इसलिए ये अपने आसपास के संदर्भ के वेरिएबल को पकड़ सकते हैं और उनमें बदलाव भी कर सकते हैं।
अगले पाठ में हम देखेंगे कि Groovy में कार्यात्मक प्रोग्रामिंग के पैटर्न पर क्लोज़र कैसे लागू किए जाते हैं!
एआई शिक्षक के साथ Groovy सीखें — निःशुल्क
अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।
- पाठ्यक्रम
- 12
- पाठ
- 48
अक्सर पूछे जाने वाले प्रश्न
क्या “Groovy क्लोज़र को समझना” पाठ निःशुल्क है?
हाँ—“Groovy क्लोज़र को समझना” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और Groovy और Gradle: JVM स्वचालन और बिल्ड इंजीनियरिंग पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। Groovy और Gradle: JVM स्वचालन और बिल्ड इंजीनियरिंग पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
“Groovy क्लोज़र को समझना” में मैं क्या सीखूँगा?
क्लोज़र की अवधारणा, उन्हें परिभाषित करने का तरीका और Groovy में उनके बहुमुखी उपयोग सीखें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Groovy और Gradle: JVM स्वचालन और बिल्ड इंजीनियरिंग का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।
क्या Groovy और Gradle: JVM स्वचालन और बिल्ड इंजीनियरिंग शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?
पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Groovy और Gradle: JVM स्वचालन और बिल्ड इंजीनियरिंग शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 2वाँ पाठ है।
“Groovy क्लोज़र को समझना” पाठ पूरा करने में कितना समय लगता है?
CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।
क्या मैं इस Groovy और Gradle: JVM स्वचालन और बिल्ड इंजीनियरिंग पाठ में कोड लिख और चला सकता हूँ?
हाँ। हर Groovy और Gradle: JVM स्वचालन और बिल्ड इंजीनियरिंग पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।
इस पाठ्यक्रम के सभी पाठ
- Groovy संग्रहों में सुधार
- Groovy क्लोज़र को समझना
- Groovy के साथ कार्यात्मक प्रतिरूप
- करीइंग और क्लोज़र संयोजन