Guards और Binding
Matches में conditions
Guards और Binding, CoddyKit पर बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala का एक निःशुल्क पाठ है। यह 4 में से 3वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
गार्ड क्या है?
गार्ड if का उपयोग करके किसी केस में बूलियन शर्त जोड़ता है। केस तभी मेल खाता है जब पैटर्न सही बैठे और गार्ड सत्य हो।
गार्ड किसी एक पैटर्न को मान के आधार पर अधिक सूक्ष्म केसों में बाँटने देते हैं।
if गार्ड जोड़ना
गार्ड को पैटर्न के बाद लिखें: case n if n > 0 =>। यदि शर्त असत्य है, तो मिलान अगले केस पर जारी रहता है।
object Main {
def sign(n: Int): String = n match {
case x if x > 0 => "positive"
case x if x < 0 => "negative"
case _ => "zero"
}
def main(args: Array[String]): Unit = {
println(sign(5))
println(sign(-3))
println(sign(0))
}
}पहले बाँधना, फिर गार्ड लगाना
गार्ड उस नाम का संदर्भ ले सकता है जिसे आपने पैटर्न में बाँधा है। इसी तरह आप मिलान किए गए मान के गुणों की जाँच करते हैं।
object Main {
def fizz(n: Int): String = n match {
case x if x % 15 == 0 => "FizzBuzz"
case x if x % 3 == 0 => "Fizz"
case x if x % 5 == 0 => "Buzz"
case x => x.toString
}
def main(args: Array[String]): Unit = {
println(fizz(15))
println(fizz(9))
println(fizz(7))
}
}रेंज पर गार्ड
रेंज के लिए गार्ड बिल्कुल उपयुक्त हैं, जिन्हें लिटरल पैटर्न सीधे व्यक्त नहीं कर सकते।
object Main {
def band(score: Int): String = score match {
case s if s >= 90 => "A"
case s if s >= 80 => "B"
case s if s >= 70 => "C"
case _ => "F"
}
def main(args: Array[String]): Unit = {
println(band(95))
println(band(83))
println(band(60))
}
}@ के साथ पैटर्न बाँधना
@ चिह्न पूरे मिलान किए गए मान को किसी नाम से बाँधता है और साथ ही उसकी संरचना का पैटर्न मिलान भी करता है।
यहाँ whole @ pattern का अर्थ है: pattern से मिलान करें और मिलान किए गए मान को whole नाम दें।
object Main {
def main(args: Array[String]): Unit = {
val x: Any = 7
val msg = x match {
case n @ (_: Int) => s"int value is $n"
case _ => "other"
}
println(msg)
}
}संग्रहों में बाँधना
@ बाइंडिंग संरचित पैटर्न के साथ विशेष रूप से उपयोगी है, जैसे सूची के शीर्ष तत्व की जाँच करते हुए पूरी सूची को भी कैप्चर करना।
object Main {
def describe(xs: List[Int]): String = xs match {
case all @ (first :: _) => s"starts with $first, full = $all"
case Nil => "empty"
}
def main(args: Array[String]): Unit = {
println(describe(List(1, 2, 3)))
println(describe(Nil))
}
}प्रकार पैटर्न और गार्ड का संयोजन
आप प्रकार पैटर्न को गार्ड के साथ मिला सकते हैं। पहले प्रकार की जाँच होती है, फिर बूलियन शर्त की।
object Main {
def label(x: Any): String = x match {
case s: String if s.length > 3 => "long string"
case s: String => "short string"
case _ => "not a string"
}
def main(args: Array[String]): Unit = {
println(label("hello"))
println(label("hi"))
println(label(42))
}
}कई शर्तें
गार्ड केवल एक बूलियन अभिव्यक्ति है, इसलिए आप && और || के साथ शर्तों को संयोजित कर सकते हैं।
object Main {
def category(age: Int): String = age match {
case a if a >= 13 && a <= 19 => "teen"
case a if a < 13 => "child"
case _ => "adult"
}
def main(args: Array[String]): Unit = {
println(category(15))
println(category(8))
println(category(40))
}
}गार्ड अगले केस में जाता है
यदि कोई पैटर्न मेल खाता है लेकिन उसका गार्ड असत्य है, तो Scala उसी पैटर्न के अगले गार्ड पर नहीं, बल्कि अगले केस पर जाती है।
सुनिश्चित करें कि बाद का कोई केस उन मानों को पकड़ सके जो हर गार्ड में विफल हों।
object Main {
def test(n: Int): String = n match {
case x if x > 100 => "big"
case x => s"not big: $x"
}
def main(args: Array[String]): Unit = {
println(test(200))
println(test(5))
}
}गार्ड और बाइंडिंग क्यों?
गार्ड और @ बाइंडिंग मिलकर पैटर्न मिलान को अभिव्यक्तिपूर्ण बनाते हैं:
- गार्ड रेंज और विभाज्यता जैसी शर्तें जोड़ते हैं
@मान की संरचना अलग करते हुए पूरे मान को कैप्चर करता है- वे शाखाकरण तर्क को संक्षिप्त और पठनीय रखते हैं
सबको एक साथ जोड़ना
यह उदाहरण मान को बाँधता है, गार्ड की जाँच करता है और वैकल्पिक व्यवस्था प्रदान करता है।
object Main {
def temp(c: Int): String = c match {
case t if t >= 30 => s"hot ($t)"
case t if t >= 15 => s"mild ($t)"
case t => s"cold ($t)"
}
def main(args: Array[String]): Unit = {
println(temp(35))
println(temp(20))
println(temp(5))
}
}त्वरित जाँच
गार्ड और बाइंडिंग की अपनी समझ को Test करें।
पुनरावृत्ति
आपने मिलानों को अधिक विशिष्ट बनाना सीखा:
- गार्ड पैटर्न के बाद आने वाली
ifशर्त है - गार्ड असत्य होने पर मिलान अगले केस पर चला जाता है
@ऑपरेटर संरचना अलग करते हुए पूरे मान को बाँधता है- गार्ड प्रकार पैटर्न और बूलियन ऑपरेटर के साथ संयोजित किए जा सकते हैं
एआई शिक्षक के साथ Scala सीखें — निःशुल्क
अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।
- पाठ्यक्रम
- 39
- पाठ
- 143
अक्सर पूछे जाने वाले प्रश्न
क्या “Guards और Binding” पाठ निःशुल्क है?
हाँ—“Guards और Binding” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
“Guards और Binding” में मैं क्या सीखूँगा?
Matches में conditions आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।
क्या बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?
पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 3वाँ पाठ है।
“Guards और Binding” पाठ पूरा करने में कितना समय लगता है?
CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।
क्या मैं इस बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ में कोड लिख और चला सकता हूँ?
हाँ। हर बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।
इस पाठ्यक्रम के सभी पाठ
- match Expressions
- Types और Values का Matching
- Guards और Binding
- Deconstruction