Scala Language
tuples

टिप्पणियों

एक नया टपल बनाना

एक टपल दो से बाईस मानों का एक विषम संग्रह है। कोष्ठक का उपयोग करके एक टपल को परिभाषित किया जा सकता है। आकार 2 के टुपल्स के लिए (जिसे 'जोड़ी' भी कहा जाता है) एक तीर वाक्यविन्यास है।

scala> val x = (1, "hello") 
x: (Int, String) = (1,hello)
scala> val y = 2 -> "world" 
y: (Int, String) = (2,world)
scala> val z = 3 → "foo"     //example of using U+2192 RIGHTWARD ARROW
z: (Int, String) = (3,foo)

x आकार दो का एक टपल है। एक tuple के तत्वों का उपयोग करने के लिए ._1 , through ._22 । उदाहरण के लिए, हम x tuple के पहले तत्व तक पहुँचने के लिए x._1 का उपयोग कर सकते हैं। x._2 दूसरे तत्व तक पहुँचता है। अधिक सुरुचिपूर्ण ढंग से, आप टपल निकालने वाले का उपयोग कर सकते हैं ।

दो आकार के ट्यूल बनाने के लिए तीर सिंटैक्स मुख्य रूप से मैप्स में उपयोग किया जाता है, जो कि (key -> value) जोड़े का संग्रह है:

scala> val m = Map[Int, String](2 -> "world")
m: scala.collection.immutable.Map[Int,String] = Map(2 -> world)

scala> m + x
res0: scala.collection.immutable.Map[Int,String] = Map(2 -> world, 1 -> hello)

scala> (m + x).toList
res1: List[(Int, String)] = List((2,world), (1,hello))

नक्शे में जोड़ी के लिए वाक्यविन्यास तीर वाक्यविन्यास है, जिससे यह स्पष्ट होता है कि 1 कुंजी है और उस कुंजी के साथ जुड़ा हुआ मूल्य है।

संग्रह के भीतर ट्यूपल

टुपल्स का उपयोग अक्सर संग्रह के भीतर किया जाता है लेकिन उन्हें एक विशिष्ट तरीके से नियंत्रित किया जाना चाहिए। उदाहरण के लिए, टुपल्स की निम्नलिखित सूची दी गई है:

scala> val l = List(1 -> 2, 2 -> 3, 3 -> 4)
l: List[(Int, Int)] = List((1,2), (2,3), (3,4))

निहित टपल-अनपैकिंग का उपयोग करके तत्वों को एक साथ जोड़ना स्वाभाविक लग सकता है:

scala> l.map((e1: Int, e2: Int) => e1 + e2)

हालाँकि यह निम्न त्रुटि के कारण होता है:

<console>:9: error: type mismatch;
 found   : (Int, Int) => Int
 required: ((Int, Int)) => ?
              l.map((e1: Int, e2: Int) => e1 + e2)

स्केल इस तरीके से ट्यूपलों को अलग नहीं कर सकता है। इस नक्शे को ठीक करने के लिए हमारे पास दो विकल्प हैं। पहला स्थितीय _1 और _2 का उपयोग करना है:

scala> l.map(e => e._1 + e._2)
res1: List[Int] = List(3, 5, 7)

अन्य विकल्प पैटर्न मिलान का उपयोग करके टुपल्स को अनपैक करने के लिए case स्टेटमेंट का उपयोग करना है:

scala> l.map{ case (e1: Int, e2: Int) => e1 + e2}
res2: List[Int] = List(3, 5, 7)

ये प्रतिबंध टुपल्स के संग्रह पर लागू किसी भी उच्च-क्रम-फ़ंक्शन के लिए लागू होते हैं।