Geïnterpoleerde tekenreeksen

  • Artikel

Geïnterpoleerde tekenreeksen zijn tekenreeksen waarmee u F#-expressies kunt insluiten. Ze zijn handig in een breed scala aan scenario's waarbij de waarde van een tekenreeks kan veranderen op basis van het resultaat van een waarde of expressie.

Syntaxis

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

Opmerkingen

Met geïnterpoleerde tekenreeksen kunt u code schrijven in 'gaten' binnen een letterlijke tekenreeks. Hier volgt een basisvoorbeeld:

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

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

De inhoud tussen elke {} accoladepaar kan elke F#-expressie zijn.

Als u een {} accoladepaar wilt ontsnappen, schrijft u er twee als volgt uit:

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

Getypte geïnterpoleerde tekenreeksen

Geïnterpoleerde tekenreeksen kunnen ook F#-indelingsaanduidingen hebben om typeveiligheid af te dwingen.

let name = "Phillip"
let age = 30

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

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

In het vorige voorbeeld geeft de code per ongeluk de age waarde door waar name deze moet zijn en vice versa. Omdat de geïnterpoleerde tekenreeksen indelingsaanduidingen gebruiken, is dit een compilatiefout in plaats van een subtiele runtimefout.

Letterlijk geïnterpoleerde tekenreeksen

F# biedt ondersteuning voor letterlijke tekstinterpolatie van tekenreeksen met drie aanhalingstekens, zodat u letterlijke tekenreeksen kunt insluiten.

let age = 30

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

Opmaakaanduidingen

Opmaakaanduidingen kunnen printf-stijl of . NET-stijl. Afdrukstijlaanduidingen zijn aanduidingen die worden behandeld in tekst zonder opmaak, geplaatst vóór de accolades. Voorbeeld:

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

De indelingsaanduiding %A is met name handig voor het produceren van diagnostische uitvoer van gestructureerde F#-gegevens.

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

. NET-stijlaanduidingen zijn de aanduidingen die bruikbaar zijn met String.Format, geplaatst na een : binnen de accolades. Voorbeeld:

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

Als een . Net-stijlaanduiding bevat een ongebruikelijk teken en kan worden ontsnapt met behulp van dubbele backticks:

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

Expressies uitlijnen in geïnterpoleerde tekenreeksen

U kunt expressies links uitlijnen of rechts uitlijnen binnen geïnterpoleerde tekenreeksen en | een specificatie van het aantal spaties. Met de volgende geïnterpoleerde tekenreeks worden respectievelijk de linker- en rechterexpressies met zeven spaties uitgelijnd op de linker- en rechterexpressie.

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

Geïnterpoleerde tekenreeksen en FormattableString opmaak

U kunt ook opmaak toepassen die voldoet aan de regels voor 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."

Daarnaast kan een geïnterpoleerde tekenreeks ook worden gecontroleerd als een FormattableString via een typeaantekening:

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

Houd er rekening mee dat het typeaantekening zich moet bevinden in de geïnterpoleerde tekenreeksexpressie zelf. F# converteert een geïnterpoleerde tekenreeks niet impliciet naar een FormattableString.

Uitgebreide syntaxis voor tekenreeksinterpolatie

Vanaf F# 8 kunt u, wanneer u met tekst met meerdere {tekens } werkt, % uitgebreide tekenreeksinterpolatiesyntaxis gebruiken om de noodzaak voor escapen te verwijderen.

Letterlijke tekenreeksen met drie aanhalingstekens kunnen beginnen met meerdere $ tekens, waardoor wordt gewijzigd hoeveel accolades nodig zijn om interpolatie te openen en te sluiten. In deze letterlijke tekenreeksen { hoeven } tekens niet te worden ontsnapt:

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

Het aantal % tekens dat nodig is voor notatieaanduidingen wordt op dezelfde manier beïnvloed:

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

Zie ook