Scala: ¿Cómo puedo obtener una representación escapada de una cadena?

Question

Básicamente, lo que me gustaría hacer es tener:

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

hacer esto:

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

Básicamente busca de un análogo de String#inspect de rubí o Haskell de show :: String -> String.

Answer 1

Esta pregunta es un poco viejo, pero tropecé con él durante la búsqueda de una solución a mí mismo y estaba insatisfecho con las otras respuestas porque no son seguras (reemplazando cosas por su cuenta) o requieren una biblioteca externa.

Encontré una forma de obtener la representación escapada de una cadena con la biblioteca estándar scala (> 2.10.0) que es segura. Utiliza un pequeño truco:

A través de la reflexión en tiempo de ejecución puede obtener fácilmente una representación de una expresión de cadena literal. El árbol de dicha expresión se devuelve como (casi) código scala al llamar al método toString. Esto significa especialmente que el literal se representa de la forma en que sería en código, es decir, escapado y comillas dobles.

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

Por tanto, la función de escape se traduce en el código de representación deseada de la cadena de texto proporcionado (incluyendo las comillas dobles que rodean):

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

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

Esta solución está abusando cierto que el API de reflexión, pero en mi humilde opinión aún más seguro y más sostenible que las otras soluciones propuestas.

Answer 2

Si Compilo siguientes:

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

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

no encuentro una diferencia en la cadena, así que supongo que: No hay posibilidad, para averiguar, si hubo un "\ n" en la fuente.

¿Pero tal vez te equivoqué y quisieras obtener el mismo resultado para ambos?

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

La segunda posibilidad es:

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

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

prueba:

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

Estoy bastante seguro de que esto no está disponible en las librerías estándar, ya sea para Scala o Java, pero está en 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 

Puede agregar fácilmente las comillas a la cadena escapada si lo desea, por supuesto.

Answer 4

Se puede construir su propia función con bastante facilidad, si no desea utilizar la biblioteca Apache:

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

La solución scala.reflect realmente funciona bien. Cuando no quiere obtener toda la biblioteca, esto es lo que parece hacer bajo el capó (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