porcentaje - string.format separador miles c#

Mejor formato de cadena en Scala

Question

Con demasiados argumentos, String.format fácilmente se vuelve demasiado confuso. ¿Hay una manera más poderosa para formatear una cadena. Al igual que:

"This is #{number} string".format("number" -> 1)

O esto no es posible debido a problemas de tipo (el format debería tomar un Mapa [Cadena, Cualquiera], supongo; no sé si esto empeoraría las cosas).

O es la mejor manera de hacerlo así:

val number = 1
<plain>This is { number } string</plain> text

¿A pesar de que contamina el espacio de nombres?

Editar:

Mientras que un simple proxenetismo podría hacer en muchos casos, también estoy buscando algo que vaya en la misma dirección que el format() de Python format() (Ver: http://docs.python.org/release/3.1.2/library/string.html#formatstrings )

Answer 1

Bueno, si su único problema es hacer que el orden de los parámetros sea más flexible, esto se puede hacer fácilmente:

scala> "%d %d" format (1, 2)
res0: String = 1 2

scala> "%2$d %1$d" format (1, 2)
res1: String = 2 1

Y también hay reemplazo de expresiones regulares con la ayuda de un mapa:

scala> val map = Map("number" -> 1)
map: scala.collection.immutable.Map[java.lang.String,Int] = Map((number,1))

scala> val getGroup = (_: scala.util.matching.Regex.Match) group 1
getGroup: (util.matching.Regex.Match) => String = <function1>

scala> val pf = getGroup andThen map.lift andThen (_ map (_.toString))
pf: (util.matching.Regex.Match) => Option[java.lang.String] = <function1>

scala> val pat = "#//{([^}]*)//}".r
pat: scala.util.matching.Regex = #/{([^}]*)/}

scala> pat replaceSomeIn ("This is #{number} string", pf)
res43: String = This is 1 string

Answer 2

En Scala 2.10 puedes usar interpolación de cadenas .

val height = 1.9d
val name = "James"
println(f"$name%s is $height%2.2f meters tall")  // James is 1.90 meters tall

Answer 3

Esta es la respuesta que vine aquí buscando:

"This is %s string".format(1)

Answer 4

Puede implementar fácilmente un formato más rico (con el enfoque pimp-my-library):

scala> implicit def RichFormatter(string: String) = new {
     |   def richFormat(replacement: Map[String, Any]) =
     |     (string /: replacement) {(res, entry) => res.replaceAll("#//{%s//}".format(entry._1), entry._2.toString)}
     | }
RichFormatter: (string: String)java.lang.Object{def richFormat(replacement: Map[String,Any]): String}

scala> "This is #{number} string" richFormat Map("number" -> 1)
res43: String = This is 1 string

Answer 5

Si está utilizando 2.10, vaya con la interpolación incorporada. De lo contrario, si no le importa el rendimiento extremo y no le teme a las líneas simples funcionales, puede usar un doblez + varios análisis de expresiones regulares:

val template = "Hello #{name}!"
val replacements = Map( "name" -> "Aldo" )
replacements.foldLeft(template)((s:String, x:(String,String)) => ( "#//{" + x._1 + "//}" ).r.replaceAllIn( s, x._2 ))

Answer 6

Tal vez el complemento de cadenas mejoradas de Scala pueda ayudarte. Mira aquí:

Scala-Enhanced-Strings-Plugin Documentation

Answer 7

También puede considerar el uso de un motor de plantillas para cadenas realmente complejas y largas. En la parte superior de mi cabeza tengo Scalate que implementa, entre otros, el motor de plantillas de Mustache .

Podría ser una exageración y una pérdida de rendimiento para cadenas simples, pero parece que estás en esa área donde comienzan a convertirse en plantillas reales.