Interpolované řetězce

Interpolované řetězce jsou řetězce, které umožňují vložit výrazy jazyka F#do nich. Jsou užitečné v široké škále scénářů, kdy se hodnota řetězce může změnit na základě výsledku hodnoty nebo výrazu.

Syntaxe

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

Poznámky

Interpolované řetězce umožňují psát kód v "dírách" uvnitř řetězcového literálu. Tady je základní příklad:

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

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

Obsah mezi jednotlivými {} dvojicemi závorek může být libovolný výraz jazyka F#.

Pro interpolaci s řetězcovou hodnotou v jazyce F# 11 používá neformátovaný výraz převod jazyka string F#. Pokud se výraz vyhodnotí jako null, použije se prázdný řetězec. Dřívější kompilátory by mohly optimalizovat některé interpolace pouze řetězce, ale jinak používaly formátování printf; Informace o rozdílech formátování najdete v tématu Nativní interpolace AOT a interpolace hodnot řetězců .

U interpolovaných řetězců se specifikátory formátu (například %s{expr} ) %d{expr}se převod řídí pravidly definovanými pro specifikátor konkrétního formátu. Pokud chcete utéct {} páru závorek, napište dva z nich takto:

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

Typované interpolované řetězce

Interpolované řetězce můžou mít také specifikátory formátu F#, které vynucují bezpečnost typů.

let name = "Phillip"
let age = 30

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

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

V předchozím příkladu kód omylem předává age hodnotu, kde name by měla být, a naopak. Protože interpolované řetězce používají specifikátory formátu, jedná se o chybu kompilace místo drobné chyby modulu runtime.

Doslovné interpolované řetězce

Jazyk F# podporuje doslovné interpolované řetězce dvěma způsoby:

Použití $@ nebo @$ předpona

Interpolační předponu můžete kombinovat s předponou $@ doslovné řetězce v libovolném pořadí. Doslovné řetězce ignorují řídicí sekvence (s výjimkou "" uvozovek) a mohou přesahovat více řádků. To je zvlášť užitečné při práci s cestami k souborům nebo řetězci obsahujícími zpětné lomítka a uvozovky.

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"

Použití trojitých uvozovek

Jazyk F# také podporuje doslovné interpolované řetězce s trojitými uvozovkami, abyste mohli vkládat řetězcové literály bez odvozování.

let age = 30

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

Specifikátory formátu

Specifikátory formátu mohou být buď ve stylu printf, nebo . Styl NET. Specifikátory stylu Printf jsou ty, které jsou pokryté formátováním prostého textu, umístěné před složenými závorkami. Například:

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

Specifikátor %A formátu je zvláště užitečný pro vytváření diagnostických výstupů strukturovaných dat F#.

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

. Specifikátory stylu NET jsou ty, které lze použít s String.Format, umístěné za : uvnitř složených závorek. Například:

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

Je-li . Specifikátor stylu NET obsahuje neobvyklý znak, který lze uvozit pomocí dvojitých zpětných znamétek:

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

Zarovnání výrazů v interpolovaných řetězcích

Výrazy v interpolovaných řetězcích | můžete zarovnat doleva nebo doprava a určit počet mezer. Následující interpolovaný řetězec zarovná výrazy doleva a doprava (v uvedeném pořadí) o sedm mezer.

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

Interpolované řetězce a FormattableString formátování

Můžete také použít formátování, které dodržuje pravidla pro 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."

Interpolovaný řetězec lze také zadat jako FormattableString typ anotace 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.

Všimněte si, že poznámka k typu musí být u interpolovaného řetězcového výrazu samotného. Jazyk F# implicitně nepřevádí interpolovaný řetězec na FormattableString.

Rozšířená syntaxe pro interpolaci řetězců

Počínaje jazykem F# 8 můžete při práci s textem, který už obsahuje více {} znaků%, použít rozšířenou syntaxi interpolace řetězců k odebrání nutnosti odvozování.

Trojité řetězcové literály uvozovek mohou začínat více $ znaky, což změní počet závorek potřebných k otevření a zavření interpolace. V těchto řetězcových literálechach {}

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

Počet znaků potřebných % pro specifikátory formátu je ovlivněn stejným způsobem:

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

Nativní interpolace AOT a řetězcové hodnoty

Pokud chcete formátovat text bez modulu formátování založeného na odrazu, použijte interpolaci s řetězcovou hodnotou s prostými nebo .NET formátovacími otvory:

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

F# 11 používá přímé převody a System.String.Concat pro další interpolace s řetězcovou hodnotou. Díra .NET formátu používá invariantní String.Format a pole argumentu. Tyto změny kompilátoru podporují nativní AOT bez nutnosti moderního sestavení Core; další kód aplikace může stále potřebovat reflexi.

Otvory ve stylu printf, které vyžadují formátování tiskovéhofu, například %04d{number} nebo %A{record}, můžou stále používat cestu založenou na odrazu. Holé %s, , %c, %d, %ia %M díry si zachovávají kontroly typů a vyhněte se formátování tisku. Na další specifikátory, včetně %u, se tato optimalizace nevztahuje. Interpolace použitá jako PrintfFormat hodnota je také odlišná od interpolace, jejíž typ výsledku je string.

Kompatibilita jazykové verze a formátu

Prosté díry používají převod jazyka string F#; .NET díry ve formátu používají neutrální formátování. Pokud chcete vytvořit lokalizovaný výstup, vyberte jazykovou verzi explicitně:

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

Při upgradu zkontrolujte lokalizovaný výstup. FormattableString zachovává argumenty pro pozdější formátování založené na zprostředkovateli místo toho, aby se tomuto zřetězení cesty.

Upozornění FS3884 identifikuje nepoužitou funkci nebo delegáta v interpolačním otvoru. Použijte funkci, pokud jste chtěli její výsledek:

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

Zápis hodnoty do standardního výstupu

Pokud chcete napsat hodnotu bez formátu printf, FSharp.Core 11 přidá print a printn. Používají string převod; printn přidá nový řádek:

print "Parcels: "
printn 3

Pro strukturální %A výstup použijte formátování prostého textu.

Záznam a sjednocování výstupu bez reflexe

V --reflectionfreepřípadě , F# 11 může generovat smysluplné ToString implementace pro záznamy a sjednocení místo zobrazení pouze název typu:

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

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

Ukázkový projekt povolí příznak. Výstup se liší od %Atypů polí a také potřebují vhodné ToString implementace.

Viz také