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 der Interpolation mit Zeichenfolgenwerten in F# 11 verwendet ein unformatierter Ausdruck die Konvertierung von string F#. Wenn der Ausdruck ausgewertet wird null, wird eine leere Zeichenfolge verwendet. Frühere Compiler könnten einige Nur-Zeichenfolgen-Interpolationen optimieren, aber andernfalls die Printf-Formatierung verwendet; siehe native AOT- und Zeichenfolgen-Interpolation für Formatierungsunterschiede.

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"

Native AOT- und Zeichenfolgen-Interpolation

Um Text ohne spiegelbasierte Formatierungsmodul zu formatieren, verwenden Sie die Zeichenfolgen-Wert-Interpolation mit einfachen oder .NET-Formatlöchern:

let name = "Ada"
let score = 97.5
let message: string = $"{name}: {score:F1}"
printn message
// Ada: 97.5

F# 11 verwendet direkte Konvertierungen und System.String.Concat für weitere Interpolationen mit Zeichenfolgenwerten. Ein .NET-Format-Loch verwendet invarianten String.Format Feldern und Feldern sein Argument. Diese Compileränderungen unterstützen native AOT , ohne dass der moderne Core-Build erforderlich ist; Ein anderer Anwendungscode kann weiterhin Spiegelung benötigen.

Drucklöcher, die Druckformatierungen erfordern, z %04d{number} . B. oder %A{record}, können weiterhin den spiegelbasierten Pfad verwenden. Bare %s, , %c, %d, %iund %M Löcher behalten ihre Typüberprüfungen bei und vermeiden Sie die Druckformatierung. Andere Bezeichner, einschließlich %u, werden von dieser Optimierung nicht abgedeckt. Eine als PrintfFormat Wert verwendete Interpolation unterscheidet sich auch von einem, dessen Ergebnistyp lautet string.

Kultur- und Formatkompatibilität

Einfache Löcher verwenden die Konvertierung von string F#; .NET-Format-Löcher verwenden invarianten Formatierungen. Um lokalisierte Ausgaben zu erzeugen, wählen Sie die Kultur explizit aus:

open System.Globalization

let value = 12.5m
let machineText: string = $"{value:F2}"
let displayText =
    value.ToString("F2", CultureInfo.GetCultureInfo("fr-FR"))

assert (machineText = "12.50")
assert (displayText = "12,50")

Überprüfen Sie die lokalisierte Ausgabe beim Upgrade. FormattableString behält die Argumente für spätere anbieterbasierte Formatierung bei, anstatt diesem Verkettungspfad zu folgen.

Warnung FS3884 identifiziert eine nicht angewendete Funktion oder Stellvertretung in einem Interpolationsloch. Wenden Sie die Funktion an, wenn Sie das Ergebnis beabsichtigt haben:

let weight () = 12.5m
let text: string = $"Weight: {weight ()} kg"

Schreiben eines Werts in die Standardausgabe

Um einen Wert ohne printf-Format zu schreiben, wird FSharp.Core 11 hinzugefügt print und printn. Sie verwenden string konvertierung; printn fügt eine neue Zeile hinzu:

print "Parcels: "
printn 3

Verwenden Sie für die Strukturausgabe %A die Nur-Text-Formatierung.

Aufzeichnungs- und Union-Ausgabe ohne Spiegelung

Mit --reflectionfree, F# 11 kann aussagekräftige ToString Implementierungen für Datensätze und Vereinigungen generieren, anstatt nur den Typnamen anzuzeigen:

type Reading = { Sensor: string; Value: int }
type Outcome = Recorded of Reading | Unavailable

let reading = { Sensor = "north"; Value = 12 }
printn reading
printn (Recorded reading)

Das Beispielprojekt aktiviert das Flag. Die Ausgabe unterscheidet sich von %A; Feldtypen benötigen auch geeignete ToString Implementierungen.

Siehe auch

  • Zuletzt aktualisiert um