Dela via

Interpolerade strängar

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

Anmärkningar

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.

För icke-typerade interpolerade strängar (utan formatspecificerare) konverteras uttrycket till en sträng med hjälp av ToString() metoden. Om uttrycket utvärderas till nullanvänds en tom sträng.

För typade interpolerade strängar med formatspecificerare (till exempel %s{expr} eller %d{expr}) följer konverteringen de regler som definierats för den specifika formatspecificeraren. 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 på två sätt:

Använda $@ eller @$ prefix

Du kan kombinera interpolationsprefixet $ med det ordagranna strängprefixet @ i valfri ordning. Ordagranna strängar ignorerar escape-sekvenser (förutom för "" att representera ett citattecken) och kan sträcka sig över flera rader. Detta är särskilt användbart när du arbetar med filsökvägar eller strängar som innehåller omvänt snedstreck och citattecken.

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"

Använda tre citattecken

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

let age = 30

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

Formatspecifikatorer

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``}" // for example, "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``}" // for example, "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

  • Last updated on