Scala: Wie kann ich eine Escape-Darstellung einer Zeichenfolge erhalten?

Question

Im Grunde, was ich möchte zu tun haben:

// in foo.scala 
val string = "this is a string\nover two lines" 
println(string) 
println(foo(string)) 

tun:

% scala foo.scala 
this is a string 
over two lines 
"this is a string\nover two lines" 

Grundsätzlich für ein Analogon von Rubys String#inspect oder Haskells show :: String -> String suchen.

Answer 1

Diese Frage ist ein bisschen alt, aber ich stolperte über sie, während für eine Lösung selbst suchen und war mit den anderen Antworten unzufrieden, weil sie entweder nicht sicher sind (sie selbst ersetzen) oder eine externe Bibliothek benötigen.

Ich habe einen Weg gefunden, um die Escape-Darstellung einer Zeichenfolge mit der Scala-Standardbibliothek (> 2.10.0) zu bekommen, die sicher ist. Es verwendet einen kleinen Trick:

Durch Laufzeit-Reflektion können Sie leicht eine Darstellung eines literalen String-Ausdrucks erhalten. Der Baum eines solchen Ausdrucks wird beim Aufruf seiner Methode toString als (fast) Scala-Code zurückgegeben. Dies bedeutet insbesondere, dass das Literal so dargestellt wird, wie es im Code wäre, d. H. Maskiert und doppelt zitiert.

def escape(raw: String): String = { 
    import scala.reflect.runtime.universe._ 
    Literal(Constant(raw)).toString 
} 

Die escape Funktion ergibt sich somit in der gewünschten Code-Darstellung der rohen Saite (einschließlich der umgebenden doppelte Anführungszeichen):

scala> "\bHallo" + '\n' + "\tWelt" 
res1: String = 
?Hallo 
     Welt 

scala> escape("\bHallo" + '\n' + "\tWelt") 
res2: String = "\bHallo\n\tWelt" 

Diese Lösung zwar die Reflexion api aber IMHO mißbraucht noch sicherer und wartbarer als die anderen vorgeschlagenen Lösungen.

Answer 2

Wenn ich kompilieren diese:

object s1 { 
val s1 = "this is a string\nover two lines" 
} 

object s2 { 
val s2 = """this is a string 
over two lines""" 
} 

ich, keinen Unterschied in der String finden also denke ich: Es gibt keine Möglichkeit ist, um herauszufinden, ob es ein „\ n“ war in die Quelle.

Aber vielleicht habe ich dich falsch verstanden, und Sie möchten das gleiche Ergebnis für beide bekommen?

"\"" + s.replaceAll ("\\n", "\\\\n").replaceAll ("\\t", "\\\\t") + "\"" 

Die zweite Möglichkeit ist:

val mask = Array.fill (3)('"').mkString 
mask + s + mask 

res5: java.lang.String = 
"""a 
b""" 

Test:

scala> val s = "a\n\tb" 
s: java.lang.String = 
a 
    b 

scala>  "\"" + s.replaceAll ("\\n", "\\\\n").replaceAll ("\\t", "\\\\t") + "\"" 
res7: java.lang.String = "a\n\tb" 

scala> mask + s + mask 
res8: java.lang.String = 
"""a 
    b""" 

Answer 3

Ich bin ziemlich sicher, das entweder für Scala oder Java in den Standardbibliotheken nicht verfügbar ist, aber es ist in Apache Commons Lang:

scala> import org.apache.commons.lang.StringEscapeUtils.escapeJava 
import org.apache.commons.lang.StringEscapeUtils.escapeJava 

scala> escapeJava("this is a string\nover two lines") 
res1: java.lang.String = this is a string\nover two lines 

Sie könnten natürlich die Anführungszeichen zur Escapezeichenfolge hinzufügen, wenn Sie möchten.

Answer 4

Sie könnten Ihre eigene Funktion ziemlich leicht bauen, wenn Sie die Apache-Bibliothek nicht verwenden wollen:

scala> var str = "this is a string\b with some \n escapes \t so we can \r \f \' \" see how they work \\"; 
str: java.lang.String = 
this is a string? with some 
escapes  so we can 
' " see how they work \ 

scala> print(str.replace("\\","\\\\").replace("\n","\\n").replace("\b","\\b").replace("\r","\\r").replace("\t","\\t").replace("\'","\\'").replace("\f","\\f").replace("\"","\\\"")); 
this is a string\b with some \n escapes \t so we can \r \f \' \" see how they work \\ 

Answer 5

Die scala.reflect Lösung funktioniert tatsächlich gut. Wenn du diese ganze Bibliothek nicht reinziehen willst, scheint das unter der Haube zu funktionieren (Scala 2.11):

def quote (s: String): String = "\"" + escape(s) + "\"" 
def escape(s: String): String = s.flatMap(escapedChar) 

def escapedChar(ch: Char): String = ch match { 
    case '\b' => "\\b" 
    case '\t' => "\\t" 
    case '\n' => "\\n" 
    case '\f' => "\\f" 
    case '\r' => "\\r" 
    case '"' => "\\\"" 
    case '\'' => "\\\'" 
    case '\\' => "\\\\" 
    case _ => if (ch.isControl) "\\0" + Integer.toOctalString(ch.toInt) 
       else    String.valueOf(ch) 
} 

val string = "\"this\" is a string\nover two lines" 
println(quote(string)) // ok