Share via

Interpolerade strängar

  • Artikel

Interpolerade strängar är strängar som gör att du kan bädda in F#-uttryck i dem. De är användbara i en mängd olika scenarier där värdet för en sträng kan ändras baserat på resultatet av ett värde eller uttryck.

Syntax

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

Kommentarer

Med interpolerade strängar kan du skriva kod i "hål" inuti en strängliteral. Här är ett grundläggande exempel:

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

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

Innehållet mellan varje {} klammerpar kan vara valfritt F#-uttryck.

Om du vill undvika ett {} klammerpar skriver du två av dem så här:

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

Typade interpolerade strängar

Interpolerade strängar kan också ha F#-formatsspecificerare för att framtvinga typsäkerhet.

let name = "Phillip"
let age = 30

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

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

I föregående exempel skickar koden av misstag värdet age där name ska vara och vice/versa. Eftersom de interpolerade strängarna använder formatspecificerare är detta ett kompileringsfel i stället för en diskret körningsbuggar.

Ordagranna interpolerade strängar

F# stöder ordagranna interpolerade strängar med tre citattecken så att du kan bädda in strängliteraler.

let age = 30

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

Formatera specificerare

Formatspecificerare kan antingen vara printf-style eller . NET-format. Printf-formatspecificerare är de som täcks i klartextformatering, placerade före klammerparenteserna. Till exempel:

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

Formatspecificeraren %A är särskilt användbar för att producera diagnostiska utdata från strukturerade F#-data.

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

. NET-formatsspecificerare är de som kan användas med String.Format, placerade efter en : inom klammerparenteserna. Till exempel:

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

Om en . NET-formatsspecificeraren innehåller ett ovanligt tecken, och kan sedan undantagas med hjälp av dubbel-backticks:

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

Justera uttryck i interpolerade strängar

Du kan vänsterjustera eller högerjustera uttryck inuti interpolerade strängar med | och en specifikation av hur många blanksteg. Följande interpolerade sträng justerar vänster- och högeruttryck till vänster respektive höger med sju blanksteg.

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

Interpolerade strängar och FormattableString formatering

Du kan också använda formatering som följer reglerna för 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."

Dessutom kan en interpolerad sträng också vara typkontrollerad som en FormattableString via en typanteckning:

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

Observera att typanteckningen måste finnas i själva det interpolerade stränguttrycket. F# konverterar inte implicit en interpolerad sträng till en FormattableString.

Utökad syntax för stränginterpolation

Från och med F# 8, när du arbetar med text som redan innehåller flera {, } eller % tecken, kan du använda utökad stränginterpolationssyntax för att ta bort behovet av att fly.

Strängliteraler med tre citattecken kan börja med flera $ tecken, vilket ändrar hur många klammerparenteser som krävs för att öppna och stänga interpolationen. I dessa strängliteraler { och } tecken behöver inte vara undantagna:

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

Antalet % tecken som behövs för formatspecificerare påverkas på samma sätt:

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

Se även