Cadenas interpoladas
Las cadenas interpoladas son cadenas que permiten insertar expresiones de F# en su interior. Son útiles en una amplia gama de escenarios en los que el valor de una cadena puede cambiar en función del resultado de un valor o una expresión.
Sintaxis
$"string-text {expr}"
$"string-text %format-specifier{expr}"
$"""string-text {"embedded string literal"}"""
$$"""string-text %%format-specifier{{expr}}"""
Comentarios
Las cadenas interpoladas permiten escribir código en "agujeros" dentro de un literal de cadena. Este es un ejemplo básico:
let name = "Phillip"
let age = 30
printfn $"Name: {name}, Age: {age}"
printfn $"I think {3.0 + 0.14} is close to {System.Math.PI}!"
El contenido entre cada par de llaves {} puede ser cualquier expresión de F#.
Para aplicar escape a un par de llaves {}, escriba dos de ellas de la siguiente manera:
let str = $"A pair of braces: {{}}"
// "A pair of braces: {}"
Cadenas interpoladas con tipo
Las cadenas interpoladas también pueden tener especificadores de formato de F# para aplicar seguridad de tipos.
let name = "Phillip"
let age = 30
printfn $"Name: %s{name}, Age: %d{age}"
// Error: type mismatch
printfn $"Name: %s{age}, Age: %d{name}"
En el ejemplo anterior, el código pasa erróneamente el valor age donde debería estar name, y viceversa. Dado que las cadenas interpoladas usan especificadores de formato, se trata de un error de compilación en lugar de un error en tiempo de ejecución leve.
Cadenas interpoladas textuales
F# admite cadenas interpoladas textuales con comillas triples para que se puedan insertar literales de cadena.
let age = 30
printfn $"""Name: {"Phillip"}, Age: %d{age}"""
Especificadores de formato
Los especificadores de formato pueden ser de estilo printf o de estilo .NET. Los especificadores de estilo printf son los que se tratan en Texto sin formato, colocados antes de las llaves. Por ejemplo:
let pi = $"%0.3f{System.Math.PI}" // "3.142"
let code = $"0x%08x{43962}" // "0x0000abba"
El especificador de formato %A es especialmente útil para generar la salida de diagnóstico de datos estructurados de F#.
let data = [0..4]
let output = $"The data is %A{data}" // "The data is [0; 1; 2; 3; 4]"
Los especificadores de estilo .NET son los que se pueden usar con String.Format, colocados después de : dentro de las llaves. Por ejemplo:
let pi = $"{System.Math.PI:N4}" // "3.1416"
let now = $"{System.DateTime.UtcNow:``yyyyMMdd``}" // e.g. "20220210"
Si un especificador de estilo .NET contiene un carácter inusual, se le puede aplicar escape mediante acentos graves dobles:
let nowDashes = $"{System.DateTime.UtcNow:``yyyy-MM-dd``}" // e.g. "2022-02-10"
Alineación de expresiones en cadenas interpoladas
Puede alinear a la izquierda o a la derecha expresiones dentro de cadenas interpoladas con | y una especificación de cuántos espacios. La siguiente cadena interpolada alinea las expresiones izquierda y derecha a la izquierda y a la derecha, respectivamente, por siete espacios.
printfn $"""|{"Left",-7}|{"Right",7}|"""
// |Left | Right|
Cadenas interpoladas y formato FormattableString
También puede aplicar formato que cumpla las reglas de FormattableString:
let speedOfLight = 299792.458
printfn $"The speed of light is {speedOfLight:N3} km/s."
// "The speed of light is 299,792.458 km/s."
Además, el tipo de una cadena interpolada también se puede comprobar como FormattableString mediante una anotación de tipo:
let frmtStr = $"The speed of light is {speedOfLight:N3} km/s." : FormattableString
// Type: FormattableString
// The speed of light is 299,792.458 km/s.
Tenga en cuenta que la anotación de tipo debe estar en la propia expresión de cadena interpolada. F# no convierte implícitamente una cadena interpolada en FormattableString.
Sintaxis extendida para la interpolación de cadenas
A partir de F# 8, cuando se trabaja con texto que ya contiene varios caracteres {, } o %, puede usar la sintaxis de interpolación de cadenas extendida para quitar la necesidad de escapar.
Los literales de cadena de comillas triples pueden comenzar con varios caracteres $, lo que cambia cuántas llaves son necesarias para abrir y cerrar la interpolación.
En estos literales de cadena, no es necesario escapar los caracteres { y }:
let str = $$"""A string containing some {curly braces} and an {{"F#" + " " + "expression"}}."""
// "A string containing some {curly braces} and an F# expression."
let another = $$$"""A string with pairs of {{ and }} characters and {{{ "an F# expression" }}}."""
// "A string with pairs of {{ and }} characters and an F# expression."""
El número de caracteres % necesarios para los especificadores de formato se ve afectado de la misma manera:
let percent = $$"""50% of 20 is %%.1f{{20m * 0.5m}}"""
// "50% of 20 is 10.0"
