Partager via

Chaînes interpolées

Les chaînes interpolées sont des chaînes qui vous permettent d’incorporer des expressions F# dans celles-ci. Ils sont utiles dans un large éventail de scénarios où la valeur d’une chaîne peut changer en fonction du résultat d’une valeur ou d’une expression.

Syntaxe

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

Remarques

Les chaînes interpolées vous permettent d’écrire du code dans des « trous » à l’intérieur d’un littéral de chaîne. Voici un exemple de base :

let name = "Phillip"
let age = 30
printfn $"Name: {name}, Age: {age}"

printfn $"I think {3.0 + 0.14} is close to {System.Math.PI}!"

Le contenu entre chaque {} paire d’accolades peut être n’importe quelle expression F#.

Pour échapper à une paire d’accolades {} , écrivez deux d’entre eux comme suit :

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

Chaînes interpolées typées

Les chaînes interpolées peuvent également avoir des spécificateurs de format F# pour appliquer la sécurité des types.

let name = "Phillip"
let age = 30

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

// Error: type mismatch
printfn $"Name: %s{age}, Age: %d{name}"

Dans l’exemple précédent, le code passe par erreur la age valeur où name doit être, et vice/versa. Étant donné que les chaînes interpolées utilisent des spécificateurs de format, il s’agit d’une erreur de compilation au lieu d’un bogue d’exécution subtil.

Chaînes interpolées verbatim

F# prend en charge les chaînes interpolées détaillées avec des guillemets triples afin que vous puissiez incorporer des littéraux de chaîne.

let age = 30

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

Spécificateurs de format

Les spécificateurs de format peuvent être printf-style ou . Style NET. Les spécificateurs de style Printf sont ceux couverts dans la mise en forme en texte clair, placés avant les accolades. Par exemple:

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

Le spécificateur %A de format est particulièrement utile pour produire la sortie de diagnostic des données F# structurées.

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

. Les spécificateurs de style NET sont utilisables avec String.Format, placés après une : accolade. Par exemple:

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

Si un . Le spécificateur de style NET contient un caractère inhabituel, puis il peut être échappé à l’aide de double backticks :

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

Alignement d’expressions dans des chaînes interpolées

Vous pouvez aligner ou aligner à gauche des expressions à l’intérieur de chaînes | interpolées et une spécification du nombre d’espaces. La chaîne interpolée suivante aligne les expressions de gauche et de droite à gauche et à droite, respectivement, par sept espaces.

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

Chaînes interpolées et FormattableString mise en forme

Vous pouvez également appliquer la mise en forme qui respecte les règles pour 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."

En outre, une chaîne interpolée peut également être vérifiée en tant que FormattableString par le biais d’une annotation de type :

let frmtStr = $"The speed of light is {speedOfLight:N3} km/s." : FormattableString
// Type: FormattableString
// The speed of light is 299,792.458 km/s.

Notez que l’annotation de type doit se trouver sur l’expression de chaîne interpolée elle-même. F# ne convertit pas implicitement une chaîne interpolée en un FormattableString.

Syntaxe étendue pour l’interpolation de chaîne

À compter de F# 8, lorsque vous travaillez avec du texte contenant plusieurs caractères ou %} plusieurs {caractères, vous pouvez utiliser la syntaxe d’interpolation de chaîne étendue pour supprimer la nécessité d’échapper.

Les littéraux de chaîne de guillemets triples peuvent commencer par plusieurs $ caractères, ce qui modifie le nombre d’accolades requises pour ouvrir et fermer l’interpolation. Dans ces littéraux de chaîne, { et } les caractères n’ont pas besoin d’être échappés :

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

Le nombre de caractères nécessaires pour les spécificateurs de % format est affecté de la même façon :

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

Voir aussi