Cadeias de caracteres interpoladas

  • Artigo

Cadeias de caracteres interpoladas são cadeias de caracteres que permitem inserir expressões F# nelas. Elas são úteis em uma ampla variedade de cenários em que o valor de uma cadeia de caracteres pode ser alterado com base no resultado de um valor ou expressão.

Sintaxe

$"string-text {expr}"
$"string-text %format-specifier{expr}"
$"""string-text {"embedded string literal"}"""
$$"""string-text %%format-specifier{{expr}}"""

Comentários

Cadeias de caracteres interpoladas permitem escrever código em "espaços" dentro de um literal de cadeia de caracteres. Este é um exemplo 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}!"

O conteúdo entre cada par de chaves {} pode ser qualquer expressão F#.

Para escapar de um par de chaves {}, escreva dois deles da seguinte maneira:

let str = $"A pair of braces: {{}}"
// "A pair of braces: {}"

Cadeias de caracteres interpoladas

Cadeias de caracteres interpoladas também podem ter especificadores de formato F# para impor a segurança 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}"

No exemplo anterior, o código passa erroneamente o valor age onde name deveria estar e vice-versa. Como as cadeias de caracteres interpoladas usam especificadores de formato, esse é um erro de compilação em vez de um bug de runtime sutil.

Cadeias de caracteres interpoladas verbatim

O F# dá suporte a cadeias de caracteres interpoladas verbatim com aspas triplas para que você possa inserir literais de cadeia de caracteres.

let age = 30

printfn $"""Name: {"Phillip"}, Age: %d{age}"""

Especificadores de formato

Os especificadores de formato podem ser no estilo printf ou .NET. Os especificadores de estilo printf são aqueles cobertos na formatação de texto sem formatação, colocados antes das chaves. Por exemplo:

let pi = $"%0.3f{System.Math.PI}"  // "3.142"
let code = $"0x%08x{43962}"  // "0x0000abba"

O especificador de formato %A é particularmente útil para produzir a saída de diagnóstico de dados F# estruturados.

let data = [0..4]
let output = $"The data is %A{data}"  // "The data is [0; 1; 2; 3; 4]"

Os especificadores de estilo .NET são aqueles utilizáveis com String.Format, colocados após um : dentro das chaves. Por exemplo:

let pi = $"{System.Math.PI:N4}"  // "3.1416"
let now = $"{System.DateTime.UtcNow:``yyyyMMdd``}" // e.g. "20220210"

Se um especificador de estilo NET contiver um caractere incomum e, em seguida, ele puder ser escapado usando acentos graves duplos:

let nowDashes = $"{System.DateTime.UtcNow:``yyyy-MM-dd``}" // e.g. "2022-02-10"

Alinhando expressões em cadeias de caracteres interpoladas

Você pode alinhar expressões à esquerda ou à direita dentro de cadeias de caracteres interpoladas com | e uma especificação de quantos espaços. A cadeia de caracteres interpolada a seguir alinha as expressões esquerda e direita à esquerda e à direita, respectivamente, em sete espaços.

printfn $"""|{"Left",-7}|{"Right",7}|"""
// |Left   |  Right|

Cadeias de caracteres interpoladas e formatação FormattableString

Você também pode aplicar formatação que segue as regras para 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."

Além disso, uma cadeia de caracteres interpolada também pode ter seu tipo verificado como um FormattableString por meio de uma anotação 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.

Observe que a anotação de tipo deve estar na própria expressão de cadeia de caracteres interpolada. O F# não converte implicitamente uma cadeia de caracteres interpolada em um FormattableString.

Sintaxe estendida para interpolação de cadeia de caracteres

A partir do F# 8, ao trabalhar com texto que contém vários caracteres ou que já contém caracteres {, } ou %, você pode usar a sintaxe de interpolação de cadeia de caracteres estendida para eliminar a necessidade de escape.

Literais de cadeia de caracteres com aspas triplas podem começar com vários caracteres $, o que altera a quantidade de chaves necessárias para abrir e fechar a interpolação. Nesses literais de cadeia de caracteres, os caracteres { e } não precisam ser escapados:

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."""

O número de caracteres % necessários para especificadores de formato é afetado da mesma maneira:

let percent = $$"""50% of 20 is %%.1f{{20m * 0.5m}}"""
// "50% of 20 is 10.0"

Confira também