Ciągi interpolowane
Ciągi interpolowane to ciągi , które umożliwiają osadzanie w nich wyrażeń języka F#. Są one przydatne w wielu scenariuszach, w których wartość ciągu może ulec zmianie na podstawie wyniku wartości lub wyrażenia.
Składnia
$"string-text {expr}"
$"string-text %format-specifier{expr}"
$"""string-text {"embedded string literal"}"""
$$"""string-text %%format-specifier{{expr}}"""
Uwagi
Ciągi interpolowane umożliwiają pisanie kodu w "otworach" wewnątrz literału ciągu. Poniżej przedstawiono prosty przykład:
let name = "Phillip"
let age = 30
printfn $"Name: {name}, Age: {age}"
printfn $"I think {3.0 + 0.14} is close to {System.Math.PI}!"
Zawartość między każdą {} parą nawiasów klamrowych może być dowolnym wyrażeniem języka F#.
Aby uniknąć pary nawiasów {} klamrowych, napisz dwa z nich w następujący sposób:
let str = $"A pair of braces: {{}}"
// "A pair of braces: {}"
Wpisane ciągi interpolowane
Ciągi interpolowane mogą również mieć specyfikatory formatu F# w celu wymuszania bezpieczeństwa typu.
let name = "Phillip"
let age = 30
printfn $"Name: %s{name}, Age: %d{age}"
// Error: type mismatch
printfn $"Name: %s{age}, Age: %d{name}"
W poprzednim przykładzie kod błędnie przekazuje age wartość, gdzie name powinna być i na odwrót. Ponieważ ciągi interpolowane używają specyfikatorów formatu, jest to błąd kompilacji zamiast subtelnej usterki środowiska uruchomieniowego.
Ciągi interpolowane dosłownie
Język F# obsługuje ciągi interpolowane z potrójnymi cudzysłowami, dzięki czemu można osadzić literały ciągu.
let age = 30
printfn $"""Name: {"Phillip"}, Age: %d{age}"""
Specyfikatory formatu
Specyfikatory formatu mogą być typu printf lub . Styl net. Specyfikatory stylu printf są objęte formatowaniem zwykłego tekstu umieszczonym przed nawiasami klamrowymi. Na przykład:
let pi = $"%0.3f{System.Math.PI}" // "3.142"
let code = $"0x%08x{43962}" // "0x0000abba"
Specyfikator %A formatu jest szczególnie przydatny do tworzenia danych diagnostycznych ustrukturyzowanych danych języka F#.
let data = [0..4]
let output = $"The data is %A{data}" // "The data is [0; 1; 2; 3; 4]"
. Specyfikatory stylu NET są takie, których można używać z elementem String.Format, umieszczonym : po nawiasach klamrowych. Na przykład:
let pi = $"{System.Math.PI:N4}" // "3.1416"
let now = $"{System.DateTime.UtcNow:``yyyyMMdd``}" // e.g. "20220210"
Jeśli element . Specyfikator stylu NET zawiera nietypowy znak, a następnie można go uniknąć za pomocą podwójnych backticks:
let nowDashes = $"{System.DateTime.UtcNow:``yyyy-MM-dd``}" // e.g. "2022-02-10"
Wyrównanie wyrażeń w ciągach interpolowanych
Wyrażenia wyrównane do lewej lub wyrównania do prawej wewnątrz ciągów | interpolowanych i określenie liczby spacji. Poniższy ciąg interpolowany wyrównuje odpowiednio wyrażenia lewe i prawe do lewej i prawej o siedem spacji.
printfn $"""|{"Left",-7}|{"Right",7}|"""
// |Left | Right|
Ciągi interpolowane i FormattableString formatowanie
Można również zastosować formatowanie zgodne z regułami dla elementu 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."
Ponadto ciąg interpolowany może być również sprawdzany jako FormattableString znak za pomocą adnotacji typu:
let frmtStr = $"The speed of light is {speedOfLight:N3} km/s." : FormattableString
// Type: FormattableString
// The speed of light is 299,792.458 km/s.
Należy pamiętać, że adnotacja typu musi znajdować się w samym wyrażeniu ciągu interpolowanego. Język F# nie konwertuje niejawnie ciągu interpolowanego na FormattableString.
Rozszerzona składnia interpolacji ciągów
Począwszy od języka F# 8, gdy pracujesz z tekstem zawierającym już wiele {} znaków lub % , możesz użyć rozszerzonej składni interpolacji ciągów, aby usunąć konieczność ucieczki.
Literały ciągu potrójnego cudzysłowu mogą zaczynać się od wielu $ znaków, co zmienia liczbę nawiasów klamrowych wymaganych do otwarcia i zamknięcia interpolacji.
W tych literałach ciągów { i } znaki nie muszą być ucieczki:
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."""
Liczba znaków potrzebnych % do specyfikatorów formatu ma wpływ w ten sam sposób:
let percent = $$"""50% of 20 is %%.1f{{20m * 0.5m}}"""
// "50% of 20 is 10.0"
