Cadenas interpoladas

  • Artículo

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"

Vea también