String Interpolation in Scala
Download as ODP, PDF1 like3,884 views
The document provides an overview of string interpolation in Scala, introducing its concepts and various interpolators such as s, f, and raw. It explains how to embed variable values and expressions within string literals, making string formatting more intuitive. Additionally, it covers type safety with the f interpolator and the ability to define custom interpolators.
String Interpolation in Scala
- 1. String Interpolation In Scala Ruchi Agarwal Software Consultant Knoldus Software LLP
- 2. Index: ● ● ● Introduction String Interpolation in Scala Usage ● The s String Interpolator ● ● ● Using expressions in string literals The f Interpolator The raw Interpolator
- 3. Introduction: - String interpolation is the replacement of defined character sequences in the string by values or variable values. - Its common in many programming languages which make heavy use of string representations of data, such as Python, Ruby, PHP, Perl, Scala etc. - It means to insert a string or replace a variable with its value. It makes string formatting and specifying contents more intuitive - Variable interpolation is variable substitution with its value inside a string - Variable interpolation occurs when the string literal is double-quoted, but not when it is single-quoted - The variables are recognized because variables start with a sigil (typically "$") - Java doesn't support variable interpolation, but it supports more advanced interpolation with a special formatting function, such as printf, in which the first argument, the format, specifies the pattern in which the remaining arguments are substituted
- 4. Example: String name = "James"; String output = String.format("Hello %s !", name); System.out.printf(“Hello %s !”, name); System.out.format(“Hello %s !”, name); //string formatting
- 5. String Interpolation in Scala: - Starting in Scala 2.10.0, Scala offers a new mechanism to create strings from data: String Interpolation - String interpolation was introduced by SIP-11, which contains all details of the implementation - String Interpolation allows users to embed variable references directly in processed string literals. Example: scala> val name = "James" name: String = James scala> println(s"Hello, $name !") Hello, James ! - In the above, the literal s"Hello, $name" is a processed string literal. This means that the compiler does some additional work to this literal. A processed string literal is denoted by a set of characters precedding the "
- 6. The s String Interpolator: - Prepending s to any string literal allows the usage of variables directly in the string Example: scala> val name = "James" name: String = James scala> println(s"Hello, $name !") Hello, James ! - Here $name is nested inside an s processed string. - The s interpolator insert the value of the name variable at this location in the string, resulting in the string Hello, James - With the s interpolator, any name that is in scope can be used within a string
- 7. Using expressions in string literals: - In addition to putting variables inside strings, we can include expressions ( arbitrary expressions) inside a string by placing the expression inside curly braces Example: scala> println(s"1 + 1 = ${1 + 1}") 1+1=2 - Any arbitrary expression can be embedded in ${} - Also need to use curly braces when printing object fields. Example: scala> case class Student(name: String, score: Int) defined class Student scala> val student = Student("James", 95) student: Student = Student(James,95) scala> println(s"${student.name} has a score of ${student.score}") James has a score of 95
- 8. - Attempting to print the values of the object fields without wrapping them in curly braces results in the wrong information being printed out: // error: this is intentionally wrong scala> println(s"$student.name has a score of $student.score") Student(James,95).name has a score of Student(James,95).score - Because $student.name wasn’t wrapped in curly braces, the wrong information was printed; in this case, the toString output of the student variable.
- 9. The f String Interpolator: - Prepending f to any string literal allows the creation of simple formatted strings, similar to printf in other languages. When using the f interpolator, all variable references should be followed by a printfstyle format string, like %d. Example: scala> val height = 1.9d height: Double = 1.9 scala> val name = "James" name: String = James scala> f"$name%s is $height%.2f meters tall") String = James is 1.90 meters tall - The f interpolator is typesafe. If you try to pass a format string that only works for integers but pass a double, the compiler will issue an error.
- 10. Example: scala> f"$height%d" <console>:9: error: type mismatch; found : Double required: Int f"$height%d" ^ - The f interpolator makes use of the string format utilities available from Java. The formats allowed after the % character are outlined in the Formatter javadoc. If there is no % character after a variable definition a formatter of %s (String) is assumed.
- 11. The raw String Interpolator: - The raw interpolator is similar to the s interpolator except that it performs “No escaping of literals within the string” Example: scala> s"anb" res0: String = a b - Here the s string interpolator replaced the characters n with a return character. The raw interpolator will not do that Example: scala> raw"anb" res1: String = anb - The raw interpolator is useful when you want to avoid having a sequence of characters like n turn into a newline character - In addition to the three default string interpolators, users can define their own