Scala Language
भाव के लिए

वाक्य - विन्यास

• {क्लाज} शरीर के लिए
• {क्लाज} के लिए शरीर प्राप्त करें
• (खंड) शरीर के लिए
• के लिए (खंड) उपज शरीर

पैरामीटर

बुनियादी लूप के लिए

for (x <- 1 to 10)
  println("Iteration number " + x)

यह 1 से 10 तक चर, x पुन: प्रदर्शित करता है और उस मान के साथ कुछ करता है। समझ के for इसका वापसी प्रकार Unit ।

बुनियादी समझ के लिए

यह फॉर-लूप पर एक फ़िल्टर प्रदर्शित करता है, और yield का उपयोग 'अनुक्रम समझ' बनाने के लिए करता है:

for ( x <- 1 to 10 if x % 2 == 0)
  yield x

इसके लिए आउटपुट है:

scala.collection.immutable.IndexedSeq[Int] = Vector(2, 4, 6, 8, 10)

जब आप पुनरावृत्‍ति के आधार पर एक नया संग्रह बनाना चाहते हैं, तो यह समझ के लिए उपयोगी है।

नेस्ट फॉर लूप

यह दिखाता है कि आप कई चर पर कैसे पुनरावृति कर सकते हैं:

for {
  x <- 1 to 2
  y <- 'a' to 'd'
} println("(" + x + "," + y + ")")

(ध्यान दें कि to एक इन्फ़िक्स ऑपरेटर विधि है कि एक रिटर्न है यहाँ समावेशी रेंज । परिभाषा को देखें यहाँ ।)

यह आउटपुट बनाता है:

(1,a)
(1,b)
(1,c)
(1,d)
(2,a)
(2,b)
(2,c)
(2,d)

ध्यान दें कि यह एक समतुल्य अभिव्यक्ति है, कोष्ठक के बजाय कोष्ठक का उपयोग करते हुए:

for (
  x <- 1 to 2
  y <- 'a' to 'd'
) println("(" + x + "," + y + ")")

सभी संयोजनों को एकल वेक्टर में लाने के लिए, हम परिणाम yield कर सकते हैं और इसे val सेट कर सकते हैं:

val a = for {
  x <- 1 to 2
  y <- 'a' to 'd'
} yield "(%s,%s)".format(x, y)
// a: scala.collection.immutable.IndexedSeq[String] = Vector((1,a), (1,b), (1,c), (1,d), (2,a), (2,b), (2,c), (2,d))

समझ के लिए मौद्रिक

यदि आपके पास कई प्रकार के मोनैडिक प्रकार हैं, तो हम 'समझ के लिए' का उपयोग करके मूल्यों के संयोजन प्राप्त कर सकते हैं:

for {
   x <- Option(1)
   y <- Option("b")
   z <- List(3, 4)
} {
    // Now we can use the x, y, z variables
    println(x, y, z)
    x  // the last expression is *not* the output of the block in this case!
}

// This prints
// (1, "b", 3)
// (1, "b", 4)

इस ब्लॉक का रिटर्न टाइप Unit ।

यदि वस्तुएं एक ही समान प्रकार के M (जैसे Option ) तो yield का उपयोग करने से Unit बजाय टाइप M का एक ऑब्जेक्ट वापस आ जाएगा।

val a = for {
   x <- Option(1)
   y <- Option("b")
} yield {
    // Now we can use the x, y variables
    println(x, y)
    // whatever is at the end of the block is the output
    (7 * x, y)
}

// This prints:
// (1, "b")
// The val `a` is set:
// a: Option[(Int, String)] = Some((7,b))

ध्यान दें कि yield कीवर्ड का उपयोग मूल उदाहरण में नहीं किया जा सकता है, जहां मोनैडिक प्रकार ( Option और List ) का मिश्रण है। ऐसा करने की कोशिश करने से एक संकलन-समय प्रकार बेमेल त्रुटि होगी।

एक लूप के लिए संग्रह के माध्यम से Iterate

यह दर्शाता है कि मानचित्र के प्रत्येक तत्व को कैसे प्रिंट किया जाए

val map = Map(1 -> "a", 2 -> "b")
for (number <- map) println(number) // prints (1,a), (2,b)
for ((key, value) <- map) println(value) // prints a, b

यह दर्शाता है कि सूची के प्रत्येक तत्व को कैसे प्रिंट किया जाए

val list = List(1,2,3)
for(number <- list) println(number) // prints 1, 2, 3

समझ के लिए उतरना

Scala में समझ के for बस वाक्यविन्यास चीनी हैं । ये flatMap अपने विषय प्रकारों के withFilter , foreach , flatMap और map विधियों का उपयोग करके कार्यान्वित की withFilter हैं। इस कारण से, इन विधियों को परिभाषित करने वाले केवल प्रकारों का उपयोग एक समझ के for किया जा सकता है।

एक for निम्न प्रपत्र की समझ, पैटर्न के साथ pN , जेनरेटर gN और शर्तों cN :

for(p0 <- x0 if g0; p1 <- g1 if c1) { ??? }

... डी-चीनी का उपयोग कर नेस्टेड कॉल करने के लिए होगा withFilter और foreach :

g0.withFilter({ case p0 => c0  case _ => false }).foreach({
  case p0 => g1.withFilter({ case p1 => c1  case _ => false }).foreach({
    case p1 => ???
  })
})

जबकि एक for / yield निम्नलिखित फार्म की अभिव्यक्ति:

for(p0 <- g0 if c0; p1 <- g1 if c1) yield ???

... डी-शुगर के साथ नेस्टेड कॉल के साथ withFilter और flatMap map या map का उपयोग withFilter :

g0.withFilter({ case p0 => c0  case _ => false }).flatMap({
  case p0 => g1.withFilter({ case p1 => c1  case _ => false }).map({
    case p1 => ???
  })
})

(ध्यान दें कि map का उपयोग अंतरतम समझ में किया जाता है, और flatMap का उपयोग हर बाहरी समझ में किया जाता है।)

डी-सुगरेड प्रतिनिधित्व द्वारा आवश्यक तरीकों को लागू करने के लिए किसी भी प्रकार के for एक समझ के for लागू किया जा सकता है। इन विधियों के वापसी प्रकारों पर कोई प्रतिबंध नहीं है, इसलिए जब तक वे रचना करने योग्य होते हैं।