Chaînes interpolées

  • Article

Les chaînes interpolées sont des chaînes qui vous permettent d’incorporer des expressions F#. Elles 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}}"""

Notes

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 correspondre à n’importe quelle expression F#.

Pour utiliser une paire d’accolades {} dans le cadre d’une séquence d’échappement, écrivez-en deux comme ceci :

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 la cohérence 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 valeur de age à la place de celle de name, et inversement. Dans la mesure où les chaînes interpolées utilisent des spécificateurs de format, il s’agit d’une erreur de compilation et non d’un bogue d’exécution subtil.

Chaînes interpolées verbatim

F# prend en charge les chaînes interpolées verbatim avec des guillemets triples pour 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 de style printf ou .NET. Les spécificateurs de style printf sont ceux traités dans Mise en forme du texte en clair, et sont 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 de format %A est particulièrement utile pour produire une sortie de diagnostic de 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 ceux utilisables avec String.Format, et sont placés après : entre accolades. Par exemple :

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

Si un spécificateur de style .NET contient un caractère inhabituel, vous pouvez le placer dans une séquence d’échappement basée sur des accents graves en double :

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

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

Vous pouvez aligner à gauche ou à droite des expressions à l’intérieur de chaînes interpolées avec | 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, de sept espaces.

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

Chaînes interpolées et mise en forme avec FormattableString

Vous pouvez également appliquer une 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."

De plus, une chaîne interpolée peut également faire l’objet d’une vérification de type en tant que FormattableString via 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 FormattableString.

Syntaxe étendue pour l’interpolation de chaîne

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

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

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 manière :

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

Voir aussi