Interpolált sztringek

Az interpolált sztringek olyan sztringek , amelyek lehetővé teszik F#-kifejezések beágyazását ezekbe. Számos olyan forgatókönyvben hasznosak, ahol egy sztring értéke egy érték vagy kifejezés eredménye alapján változhat.

Szemantika

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

Megjegyzések

Az interpolált sztringek lehetővé teszik a kód írását egy sztringkonstanson belüli "lyukakba". Íme egy egyszerű példa:

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

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

Az egyes {} zárójelpárok közötti tartalom bármilyen F#-kifejezés lehet.

Az F# 11 sztringértékű interpolációja esetén egy formázatlan kifejezés az F# string -konverziót használja. Ha a kifejezés kiértékelése üres nullsztringet használ. A korábbi fordítók optimalizálhattak néhány csak sztringes interpolációt, de máskülönben nyomtatóformázást használtak; lásd : Natív AOT és sztringértékű interpoláció a formázási különbségekért.

Az interpolált, formátumjelölőkkel (például %s{expr} vagy %d{expr}) rendelkező interpolált sztringek esetében az átalakítás az adott formátumjelölőhöz meghatározott szabályokat követi. Ha meg szeretne szabadulni egy {} kapcsos zárójelpártól, írjon közülük kettőt a következőképpen:

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

Beírt interpolált sztringek

Az interpolált sztringek F#-formátumkijelölőkkel is rendelkezhetnek a típusbiztonság kikényszerítéséhez.

let name = "Phillip"
let age = 30

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

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

Az előző példában a kód tévesen adja át azt az age értéket, ahol name lennie kell, és fordítva. Mivel az interpolált sztringek formátumjelölőket használnak, ez fordítási hiba, nem pedig finom futásidejű hiba.

Szó szerinti interpolált sztringek

Az F# kétféleképpen támogatja a szó szerinti interpolált sztringeket:

Használat $@ vagy @$ előtag

Az interpolációs előtagot $ tetszőleges sorrendben kombinálhatja a szó szerinti karakterlánc előtagjával @ . A verbatim sztringek figyelmen kívül hagyják a feloldósorozatokat (kivéve "" az idézőjelet), és több sorra is kiterjedhetnek. Ez különösen akkor hasznos, ha fordított perjeleket és idézőjeleket tartalmazó fájlútvonalakkal vagy sztringekkel dolgozik.

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"

Három idézőjel használata

Az F# támogatja a szó szerinti interpolált sztringeket is tripla idézőjelekkel, így a sztringkonstansokat anélkül ágyazhatja be, hogy elszabadulna.

let age = 30

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

Formázási definiálók

A formátumjelölők lehetnek printf stílusúak vagy . NET-stílus. A printf-style kijelölők a kapcsos zárójelek elé helyezett egyszerű szöveges formázással lefedett elemek. Például:

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

A formátumkijelölő %A különösen hasznos strukturált F#-adatok diagnosztikai kimenetének előállításához.

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

. A NET-stílusú megadók azok, amelyek a String.Formatzárójelek közé : kerülnek. Például:

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

Ha a . A NET-stílusjelölő szokatlan karaktert tartalmaz, majd kettős háttetűkkel szöktethető meg:

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

Kifejezések igazítása interpolált sztringekben

Az interpolált sztringeken | belüli kifejezéseket balra igazíthatja vagy jobbra igazíthatja, és megadhatja, hogy hány szóköz legyen. Az alábbi interpolált sztring hét szóközzel igazítja a bal és a jobb oldali kifejezéseket balra és jobbra.

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

Interpolált sztringek és FormattableString formázás

Olyan formázást is alkalmazhat, amely betartja a következőhöz tartozó szabályokat 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."

Emellett egy interpolált sztring típusjegyzetként FormattableString is ellenőrizhető:

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

Vegye figyelembe, hogy a típusjegyzetnek magának az interpolált sztringkifejezésnek kell lennie. Az F# nem konvertál implicit módon egy interpolált sztringet FormattableString.

A sztring interpolációjának bővített szintaxisa

Az F# 8-tól kezdve, ha több {, } vagy % már karaktert tartalmazó szöveggel dolgozik, kiterjesztett sztring interpolációs szintaxissal eltávolíthatja a menekülés szükségességét.

A három idézőjeles sztringkonstansok több $ karakterből állhatnak, ami megváltoztatja, hogy hány kapcsos zárójel szükséges az interpoláció megnyitásához és bezárásához. Ezekben a sztringkonstansokban { a } karaktereket nem kell feloldani:

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

A formátumjelölőkhöz szükséges karakterek száma % ugyanúgy változik:

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

Natív AOT és sztringértékű interpoláció

Ha tükröződésalapú formázási motor nélkül szeretné formázni a szöveget, használjon sztringértékű interpolációt egyszerű vagy .NET formátumú lyukakkal:

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

Az F# 11 közvetlen konverziókat és System.String.Concat sztringértékű interpolációkat használ. A .NET formátumú furat String.Format invariánst használ, és az argumentumot beszúrja. Ezek a fordítómódosítások támogatják a natív AOT-t a modern Core-build megkövetelése nélkül; más alkalmazáskódnak továbbra is tükröződnie kell.

A nyomtatásif-stílusú lyukak, amelyek nyomtatásformázást igényelnek, például %04d{number} vagy %A{record}, továbbra is használhatják a tükröződésalapú elérési utat. A csupasz %s, %ca , %d, %iés %M a lyukak megőrzik a típusellenőrzéseket, és elkerülik a nyomtatóformázást. Az optimalizálás nem fedi le a többi meghatározót, köztük %uazokat is. Az értékként PrintfFormat használt interpoláció az eredménytípustól stringis eltér.

Kulturális és formátumkompatibilitás

Az egyszerű lyukak az F#-átalakítást string használják; .NET formázási lyukak invariáns formázást használnak. A honosított kimenet létrehozásához válassza ki explicit módon a kultúrát:

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

Ellenőrizze a honosított kimenetet a frissítéskor. FormattableString Az összefűzési útvonal követése helyett megtartja a későbbi szolgáltatói formázás argumentumait.

Az FS3884 figyelmeztetés egy nem jóváhagyott függvényt vagy delegáltat azonosít egy interpolációs lyukban. Alkalmazza a függvényt, ha az eredményt kívánta:

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

Érték írása standard kimenetbe

Ha nyomtatási formátum nélkül szeretne értéket írni, az FSharp.Core 11 hozzáadja és hozzáadja print a printn. Átalakítást használnak string ; printn új vonalat adnak hozzá:

print "Parcels: "
printn 3

A szerkezeti %A kimenethez használjon egyszerű szöveges formázást.

A kimenet rögzítése és egyesülése tükröződés nélkül

Az --reflectionfreeF# 11 képes értelmes ToString implementációkat létrehozni rekordokhoz és egyesítésekhez ahelyett, hogy csak a típusnevet jeleníti meg:

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

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

A mintaprojekt engedélyezi a jelölőt. A kimenet eltér; %Aa mezőtípusoknak is megfelelő ToString implementációra van szükségük.

Lásd még

  • Utolsó frissítés időpontja: