Scala Language
स्ट्रिंग इंटरपोलेशन

टिप्पणियों

हैलो स्ट्रिंग इंटरपोलेशन

एस इंटरपोलर एक स्ट्रिंग के भीतर चर के उपयोग की अनुमति देता है।

val name = "Brian"
println(s"Hello $name")

"हैलो ब्रायन" प्रिंट जब सांत्वना के लिए।

एफ इंटरपोलर का उपयोग करके प्रारूपित स्ट्रिंग इंटरपोलेशन

val num = 42d

F का उपयोग कर num लिए दो दशमलव स्थानों को प्रिंट करें

println(f"$num%2.2f")
42.00

ई का उपयोग करके वैज्ञानिक संकेतन का उपयोग करके num प्रिंट करें

println(f"$num%e")
4.200000e+01

एक के साथ हेक्साडेसिमल में num प्रिंट करें

println(f"$num%a")
0x1.5p5

अन्य प्रारूप के तार https://docs.oracle.com/javase/6/docs/api/java/util/Formatter.html#detail पर देखे जा सकते हैं

स्ट्रिंग लीटर में अभिव्यक्ति का उपयोग करना

आप कर्ल ब्रेसिज़ का उपयोग स्ट्रिंग शाब्दिक में भावों को व्यक्त करने के लिए कर सकते हैं:

def f(x: String) = x + x
val a = "A"

s"${a}"    // "A"
s"${f(a)}" // "AA"

ब्रेसिज़ के बिना, स्केला केवल $ (इस मामले में f ) के बाद पहचानकर्ता को प्रक्षेपित करेगा। चूँकि String से f तक कोई निहित रूपांतरण नहीं है, यह इस उदाहरण में एक अपवाद है:

s"$f(a)"  // compile-time error (missing argument list for method f)

कस्टम स्ट्रिंग इंटरपोलर

अंतर्निहित लोगों के अलावा कस्टम स्ट्रिंग इंटरपोलर को परिभाषित करना संभव है।

my"foo${bar}baz"

संकलक द्वारा इसका विस्तार किया जाता है:

new scala.StringContext("foo", "baz").my(bar)

scala.StringContext पास my कोई विधि नहीं है, इसलिए इसे अंतर्निहित रूपांतरण द्वारा प्रदान किया जा सकता है। अंतर्निहित रूप में एक ही व्यवहार के साथ एक कस्टम क्षेपक s क्षेपक तो इस प्रकार लागू किया जाएगा:

implicit class MyInterpolator(sc: StringContext) {
  def my(subs: Any*): String = {
    val pit = sc.parts.iterator
    val sit = subs.iterator
    // Note parts.length == subs.length + 1
    val sb = new java.lang.StringBuilder(pit.next())
    while(sit.hasNext) {
      sb.append(sit.next().toString)
      sb.append(pit.next())          
    }
    sb.toString
  }
}

और प्रक्षेप my"foo${bar}baz" बाज my"foo${bar}baz" होगा:

new MyInterpolation(new StringContext("foo", "baz")).my(bar)

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

case class Let(name: Char, value: Int)

implicit class LetInterpolator(sc: StringContext) {
  def let(value: Int): Let = Let(sc.parts(0).charAt(0), value)
}

let"a=${4}" // Let(a, 4)
let"b=${"foo"}" // error: type mismatch
let"c=" // error: not enough arguments for method let: (value: Int)Let

अर्क के रूप में स्ट्रिंग प्रक्षेपक

यह भी संभव है कि स्काला के स्ट्रिंग इंटरपोलेशन फ़ीचर का उपयोग विस्तृत एक्सट्रैक्टर्स (पैटर्न मैचर्स) बनाने के लिए किया जाए, क्योंकि शायद स्काला मैक्रोज़ के क्वासिकोट्स एपीआई में सबसे अधिक प्रसिद्ध है।

यह देखते हुए कि n"p0${i0}p1" new StringContext("p0", "p1").n(i0) , यह शायद इस बात से new StringContext("p0", "p1").n(i0) करता है कि एक्स्ट्रेक्टर कार्यक्षमता StringContext से एक वर्ग के साथ एक अंतर्निहित रूपांतरण प्रदान करने में सक्षम है। संपत्ति n एक प्रकार का एक परिभाषित करने unapply या unapplySeq विधि।

एक उदाहरण के रूप में, निम्न एक्सट्रैक्टर पर विचार करें जो StringContext भागों से एक नियमित अभिव्यक्ति का निर्माण करके पथ खंडों को निकालता है। इसके बाद हम unapplySeq लिए सबसे भारी उठाने की विधि सौंप सकते हैं, जिसके परिणामस्वरूप scala.util.matching.Regex द्वारा प्रदान किया गया है:

implicit class PathExtractor(sc: StringContext) {
  object path {
    def unapplySeq(str: String): Option[Seq[String]] =
      sc.parts.map(Regex.quote).mkString("^", "([^/]+)", "$").r.unapplySeq(str)      
  }
}

"/documentation/scala/1629/string-interpolation" match {
  case path"/documentation/${topic}/${id}/${_}" => println(s"$topic, $id")
  case _ => ???
}

ध्यान दें कि path ऑब्जेक्ट एक apply विधि को भी परिभाषित कर सकता है ताकि एक नियमित प्रक्षेपक के रूप में भी व्यवहार किया जा सके।

रॉ स्ट्रिंग इंटरपोलेशन

आप कच्चे इंटरपोलर का उपयोग कर सकते हैं यदि आप चाहते हैं कि एक स्ट्रिंग को मुद्रित किया जाए और वह भी बिना शाब्दिक भाग के।

println(raw"Hello World In English And French\nEnglish:\tHello World\nFrench:\t\tBonjour Le Monde")

कच्चे प्रक्षेपक के उपयोग के साथ, आपको कंसोल में मुद्रित निम्नलिखित देखना चाहिए:

Hello World In English And French\nEnglish:\tHello World\nFrench:\t\tBonjour Le Monde

कच्चे प्रक्षेपक के बिना, \n और \t बच जाते थे।

println("Hello World In English And French\nEnglish:\tHello World\nFrench:\t\tBonjour Le Monde")

प्रिंटों:

Hello World In English And French
English:       Hello World
French:        Bonjour Le Monde