Freigeben über

Interpolierte Zeichenfolgen

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 {expr}"
@$"string-text {expr}"
$"""string-text {"embedded string literal"}"""
$$"""string-text %%format-specifier{{expr}}"""

Bemerkungen

Interpolierte Zeichenfolgen ermöglichen ihnen das Schreiben von Code in "Löchern" innerhalb eines Zeichenfolgenliterals. Hier ist 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 jedem {} geschweiften Paar kann ein beliebiger F#-Ausdruck sein.

Bei nicht typierten interpolierten Zeichenfolgen (ohne Formatbezeichner) wird der Ausdruck mithilfe der ToString() Methode in eine Zeichenfolge konvertiert. Wenn der Ausdruck ausgewertet wird null, wird eine leere Zeichenfolge verwendet.

Bei typierten interpolierten Zeichenfolgen mit Formatbezeichnern (z %s{expr} . B. oder %d{expr}) folgt die Konvertierung den regeln, die für diesen spezifischen Formatbezeichner definiert sind. Um einem {} geschweiften Paar zu entkommen, schreiben Sie zwei davon wie folgt:

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

Interpolierte Zeichenfolgen eingegeben

Interpolierte Zeichenfolgen können auch F#-Formatbezeichner aufweisen, um die 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 vorherigen Beispiel übergibt der Code versehentlich den age Wert, wo name er sein soll, und umgekehrt. Da die interpolierten Zeichenfolgen Formatbezeichner verwenden, ist dies ein Kompilierungsfehler anstelle eines subtilen Laufzeitfehlers.

Verbatim interpolierte Zeichenfolgen

F# unterstützt verbatim interpolierte Zeichenfolgen auf zwei Arten:

Verwenden $@ oder @$ Präfix

Sie können das Interpolationspräfix in beliebiger Reihenfolge mit dem Präfix $ für die Zeichenfolge " @ Verbatim" kombinieren. Verbatim-Zeichenfolgen ignorieren Escapesequenzen (mit Ausnahme der "" Darstellung eines Anführungszeichens) und können mehrere Zeilen umfassen. Dies ist besonders hilfreich beim Arbeiten mit Dateipfaden oder Zeichenfolgen, die umgekehrte Schrägstriche und Anführungszeichen enthalten.

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"

Verwenden von dreifachen Anführungszeichen

F# unterstützt auch verbatim interpolierte Zeichenfolgen mit dreifachen Anführungszeichen, sodass Sie Zeichenfolgenliterale einbetten können, ohne escaping zu müssen.

let age = 30

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

Formatbezeichner

Formatbezeichner können entweder printf-formatieren oder . NET-Formatvorlage. Printf-Style-Bezeichner sind diejenigen, die in der Nur-Text-Formatierung behandelt werden, die 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 eignet sich besonders für die Erstellung der Diagnoseausgabe strukturierter F#-Daten.

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

. Net-Style-Bezeichner sind diejenigen, die verwendet String.Formatwerden können, die nach einer : innerhalb der geschweiften Klammern platziert werden. Beispiel:

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

Wenn ein . Der BEzeichner im NET-Stil enthält ein ungewöhnliches Zeichen und kann dann mithilfe von Double-Backticks escaped werden:

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

Ausrichten von Ausdrücken in interpolierten Zeichenfolgen

Sie können Ausdrücke innerhalb interpolierter Zeichenfolgen | linksbündig oder rechtsbündig ausrichten und angeben, wie viele Leerzeichen vorhanden sind. Die folgende interpolierte Zeichenfolge richtet die linken und rechten Ausdrücke links bzw. rechts um sieben Leerzeichen aus.

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

Interpolierte Zeichenfolgen und FormattableString Formatierungen

Sie können auch Formatierungen anwenden, die den Regeln entsprechen: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."

Darüber hinaus kann eine interpolierte Zeichenfolge auch über FormattableString eine Typanmerkung ü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 im interpolierten Zeichenfolgenausdruck selbst enthalten muss. F# konvertiert keine interpolierte Zeichenfolge implizit in eine FormattableString.

Erweiterte Syntax für die Zeichenfolgeninterpolation

Ab F# 8 können Sie beim Arbeiten mit Text, der mehrere {Zeichen enthält, } bereits % erweiterte Zeichenfolgeninterpolationssyntax verwenden, um die Notwendigkeit der Escapefunktion zu entfernen.

Dreifache Anführungszeichenzeichenfolgenliterale 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 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 zeichen, die % für Formatbezeichner erforderlich sind, ist auf die gleiche Weise betroffen:

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

Siehe auch

  • Last updated on