Interpolierte Zeichenfolgen

  • Artikel

Interpolierte Zeichenfolgen sind Zeichenfolgen, mit denen Sie F#-Ausdrücke in sie einbetten können. Sie sind in einer Vielzahl von Szenarien hilfreich, in denen sich der Wert einer Zeichenfolge basierend auf dem Ergebnis eines Werts oder Ausdrucks ändern kann.

Syntax

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

Bemerkungen

Interpolierte Zeichenfolgen ermöglichen es Ihnen, Code in „Löcher“ innerhalb eines Zeichenfolgenliterals zu schreiben. Im Folgenden finden Sie ein einfaches Beispiel:

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

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

Der Inhalt zwischen den einzelnen {}-Klammerpaaren kann ein beliebiger F#-Ausdruck sein.

Um ein {}-Klammerpaar zu escapen, schreiben Sie die beiden Klammern wie folgt:

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

Typisierte interpolierte Zeichenfolgen

Interpolierte Zeichenfolgen können auch über F#-Formatbezeichner verfügen, um Typsicherheit zu erzwingen.

let name = "Phillip"
let age = 30

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

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

Im Beispiel oben übergibt der Code den age-Wert versehentlich dort, wo sich name befinden sollte und umgekehrt. Da die interpolierten Zeichenfolgen Formatbezeichner verwenden, handelt es sich um einen Kompilierfehler und nicht um einen subtilen Laufzeitfehler.

Verbatim interpolierte Zeichenfolgen

F# unterstützt verbatim interpolierte Zeichenfolgen mit dreifachen Anführungszeichen, sodass Sie Zeichenfolgenliterale einbetten können.

let age = 30

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

Formatbezeichner

Formatbezeichner können entweder im printf-Stil oder im .NET-Stil vorliegen. Spezifizierer im Printf-Stil sind diejenigen Spezifizierer, die in Nur-Text-Formatierung vor den geschweiften Klammern platziert werden. Beispiel:

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

Der Formatbezeichner %A ist besonders nützlich, um die Diagnoseausgabe strukturierter F#-Daten zu generieren.

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

Spezifizierer im .NET-Stil können mit String.Format verwendet werden und werden nach einem : innerhalb der geschweiften Klammern platziert. Beispiel:

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

Wenn ein Spezifizierer im .NET-Stil ein ungewöhnliches Zeichen enthält, dann kann er mit doppelten Graviszeichen als Escapezeichen versehen werden:

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

Ausrichten von Ausdrücken in interpolierten Zeichenfolgen

Sie können Ausdrücke links- oder rechtsbündig in interpolierten Zeichenfolgen mit | und der Angabe der Anzahl von Leerzeichen ausrichten. Die folgende interpolierte Zeichenfolge richtet die linken und rechten Ausdrücke mit sieben Leerzeichen links- bzw. rechtsbündig aus.

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

Interpolierte Zeichenfolgen und FormattableString-Formatierung

Sie können auch Formatierungen anwenden, die den Regeln für FormattableString entsprechen:

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

Darüber hinaus kann eine interpolierte Zeichenfolge auch über eine Typanmerkung als der Typ FormattableString überprüft werden:

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

Beachten Sie, dass sich die Typanmerkung für den interpolierten Zeichenfolgenausdruck selbst erfolgen muss. F# konvertiert eine interpolierte Zeichenfolge nicht implizit in eine FormattableString.

Erweiterte Syntax für die Zeichenfolgeninterpolation

Wenn Sie bereits mit Text arbeiten, der mehrere {-, }- oder %-Zeichen enthält, können Sie ab F# 8 die Syntax der erweiterten Zeichenfolgeninterpolation verwenden, um die Notwendigkeit von Escapezeichen zu entfernen.

Zeichenzeichenfolgenliterale mit dreifachen Anführungszeichen können mit mehreren $-Zeichen beginnen, wodurch geändert wird, wie viele geschweifte Klammern zum Öffnen und Schließen der Interpolation erforderlich sind. In diesen Zeichenfolgenliteralen müssen für {- und }-Zeichen keine Escapezeichen verwendet werden:

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

Die Anzahl der für Formatbezeichner benötigte %-Zeichen wird auf die gleiche Weise beeinflusst:

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

Siehe auch