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 {expr}"
@$"string-text {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 les chaînes interpolées non typées (sans spécificateurs de format), l’expression est convertie en chaîne à l’aide de la ToString() méthode. Si l’expression prend la valeur null, une chaîne vide est utilisée.

Pour les chaînes interpolées typées avec des spécificateurs de format (par exemple %s{expr}%d{expr}), la conversion suit les règles définies pour ce spécificateur de format spécifique. 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 de deux façons :

Utilisation $@ ou @$ préfixe

Vous pouvez combiner le préfixe $ d’interpolation avec le préfixe @ de chaîne détaillé dans n’importe quel ordre. Les chaînes détaillées ignorent les séquences d’échappement (à l’exception de "" représenter un guillemet) et peuvent s’étendre sur plusieurs lignes. Cela est particulièrement utile lors de l’utilisation de chemins d’accès ou de chaînes de fichiers contenant des barres obliques inverses et des guillemets.

let name = "Alice"
let path = @"C:\Users\Alice\Documents"

// Using $@ prefix
printfn $@"User {name} has files in: {path}"

// Using @$ prefix (also valid)
printfn @$"User {name} has files in: {path}"

// Embedding quotes - use "" to represent a single "
let message = $@"He said ""{name}"" is here"

Utilisation de guillemets triples

F# prend également 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 sans échapper.

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

  • Last updated on